Updated script that can be controled by Nodejs web app

lib/python3.13/site-packages/webdriver_manager/drivers/chrome.py

@@ -0,0 +1,97 @@
+from packaging import version
+
+from webdriver_manager.core.driver import Driver
+from webdriver_manager.core.logger import log
+from webdriver_manager.core.os_manager import ChromeType
+import json
+
+
+class ChromeDriver(Driver):
+
+    def __init__(
+            self,
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager,
+            chrome_type=ChromeType.GOOGLE
+    ):
+        super(ChromeDriver, self).__init__(
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager
+        )
+        self._browser_type = chrome_type
+
+    def get_driver_download_url(self, os_type):
+        driver_version_to_download = self.get_driver_version_to_download()
+        # For Mac ARM CPUs after version 106.0.5249.61 the format of OS type changed
+        # to more unified "mac_arm64". For newer versions, it'll be "mac_arm64"
+        # by default, for lower versions we replace "mac_arm64" to old format - "mac64_m1".
+        if version.parse(driver_version_to_download) < version.parse("106.0.5249.61"):
+            os_type = os_type.replace("mac_arm64", "mac64_m1")
+
+        if version.parse(driver_version_to_download) >= version.parse("115"):
+            if os_type == "mac64":
+                os_type = "mac-x64"
+            if os_type in ["mac_64", "mac64_m1", "mac_arm64"]:
+                os_type = "mac-arm64"
+
+            modern_version_url = self.get_url_for_version_and_platform(driver_version_to_download, os_type)
+            log(f"Modern chrome version {modern_version_url}")
+            return modern_version_url
+
+        return f"{self._url}/{driver_version_to_download}/{self.get_name()}_{os_type}.zip"
+
+    def get_browser_type(self):
+        return self._browser_type
+
+    def get_latest_release_version(self):
+        determined_browser_version = self.get_browser_version_from_os()
+        log(f"Get LATEST {self._name} version for {self._browser_type}")
+        if determined_browser_version is not None and version.parse(determined_browser_version) >= version.parse("115"):
+            url = "https://googlechromelabs.github.io/chrome-for-testing/latest-patch-versions-per-build.json"
+            response = self._http_client.get(url)
+            response_dict = json.loads(response.text)
+            determined_browser_version = response_dict.get("builds").get(determined_browser_version).get("version")
+            return determined_browser_version
+        elif determined_browser_version is not None:
+            # Remove the build version (the last segment) from determined_browser_version for version < 113
+            determined_browser_version = ".".join(determined_browser_version.split(".")[:3])
+            latest_release_url = f"{self._latest_release_url}_{determined_browser_version}"
+        else:
+            latest_release_url = self._latest_release_url
+
+        resp = self._http_client.get(url=latest_release_url)
+        return resp.text.rstrip()
+
+    def get_url_for_version_and_platform(self, browser_version, platform):
+        url = "https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json"
+        response = self._http_client.get(url)
+        data = response.json()
+        versions = data["versions"]
+
+        if version.parse(browser_version) >= version.parse("115"):
+            short_version = ".".join(browser_version.split(".")[:3])
+            compatible_versions = [v for v in versions if short_version in v["version"]]
+            if compatible_versions:
+                latest_version = compatible_versions[-1]
+                log(f"WebDriver version {latest_version['version']} selected")
+                downloads = latest_version["downloads"]["chromedriver"]
+                for d in downloads:
+                    if d["platform"] == platform:
+                        return d["url"]
+        else:
+            for v in versions:
+                if v["version"] == browser_version:
+                    downloads = v["downloads"]["chromedriver"]
+                    for d in downloads:
+                        if d["platform"] == platform:
+                            return d["url"]
+
+        raise Exception(f"No such driver version {browser_version} for {platform}")

lib/python3.13/site-packages/webdriver_manager/drivers/edge.py

@@ -0,0 +1,55 @@
+from webdriver_manager.core.driver import Driver
+from webdriver_manager.core.logger import log
+from webdriver_manager.core.os_manager import OSType, ChromeType
+
+
+class EdgeChromiumDriver(Driver):
+
+    def __init__(
+            self,
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager
+    ):
+        super(EdgeChromiumDriver, self).__init__(
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager
+        )
+
+    def get_stable_release_version(self):
+        """Stable driver version when browser version was not determined."""
+        stable_url = self._latest_release_url.replace("LATEST_RELEASE", "LATEST_STABLE")
+        resp = self._http_client.get(url=stable_url)
+        return resp.text.rstrip()
+
+    def get_latest_release_version(self) -> str:
+        determined_browser_version = self.get_browser_version_from_os()
+        log(f"Get LATEST {self._name} version for Edge {determined_browser_version}")
+
+        edge_driver_version_to_download = (
+            self.get_stable_release_version()
+            if (determined_browser_version is None)
+            else determined_browser_version
+        )
+        major_edge_version = edge_driver_version_to_download.split(".")[0]
+        os_type = self._os_system_manager.get_os_type()
+        latest_release_url = {
+            OSType.WIN
+            in os_type: f"{self._latest_release_url}_{major_edge_version}_WINDOWS",
+            OSType.MAC
+            in os_type: f"{self._latest_release_url}_{major_edge_version}_MACOS",
+            OSType.LINUX
+            in os_type: f"{self._latest_release_url}_{major_edge_version}_LINUX",
+        }[True]
+        resp = self._http_client.get(url=latest_release_url)
+        return resp.text.rstrip()
+
+    def get_browser_type(self):
+        return ChromeType.MSEDGE

lib/python3.13/site-packages/webdriver_manager/drivers/firefox.py

@@ -0,0 +1,57 @@
+from webdriver_manager.core.driver import Driver
+from webdriver_manager.core.logger import log
+
+
+class GeckoDriver(Driver):
+    def __init__(
+            self,
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            mozila_release_tag,
+            http_client,
+            os_system_manager
+    ):
+        super(GeckoDriver, self).__init__(
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager,
+        )
+        self._mozila_release_tag = mozila_release_tag
+
+    def get_latest_release_version(self) -> str:
+        determined_browser_version = self.get_browser_version_from_os()
+        log(f"Get LATEST {self._name} version for {determined_browser_version} firefox")
+        resp = self._http_client.get(
+            url=self.latest_release_url,
+            headers=self.auth_header
+        )
+        return resp.json()["tag_name"]
+
+    def get_driver_download_url(self, os_type):
+        """Like https://github.com/mozilla/geckodriver/releases/download/v0.11.1/geckodriver-v0.11.1-linux64.tar.gz"""
+        driver_version_to_download = self.get_driver_version_to_download()
+        log(f"Getting latest mozilla release info for {driver_version_to_download}")
+        resp = self._http_client.get(
+            url=self.tagged_release_url(driver_version_to_download),
+            headers=self.auth_header
+        )
+        assets = resp.json()["assets"]
+        name = f"{self.get_name()}-{driver_version_to_download}-{os_type}."
+        output_dict = [
+            asset for asset in assets if asset["name"].startswith(name)]
+        return output_dict[0]["browser_download_url"]
+
+    @property
+    def latest_release_url(self):
+        return self._latest_release_url
+
+    def tagged_release_url(self, version):
+        return self._mozila_release_tag.format(version)
+
+    def get_browser_type(self):
+        return "firefox"

lib/python3.13/site-packages/webdriver_manager/drivers/ie.py

@@ -0,0 +1,82 @@
+from webdriver_manager.core.driver import Driver
+from webdriver_manager.core.logger import log
+
+
+class IEDriver(Driver):
+
+    def __init__(
+            self,
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            ie_release_tag,
+            http_client,
+            os_system_manager
+    ):
+        super(IEDriver, self).__init__(
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager
+        )
+        self._ie_release_tag = ie_release_tag
+        # todo: for 'browser_version' implement installed IE version detection
+        #       like chrome or firefox
+
+    def get_latest_release_version(self) -> str:
+        log(f"Get LATEST driver version for Internet Explorer")
+        resp = self._http_client.get(
+            url=self.latest_release_url,
+            headers=self.auth_header
+        )
+
+        releases = resp.json()
+        release = next(
+            release
+            for release in releases
+            for asset in release["assets"]
+            if asset["name"].startswith(self.get_name())
+        )
+        return release["tag_name"].replace("selenium-", "")
+
+    def get_driver_download_url(self, os_type):
+        """Like https://github.com/seleniumhq/selenium/releases/download/3.141.59/IEDriverServer_Win32_3.141.59.zip"""
+        driver_version_to_download = self.get_driver_version_to_download()
+        log(f"Getting latest ie release info for {driver_version_to_download}")
+        resp = self._http_client.get(
+            url=self.tagged_release_url(driver_version_to_download),
+            headers=self.auth_header
+        )
+
+        assets = resp.json()["assets"]
+
+        name = f"{self._name}_{os_type}_{driver_version_to_download}" + "."
+        output_dict = [
+            asset for asset in assets if asset["name"].startswith(name)]
+        return output_dict[0]["browser_download_url"]
+
+    @property
+    def latest_release_url(self):
+        return self._latest_release_url
+
+    def tagged_release_url(self, version):
+        version = self.__get_divided_version(version)
+        return self._ie_release_tag.format(version)
+
+    def __get_divided_version(self, version):
+        divided_version = version.split(".")
+        if len(divided_version) == 2:
+            return f"{version}.0"
+        elif len(divided_version) == 3:
+            return version
+        else:
+            raise ValueError(
+                "Version must consist of major, minor and/or patch, "
+                "but given was: '{version}'".format(version=version)
+            )
+
+    def get_browser_type(self):
+        return "msie"

lib/python3.13/site-packages/webdriver_manager/drivers/opera.py

@@ -0,0 +1,55 @@
+from webdriver_manager.core.driver import Driver
+from webdriver_manager.core.logger import log
+
+
+class OperaDriver(Driver):
+    def __init__(
+            self,
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            opera_release_tag,
+            http_client,
+            os_system_manager
+    ):
+        super(OperaDriver, self).__init__(
+            name,
+            driver_version,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager
+        )
+        self.opera_release_tag = opera_release_tag
+
+    def get_latest_release_version(self) -> str:
+        resp = self._http_client.get(
+            url=self.latest_release_url,
+            headers=self.auth_header
+        )
+        return resp.json()["tag_name"]
+
+    def get_driver_download_url(self, os_type) -> str:
+        """Like https://github.com/operasoftware/operachromiumdriver/releases/download/v.2.45/operadriver_linux64.zip"""
+        driver_version_to_download = self.get_driver_version_to_download()
+        log(f"Getting latest opera release info for {driver_version_to_download}")
+        resp = self._http_client.get(
+            url=self.tagged_release_url(driver_version_to_download),
+            headers=self.auth_header
+        )
+        assets = resp.json()["assets"]
+        name = "{0}_{1}".format(self.get_name(), os_type)
+        output_dict = [
+            asset for asset in assets if asset["name"].startswith(name)]
+        return output_dict[0]["browser_download_url"]
+
+    @property
+    def latest_release_url(self):
+        return self._latest_release_url
+
+    def tagged_release_url(self, version):
+        return self.opera_release_tag.format(version)
+
+    def get_browser_type(self):
+        return "opera"