Switch to a custom Chrome downloader

It turns out that the Web Driver Manager downloads the very latest version of Chrome every time which causes conflicts on the machines that have slightly older versions:

```
selenium.common.exceptions.SessionNotCreatedException: Message: session not created: This version of ChromeDriver only supports Chrome version 133
Current browser version is 132.0.6834.110 with binary path /Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing
```

strictdoc-project/strictdoc#2077 (comment)

Author: stanislaw

html2print/html2print.py

@@ -3,10 +3,13 @@
 import atexit
 import base64
 import os.path
+import platform
+import re
+import subprocess
 import sys
+import zipfile
 from datetime import datetime
 from pathlib import Path
-from shutil import copy
 from time import sleep
 from typing import Dict, List, Optional
 
@@ -15,15 +18,9 @@
 from selenium import webdriver
 from selenium.webdriver.chrome.options import Options
 from selenium.webdriver.chrome.service import Service
-from webdriver_manager.chrome import ChromeDriverManager
-from webdriver_manager.core.download_manager import WDMDownloadManager
-from webdriver_manager.core.driver import Driver
-from webdriver_manager.core.driver_cache import DriverCacheManager
-from webdriver_manager.core.file_manager import FileManager
-from webdriver_manager.core.http import HttpClient
-from webdriver_manager.core.os_manager import OperationSystemManager
+from webdriver_manager.core.os_manager import ChromeType, OperationSystemManager
 
-__version__ = "0.0.8"
+__version__ = "0.0.12"
 
 PATH_TO_HTML2PDF_JS = os.path.join(
     os.path.dirname(os.path.join(__file__)), "html2pdf_js", "html2pdf.min.js"
@@ -39,52 +36,40 @@
 sys.stdout = open(sys.stdout.fileno(), mode="w", encoding="utf8", closefd=False)
 
 
-class HTML2Print_HTTPClient(HttpClient):
-    def get(self, url, params=None, **kwargs) -> Response:
-        last_error: Optional[Exception] = None
-        for attempt in range(1, 3):
-            print(  # noqa: T201
-                f"html2print: sending GET request attempt {attempt}: {url}"
-            )
-            try:
-                return requests.get(url, params, timeout=(5, 5), **kwargs)
-            except requests.exceptions.ConnectTimeout as connect_timeout_:
-                last_error = connect_timeout_
-            except requests.exceptions.ReadTimeout as read_timeout_:
-                last_error = read_timeout_
-            except Exception as exception_:
-                raise AssertionError(
-                    "html2print: unknown exception", exception_
-                ) from None
+class ChromeDriverManager:
+    def get_chrome_driver(self, path_to_cache_dir: str):
+        chrome_version = self.get_chrome_version()
+        chrome_major_version = chrome_version.split(".")[0]
+
         print(  # noqa: T201
-            f"html2print: "
-            f"failed to get response for URL: {url} with error: {last_error}"
+            f"html2print: Installed Chrome version: {chrome_version}"
         )
 
+        system_map = {
+            "Windows": "win32",
+            "Darwin": "mac-arm64"
+            if platform.machine() == "arm64"
+            else "mac-x64",
+            "Linux": "linux64",
+        }
+        os_type = system_map[platform.system()]
+        is_windows = platform.system() == "Windows"
 
-class HTML2Print_CacheManager(DriverCacheManager):
-    def __init__(self, file_manager: FileManager, path_to_cache_dir: str):
-        super().__init__(file_manager=file_manager)
-        self.path_to_cache_dir: str = path_to_cache_dir
-
-    def find_driver(self, driver: Driver):
-        path_to_cached_chrome_driver_dir = os.path.join(
-            self.path_to_cache_dir, "chromedriver"
-        )
-
-        os_type = self.get_os_type()
-        browser_type = driver.get_browser_type()
-        browser_version = self._os_system_manager.get_browser_version_from_os(
-            browser_type
+        print(  # noqa: T201
+            f"html2print: OS system: {platform.system()}, OS type: {os_type}."
         )
-        assert browser_version is not None, browser_version
 
         path_to_cached_chrome_driver_dir = os.path.join(
-            path_to_cached_chrome_driver_dir, browser_version, os_type
+            path_to_cache_dir, chrome_major_version
         )
         path_to_cached_chrome_driver = os.path.join(
-            path_to_cached_chrome_driver_dir, "chromedriver"
+            path_to_cached_chrome_driver_dir,
+            f"chromedriver-{os_type}",
+            "chromedriver",
         )
+        if is_windows:
+            path_to_cached_chrome_driver += ".exe"
+
         if os.path.isfile(path_to_cached_chrome_driver):
             print(  # noqa: T201
                 f"html2print: ChromeDriver exists in the local cache: "
@@ -95,25 +80,144 @@ def find_driver(self, driver: Driver):
             f"html2print: ChromeDriver does not exist in the local cache: "
             f"{path_to_cached_chrome_driver}"
         )
-        path_to_downloaded_chrome_driver = super().find_driver(driver)
-        if path_to_downloaded_chrome_driver is None:
-            print(  # noqa: T201
-                f"html2print: could not get a downloaded ChromeDriver: "
-                f"{path_to_cached_chrome_driver}"
+
+        path_to_downloaded_chrome_driver = self._download_chromedriver(
+            chrome_major_version,
+            os_type,
+            path_to_cached_chrome_driver_dir,
+            path_to_cached_chrome_driver,
+        )
+        assert os.path.isfile(path_to_downloaded_chrome_driver)
+        os.chmod(path_to_downloaded_chrome_driver, 0o755)
+
+        return path_to_downloaded_chrome_driver
+
+    @staticmethod
+    def _download_chromedriver(
+        chrome_major_version,
+        os_type: str,
+        path_to_driver_cache_dir,
+        path_to_cached_chrome_driver,
+    ):
+        url = "https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json"
+        response = ChromeDriverManager.send_http_get_request(url).json()
+
+        matching_versions = [
+            item
+            for item in response["versions"]
+            if item["version"].startswith(chrome_major_version)
+        ]
+
+        if not matching_versions:
+            raise Exception(
+                f"No compatible ChromeDriver found for Chrome version {chrome_major_version}"
+            )
+
+        latest_version = matching_versions[-1]
+
+        driver_url: str
+        chrome_downloadable_versions = latest_version["downloads"][
+            "chromedriver"
+        ]
+        for chrome_downloadable_version_ in chrome_downloadable_versions:
+            if chrome_downloadable_version_["platform"] == os_type:
+                driver_url = chrome_downloadable_version_["url"]
+                break
+        else:
+            raise RuntimeError(
+                f"Could not find a downloadable URL from downloadable versions: {chrome_downloadable_versions}"
             )
-            return None
 
         print(  # noqa: T201
-            f"html2print: saving chromedriver to StrictDoc's local cache: "
-            f"{path_to_downloaded_chrome_driver} -> {path_to_cached_chrome_driver}"
+            f"html2print: downloading ChromeDriver from: {driver_url}"
         )
-        Path(path_to_cached_chrome_driver_dir).mkdir(
-            parents=True, exist_ok=True
+        response = ChromeDriverManager.send_http_get_request(driver_url)
+
+        Path(path_to_driver_cache_dir).mkdir(parents=True, exist_ok=True)
+        zip_path = os.path.join(path_to_driver_cache_dir, "chromedriver.zip")
+        print(  # noqa: T201
+            f"html2print: saving downloaded ChromeDriver to path: {zip_path}"
         )
-        copy(path_to_downloaded_chrome_driver, path_to_cached_chrome_driver)
+        with open(zip_path, "wb") as file:
+            file.write(response.content)
 
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall(path_to_driver_cache_dir)
+
+        print(  # noqa: T201
+            f"html2print: ChromeDriver downloaded to: {path_to_cached_chrome_driver}"
+        )
         return path_to_cached_chrome_driver
 
+    @staticmethod
+    def send_http_get_request(url, params=None, **kwargs) -> Response:
+        last_error: Optional[Exception] = None
+        for attempt in range(1, 4):
+            print(  # noqa: T201
+                f"html2print: sending GET request attempt {attempt}: {url}"
+            )
+            try:
+                return requests.get(url, params, timeout=(5, 5), **kwargs)
+            except requests.exceptions.ConnectTimeout as connect_timeout_:
+                last_error = connect_timeout_
+            except requests.exceptions.ReadTimeout as read_timeout_:
+                last_error = read_timeout_
+            except Exception as exception_:
+                raise AssertionError(
+                    "html2print: unknown exception", exception_
+                ) from None
+        print(  # noqa: T201
+            f"html2print: "
+            f"failed to get response for URL: {url} with error: {last_error}"
+        )
+
+    @staticmethod
+    def get_chrome_version():
+        # Special case: GitHub Actions macOS CI machines have both
+        # Google Chrome for Testing and normal Google Chrome installed, and
+        # sometimes their versions are of different major version families.
+        # The solution is to check if the Google Chrome for Testing is available,
+        # and use its version instead of the normal one.
+        if platform.system() == "Darwin":
+            chrome_path = "/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"
+            try:
+                print(  # noqa: T201
+                    "html2print: "
+                    "checking if there is Google Chrome for Testing instead of "
+                    "a normal Chrome available."
+                )
+
+                version_output = subprocess.run(
+                    [chrome_path, "--version"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                chrome_version = version_output.stdout.strip()
+                match = re.search(r"\d+(\.\d+)+", chrome_version)
+                if not match:
+                    raise RuntimeError(
+                        "Cannot extract the version part using regex."
+                    )
+
+                chrome_version = match.group(0)
+
+                print(  # noqa: T201
+                    f"html2print: Google Chrome for Testing Version: {chrome_version}"
+                )
+
+                return chrome_version
+            except FileNotFoundError:
+                print("html2print: Chrome for Testing not available.")  # noqa: T201
+            except Exception as e:
+                print(  # noqa: T201
+                    f"html2print: Error getting Google Chrome for Testing version: {e}"
+                )
+
+        os_manager = OperationSystemManager(os_type=None)
+        version = os_manager.get_browser_version_from_os(ChromeType.GOOGLE)
+        return version
+
 
 def get_inches_from_millimeters(mm: float) -> float:
     return mm / 25.4
@@ -190,23 +294,12 @@ class Done(Exception):
     return data
 
 
-def get_chrome_driver(path_to_cache_dir: str) -> str:
-    cache_manager = HTML2Print_CacheManager(
-        file_manager=FileManager(os_system_manager=OperationSystemManager()),
-        path_to_cache_dir=path_to_cache_dir,
-    )
-
-    http_client = HTML2Print_HTTPClient()
-    download_manager = WDMDownloadManager(http_client)
-    path_to_chrome = ChromeDriverManager(
-        download_manager=download_manager, cache_manager=cache_manager
-    ).install()
-    return path_to_chrome
-
-
 def create_webdriver(chromedriver: Optional[str], path_to_cache_dir: str):
+    print("html2print: creating ChromeDriver service.", flush=True)  # noqa: T201
     if chromedriver is None:
-        path_to_chrome = get_chrome_driver(path_to_cache_dir)
+        path_to_chrome = ChromeDriverManager().get_chrome_driver(
+            path_to_cache_dir
+        )
     else:
         path_to_chrome = chromedriver
     print(f"html2print: ChromeDriver available at path: {path_to_chrome}")  # noqa: T201
@@ -254,6 +347,8 @@ def main():
     command_subparsers = parser.add_subparsers(title="command", dest="command")
     command_subparsers.required = True
 
+    print(f"html2print: version {__version__}")  # noqa: T201
+
     #
     # Get driver command.
     #
@@ -295,22 +390,20 @@ def main():
     path_to_cache_dir: str
     if args.command == "get_driver":
         path_to_cache_dir = (
-            args.cache_dir
-            if args.cache_dir is not None
-            else (DEFAULT_CACHE_DIR)
+            args.cache_dir if args.cache_dir is not None else DEFAULT_CACHE_DIR
         )
 
-        path_to_chrome = get_chrome_driver(path_to_cache_dir)
+        path_to_chrome = ChromeDriverManager().get_chrome_driver(
+            path_to_cache_dir
+        )
         print(f"html2print: ChromeDriver available at path: {path_to_chrome}")  # noqa: T201
         sys.exit(0)
 
     elif args.command == "print":
         paths: List[str] = args.paths
 
         path_to_cache_dir = (
-            args.cache_dir
-            if args.cache_dir is not None
-            else (DEFAULT_CACHE_DIR)
+            args.cache_dir if args.cache_dir is not None else DEFAULT_CACHE_DIR
         )
         driver = create_webdriver(args.chromedriver, path_to_cache_dir)