get-chrome-driver 1.4__py3-none-any.whl

get_chrome_driver/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "1.4"
+
+from get_chrome_driver.get_driver import GetChromeDriver

get_chrome_driver/app.py

@@ -0,0 +1,241 @@
+import typer
+
+from get_chrome_driver import __version__
+from get_chrome_driver.enums import Phase, OsPlatform
+from get_chrome_driver.exceptions import GetChromeDriverError
+from get_chrome_driver.get_driver import GetChromeDriver
+
+app = typer.Typer(name="Get ChromeDriver", add_completion=False)
+
+
+@app.command()
+def main(
+    beta_version: bool = typer.Option(
+        default=False, help="Print the beta version", show_default=False
+    ),
+    stable_version: bool = typer.Option(
+        default=False, help="Print the stable version", show_default=False
+    ),
+    latest_urls: bool = typer.Option(
+        default=False,
+        help="print the beta and stable version download urls for all platforms",
+        show_default=False,
+    ),
+    version_url: str = typer.Option(
+        default=None, help="Print the version download url", show_default=False
+    ),
+    beta_url: bool = typer.Option(
+        default=False, help="Print the beta version download url", show_default=False
+    ),
+    stable_url: bool = typer.Option(
+        default=False, help="Print the stable version download url", show_default=False
+    ),
+    auto_download: bool = typer.Option(
+        default=False,
+        help="Download a ChromeDriver version for the installed Chrome Version",
+        show_default=False,
+    ),
+    download_beta: bool = typer.Option(
+        default=False, help="Download beta version", show_default=False
+    ),
+    download_stable: bool = typer.Option(
+        default=False, help="Download stable version", show_default=False
+    ),
+    download_version: str = typer.Option(
+        default=None, help="Download a specific version", show_default=False
+    ),
+    extract: bool = typer.Option(
+        default=False, help="Extract the compressed driver file", show_default=False
+    ),
+    version: bool = typer.Option(
+        default=False, help="Application version", show_default=False
+    ),
+):
+    """
+    Main.
+    """
+
+    if beta_version:
+        __print_latest_version(phase=Phase.beta)
+
+    elif stable_version:
+        __print_latest_version(phase=Phase.stable)
+
+    elif latest_urls:
+        __print_latest_urls()
+
+    elif version_url:
+        __print_version_url(version=version_url)
+
+    elif beta_url:
+        __print_latest_url(phase=Phase.beta)
+
+    elif stable_url:
+        __print_latest_url(phase=Phase.stable)
+
+    elif auto_download:
+        __auto_download(extract=extract)
+
+    elif download_beta:
+        __download_latest_version(phase=Phase.beta, extract=extract)
+
+    elif download_stable:
+        __download_latest_version(phase=Phase.stable, extract=extract)
+
+    elif download_version:
+        __download_version(version=download_version, extract=extract)
+
+    elif version:
+        print(f"v{__version__}")
+
+
+def __print_latest_version(phase: Phase):
+    """
+    Print latest stable version or latest beta version.
+
+    :param phase: Stable or beta.
+    """
+
+    get_driver = GetChromeDriver()
+    error = "No latest version found"
+    if phase == Phase.beta:
+        try:
+            print(get_driver.beta_version())
+        except GetChromeDriverError:
+            print(error)
+    elif phase == Phase.stable:
+        try:
+            print(get_driver.stable_version())
+        except GetChromeDriverError:
+            print(error)
+    else:
+        print(error)
+
+
+def __print_latest_urls():
+    """
+    Print the stable and beta url version for all platforms.
+    """
+
+    get_driver_win = GetChromeDriver(OsPlatform.win)
+    get_driver_linux = GetChromeDriver(OsPlatform.linux)
+    get_driver_mac = GetChromeDriver(OsPlatform.mac)
+    get_drivers = {
+        "Windows": get_driver_win,
+        "Linux": get_driver_linux,
+        "macOS": get_driver_mac,
+    }
+
+    result = ""
+    for index, (key, value) in enumerate(get_drivers.items()):
+        try:
+            result += f"Latest beta and stable version for {key}:\n"
+            result += f"stable : {value.stable_version_url()}\n"
+            result += f"beta   : {value.beta_version_url()}"
+            if index < len(get_drivers) - 1:
+                result += "\n"
+        except GetChromeDriverError:
+            continue
+
+    print(result)
+
+
+def __print_version_url(version: str):
+    """
+    Print the url of a version.
+
+    :param version: Chromedriver version.
+    """
+
+    get_driver = GetChromeDriver()
+
+    error = "Could not find version url"
+
+    try:
+        print(get_driver.version_url(version))
+    except GetChromeDriverError:
+        print(error)
+
+
+def __print_latest_url(phase: Phase):
+    """
+    Print latest stable url or latest beta url.
+
+    :param phase: Stable or beta.
+    """
+
+    get_driver = GetChromeDriver()
+
+    error = "Could not find version url"
+
+    if phase == Phase.beta:
+        try:
+            print(get_driver.beta_version_url())
+        except GetChromeDriverError:
+            print(error)
+    elif phase == Phase.stable:
+        try:
+            print(get_driver.stable_version_url())
+        except GetChromeDriverError:
+            print(error)
+
+
+def __auto_download(extract: bool):
+    """
+    Auto download driver.
+
+    :param extract: Extract the downloaded driver or not.
+    """
+
+    get_driver = GetChromeDriver()
+
+    try:
+        get_driver.auto_download(extract=extract)
+        print("Download finished")
+    except GetChromeDriverError:
+        print("An error occurred at downloading")
+
+
+def __download_latest_version(phase: Phase, extract: bool):
+    """
+    Download the driver for the stable version or beta version.
+
+    :param phase: Stable or beta.
+    :param extract: Extract the downloaded driver or not.
+    """
+
+    get_driver = GetChromeDriver()
+
+    download_complete = "Download complete"
+    beta_error = "Could not download beta version"
+    stable_error = "Could not download stable version"
+
+    if phase == Phase.beta:
+        try:
+            get_driver.download_beta_version(extract=extract)
+            print(download_complete)
+        except GetChromeDriverError:
+            print(beta_error)
+    elif phase == Phase.stable:
+        try:
+            get_driver.download_stable_version(extract=extract)
+            print(download_complete)
+        except GetChromeDriverError:
+            print(stable_error)
+
+
+def __download_version(version: str, extract: bool):
+    """
+    Download driver version.
+
+    :param version: Chromedriver version.
+    :param extract: Extract the downloaded driver or not.
+    """
+
+    get_driver = GetChromeDriver()
+
+    try:
+        get_driver.download_version(version=version, extract=extract)
+        print("Download finished")
+    except GetChromeDriverError:
+        print("Could not download version")

get_chrome_driver/constants.py

@@ -0,0 +1,10 @@
+CHROMEDRIVER_STORAGE_URL = "https://chromedriver.storage.googleapis.com"
+LAST_KNOWN_GOOD_VERSIONS_WITH_DOWNLOADS_URL = "https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions-with-downloads.json"
+LAST_KNOWN_GOOD_VERSIONS_URL = "https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json"
+KNOWN_GOOD_VERSIONS_WITH_DOWNLOADS_URL = "https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json"
+KNOWN_GOOD_VERSIONS_URL = (
+    "https://googlechromelabs.github.io/chrome-for-testing/known-good-versions.json"
+)
+CSS_SELECTOR_VERSIONS = "ul.n8H08c:nth-child(5)"
+LATEST_STABLE_VERSION_STR = "Latest stable release"
+LATEST_BETA_VERSION_STR = "Latest beta release"

get_chrome_driver/downloader.py

@@ -0,0 +1,94 @@
+import os
+import requests
+from urllib3.util.retry import Retry
+from requests.adapters import HTTPAdapter
+from urllib.parse import urlparse
+from requests.exceptions import RequestException
+from requests.exceptions import HTTPError
+
+
+def download(url: str, output_path: str = None, file_name: str = None):
+    """
+    Download a file from url.
+    If output_path is None, the file will be downloaded directly at the current directory.
+    If file_name is None, the file name from the url will be used.
+    """
+
+    session = __retry_session(
+        retries=3,
+        backoff_factor=0.1,
+        status_forcelist=[429, 500, 502, 503, 504],
+        method_whitelist=["GET"],
+    )
+    try:
+        res = session.get(url=url)
+    except RequestException as err:
+        raise RequestException(err)
+    else:
+        if res.status_code != 200:
+            raise HTTPError("Invalid URL")
+
+        if file_name == "" or file_name is None:
+            # Get the file name from the url
+            file_name = __get_file_name_from_url(url)
+
+        if output_path == "" or output_path is None:
+            file_path = file_name
+        else:
+            __makedirs(output_path)
+            file_path = output_path + "/" + file_name
+
+        with open(file_path, "wb") as file:
+            # Download the file in chunks
+            for chunk in res.iter_content(chunk_size=1048576):
+                if chunk:
+                    file.write(chunk)
+
+        return file_path, file_name
+    finally:
+        session.close()
+
+
+def __retry_session(
+    retries: int, backoff_factor: float, status_forcelist: any, method_whitelist: any
+):
+    """
+    Retry session.
+    """
+
+    retry = Retry(
+        total=retries,
+        read=retries,
+        connect=retries,
+        backoff_factor=backoff_factor,
+        status_forcelist=status_forcelist,
+        allowed_methods=method_whitelist,
+    )
+
+    adapter = HTTPAdapter(max_retries=retry)
+    session = requests.Session()
+    session.mount("http://", adapter)
+    session.mount("https://", adapter)
+    return session
+
+
+def __get_file_name_from_url(url: str):
+    """
+    Get file name from url.
+    """
+
+    path = urlparse(url).path
+
+    return path.split("/")[-1]
+
+
+def __makedirs(path: str):
+    """
+    Make dirs.
+    """
+
+    try:
+        if not os.path.exists(path):
+            os.makedirs(path, exist_ok=True)
+    except OSError as err:
+        raise OSError(err)

get_chrome_driver/enums/__init__.py

@@ -0,0 +1,3 @@
+from .os_platform import OsPlatform
+from .phase import Phase
+from .platform import Platform

get_chrome_driver/enums/os_platform.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class OsPlatform(Enum):
+    win = "win"
+    linux = "linux"
+    mac = "mac"

get_chrome_driver/enums/phase.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class Phase(Enum):
+    stable = "stable"
+    beta = "beta"

get_chrome_driver/enums/platform.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class Platform(Enum):
+    win32 = "win32"
+    win64 = "win64"
+    linux32 = "linux32"
+    linux64 = "linux64"
+    mac32 = "mac32"
+    mac64 = "mac64"
+    mac_arm64 = "mac-arm64"
+    mac_x64 = "mac-x64"

get_chrome_driver/exceptions.py

@@ -0,0 +1,22 @@
+class GetChromeDriverError(Exception):
+    pass
+
+
+class VersionUrlError(GetChromeDriverError):
+    pass
+
+
+class UnknownPlatformError(GetChromeDriverError):
+    pass
+
+
+class UnknownVersionError(GetChromeDriverError):
+    pass
+
+
+class DownloadError(GetChromeDriverError):
+    pass
+
+
+class VersionError(GetChromeDriverError):
+    pass