webdriver-manager 4.1.1__py3-none-any.whl

webdriver_manager/__init__.py

@@ -0,0 +1 @@
+__version__ = "4.1.1"

webdriver_manager/chrome.py

@@ -0,0 +1,55 @@
+import os
+from typing import Optional
+
+from webdriver_manager.core.download_manager import DownloadManager
+from webdriver_manager.core.driver_cache import DriverCacheManager
+from webdriver_manager.core.manager import DriverManager
+from webdriver_manager.core.os_manager import OperationSystemManager, ChromeType
+from webdriver_manager.drivers.chrome import ChromeDriver
+
+
+class ChromeDriverManager(DriverManager):
+    def __init__(
+            self,
+            driver_version: Optional[str] = None,
+            name: str = "chromedriver",
+            url: str = "https://storage.googleapis.com/chrome-for-testing-public/",
+            latest_release_url: str = "https://googlechromelabs.github.io/chrome-for-testing/LATEST_RELEASE_STABLE",
+            chrome_type: str = ChromeType.GOOGLE,
+            download_manager: Optional[DownloadManager] = None,
+            cache_manager: Optional[DriverCacheManager] = None,
+            os_system_manager: Optional[OperationSystemManager] = None
+    ):
+        super().__init__(
+            download_manager=download_manager,
+            cache_manager=cache_manager,
+            os_system_manager=os_system_manager
+        )
+
+        self.driver = ChromeDriver(
+            name=name,
+            driver_version=driver_version,
+            url=url,
+            latest_release_url=latest_release_url,
+            chrome_type=chrome_type,
+            http_client=self.http_client,
+            os_system_manager=os_system_manager
+        )
+
+    def install(self) -> str:
+        driver_path = self._get_driver_binary_path(self.driver)
+        os.chmod(driver_path, 0o755)
+        return driver_path
+
+    def get_os_type(self):
+        os_type = super().get_os_type()
+        if "win" in os_type:
+            return "win64" if self._os_system_manager.get_os_architecture() == 64 else "win32"
+
+        if not self._os_system_manager.is_mac_os(os_type):
+            return os_type
+
+        if self._os_system_manager.is_arch():
+            return "mac_arm64"
+
+        return os_type

webdriver_manager/core/archive.py

@@ -0,0 +1,23 @@
+import os
+import zipfile
+
+
+class LinuxZipFileWithPermissions(zipfile.ZipFile):
+    """Class for extract files in linux with right permissions"""
+
+    def extract(self, member, path=None, pwd=None):
+        if not isinstance(member, zipfile.ZipInfo):
+            member = self.getinfo(member)
+
+        if path is None:
+            path = os.getcwd()
+
+        ret_val = self._extract_member(member, path, pwd)  # noqa
+        attr = member.external_attr >> 16
+        os.chmod(ret_val, attr)
+        return ret_val
+
+
+class Archive(object):
+    def __init__(self, path: str):
+        self.file_path = path

webdriver_manager/core/config.py

@@ -0,0 +1,41 @@
+import os
+from dotenv import load_dotenv
+
+
+def str2bool(value):
+    return value.lower() in ['true', '1']
+
+
+load_dotenv()
+
+
+def ssl_verify():
+    return str2bool(os.getenv("WDM_SSL_VERIFY", "true"))
+
+
+def gh_token():
+    return os.getenv("GH_TOKEN", None)
+
+
+def wdm_local():
+    return str2bool(os.getenv("WDM_LOCAL", "false"))
+
+
+def wdm_log_level():
+    default_level = 20
+    try:
+        return int(os.getenv("WDM_LOG", default_level))
+    except Exception:
+        return default_level
+
+
+def wdm_progress_bar():
+    default_level = 1
+    try:
+        return int(os.getenv("WDM_PROGRESS_BAR", default_level))
+    except Exception:
+        return default_level
+
+
+def get_xdist_worker_id():
+    return os.getenv("PYTEST_XDIST_WORKER", '')

webdriver_manager/core/constants.py

@@ -0,0 +1,25 @@
+import os
+import sys
+import tempfile
+
+ROOT_FOLDER_NAME = ".wdm"
+
+
+def get_default_project_root_cache_path():
+    base_path = sys.path[0]
+    if getattr(sys, "frozen", False) or base_path.endswith(".zip"):
+        base_path = os.getcwd()
+    return os.path.join(base_path, ROOT_FOLDER_NAME)
+
+
+DEFAULT_PROJECT_ROOT_CACHE_PATH = get_default_project_root_cache_path()
+
+
+def get_default_user_home_cache_path():
+    home = os.path.expanduser("~")
+    if not home or home in (os.path.sep, "/") or home.startswith("~"):
+        home = tempfile.gettempdir()
+    return os.path.join(home, ROOT_FOLDER_NAME)
+
+
+DEFAULT_USER_HOME_CACHE_PATH = get_default_user_home_cache_path()

webdriver_manager/core/download_manager.py

@@ -0,0 +1,42 @@
+import os
+from abc import ABC
+
+from webdriver_manager.core.file_manager import File
+from webdriver_manager.core.http import WDMHttpClient
+from webdriver_manager.core.logger import log
+
+
+class DownloadManager(ABC):
+    def __init__(self, http_client):
+        self._http_client = http_client
+
+    def download_file(self, url: str) -> File:
+        raise NotImplementedError
+
+    @property
+    def http_client(self):
+        return self._http_client
+
+
+class WDMDownloadManager(DownloadManager):
+    def __init__(self, http_client=None):
+        if http_client is None:
+            http_client = WDMHttpClient()
+        super().__init__(http_client)
+
+    def download_file(self, url: str) -> File:
+        log(f"About to download new driver from {url}")
+        response = self._http_client.get(url)
+        log(f"Driver downloading response is {response.status_code}")
+        file_name = self.extract_filename_from_url(url)
+        return File(response, file_name)
+
+    @staticmethod
+    def extract_filename_from_url(url):
+        # Split the URL by '/'
+        url_parts = url.split('/')
+        # Get the last part of the URL, which should be the filename
+        filename = url_parts[-1]
+        # Decode the URL-encoded filename
+        filename = os.path.basename(filename)
+        return filename

webdriver_manager/core/driver.py

@@ -0,0 +1,77 @@
+from webdriver_manager.core.logger import log
+from webdriver_manager.core.config import gh_token
+from webdriver_manager.core.os_manager import OperationSystemManager
+
+
+class Driver(object):
+    def __init__(
+            self,
+            name,
+            driver_version_to_download,
+            url,
+            latest_release_url,
+            http_client,
+            os_system_manager):
+        self._name = name
+        self._url = url
+        self._latest_release_url = latest_release_url
+        self._http_client = http_client
+        self._browser_version = None
+        self._driver_version_to_download = driver_version_to_download
+        self._os_system_manager = os_system_manager
+        if not self._os_system_manager:
+            self._os_system_manager = OperationSystemManager()
+
+    @property
+    def auth_header(self):
+        token = gh_token()
+        if token:
+            log("GH_TOKEN will be used to perform requests")
+            return {"Authorization": f"token {token}"}
+        return None
+
+    def get_name(self):
+        return self._name
+
+    def get_driver_download_url(self, os_type):
+        return f"{self._url}/{self.get_driver_version_to_download()}/{self._name}_{os_type}.zip"
+
+    def get_driver_version_to_download(self):
+        """
+        Downloads version from parameter if version not None or "latest".
+        Downloads latest, if version is "latest" or browser could not been determined.
+        Downloads determined browser version driver in all other ways as a bonus fallback for lazy users.
+        """
+        if self._driver_version_to_download:
+            return self._driver_version_to_download
+
+        return self.get_latest_release_version()
+
+    def get_latest_release_version(self):
+        # type: () -> str
+        raise NotImplementedError("Please implement this method")
+
+    def get_browser_version_from_os(self):
+        """
+        Use-cases:
+        - for key in metadata;
+        - for printing nice logs;
+        - for fallback if version was not set at all.
+        Note: the fallback may have collisions in user cases when previous browser was not uninstalled properly.
+        """
+        if self._browser_version is None:
+            self._browser_version = self._os_system_manager.get_browser_version_from_os(self.get_browser_type())
+        return self._browser_version
+
+    def get_browser_type(self):
+        raise NotImplementedError("Please implement this method")
+
+    def get_binary_name(self, os_type):
+        driver_name = self.get_name()
+        driver_binary_name = (
+            "msedgedriver" if driver_name == "edgedriver" else driver_name
+        )
+        driver_binary_name = (
+            f"{driver_binary_name}.exe" if "win" in os_type else driver_binary_name
+        )
+        return driver_binary_name

webdriver_manager/core/driver_cache.py

@@ -0,0 +1,212 @@
+import datetime
+import json
+import os
+
+from webdriver_manager.core.config import wdm_local, get_xdist_worker_id
+from webdriver_manager.core.constants import (
+    DEFAULT_PROJECT_ROOT_CACHE_PATH,
+    DEFAULT_USER_HOME_CACHE_PATH, ROOT_FOLDER_NAME,
+)
+from webdriver_manager.core.driver import Driver
+from webdriver_manager.core.file_manager import FileManager, File
+from webdriver_manager.core.logger import log
+from webdriver_manager.core.os_manager import OperationSystemManager
+from webdriver_manager.core.utils import get_date_diff
+
+
+class DriverCacheManager(object):
+    def __init__(self, root_dir=None, valid_range=1, file_manager=None, os_system_manager=None):
+        self._root_dir = DEFAULT_USER_HOME_CACHE_PATH
+        is_wdm_local = wdm_local()
+        xdist_worker_id = get_xdist_worker_id()
+        if xdist_worker_id:
+            log(f"xdist worker is: {xdist_worker_id}")
+            self._root_dir = os.path.join(self._root_dir, xdist_worker_id)
+
+        if root_dir:
+            self._root_dir = os.path.join(root_dir, ROOT_FOLDER_NAME, xdist_worker_id)
+
+        if is_wdm_local:
+            self._root_dir = os.path.join(DEFAULT_PROJECT_ROOT_CACHE_PATH, xdist_worker_id)
+
+        self._drivers_root = "drivers"
+        self._drivers_json_path = os.path.join(self._root_dir, "drivers.json")
+        self._date_format = "%d/%m/%Y"
+        self._drivers_directory = os.path.join(self._root_dir, self._drivers_root)
+        self._cache_valid_days_range = valid_range
+        self._cache_key_driver_version = None
+        self._metadata_key = None
+        self._driver_binary_path = None
+        self._os_system_manager = os_system_manager
+        if not os_system_manager:
+            self._os_system_manager = OperationSystemManager()
+        self._file_manager = file_manager
+        if not self._file_manager:
+            self._file_manager = FileManager(self._os_system_manager)
+
+    def get_driver_lock_path(self, driver_name: str, os_type: str) -> str:
+        os.makedirs(self._root_dir, exist_ok=True)
+        return os.path.join(self._root_dir, f".wdm-lock-{driver_name}-{os_type}")
+
+    def save_archive_file(self, file: File, path):
+        return self._file_manager.save_archive_file(file, path)
+
+    def unpack_archive(self, archive, path):
+        return self._file_manager.unpack_archive(archive, path)
+
+    def save_file_to_cache(self, driver: Driver, file: File):
+        path = self.__get_path(driver)
+        archive = self.save_archive_file(file, path)
+        files = self.unpack_archive(archive, path)
+        binary = self.__get_binary(files, driver.get_name())
+        binary_path = os.path.join(path, binary)
+        self.__save_metadata(driver, binary_path)
+        log(f"Driver has been saved in cache [{path}]")
+        return binary_path
+
+    def __get_binary(self, files, driver_name):
+        if not files:
+            raise Exception(f"Can't find binary for {driver_name} among {files}")
+
+        if len(files) == 1:
+            return files[0]
+
+        for f in files:
+            if 'LICENSE' in f:
+                continue
+            if 'THIRD_PARTY' in f:
+                continue
+            if driver_name in f:
+                return f
+
+        raise Exception(f"Can't find binary for {driver_name} among {files}")
+
+    def __save_metadata(self, driver: Driver, binary_path, date=None):
+        if date is None:
+            date = datetime.date.today()
+
+        metadata = self.load_metadata_content()
+        key = self.__get_metadata_key(driver)
+        data = {
+            key: {
+                "timestamp": date.strftime(self._date_format),
+                "binary_path": binary_path,
+            }
+        }
+
+        metadata.update(data)
+        with open(self._drivers_json_path, "w+") as outfile:
+            json.dump(metadata, outfile, indent=4)
+
+    def get_os_type(self):
+        return self._os_system_manager.get_os_type()
+
+    def find_driver(self, driver: Driver):
+        """Find driver by '{os_type}_{driver_name}_{driver_version}_{browser_version}'."""
+        os_type = self.get_os_type()
+        driver_name = driver.get_name()
+        browser_type = driver.get_browser_type()
+        browser_version = self._os_system_manager.get_browser_version_from_os(browser_type)
+        if not browser_version:
+            return None
+
+        metadata = self.load_metadata_content()
+        requested_driver_version = getattr(driver, "_driver_version_to_download", None)
+        if not requested_driver_version:
+            cached_path = self.__find_driver_by_browser_version(
+                metadata=metadata,
+                os_type=os_type,
+                driver_name=driver_name,
+                browser_version=browser_version,
+            )
+            if cached_path:
+                return cached_path
+
+        driver_version = self.get_cache_key_driver_version(driver)
+
+        key = self.__get_metadata_key(driver)
+        if key not in metadata:
+            log(f'There is no [{os_type}] {driver_name} "{driver_version}" for browser {browser_type} '
+                f'"{browser_version}" in cache')
+            return None
+
+        driver_info = metadata[key]
+        path = driver_info["binary_path"]
+        if not os.path.exists(path):
+            return None
+
+        if not self.__is_valid(driver_info):
+            return None
+
+        path = driver_info["binary_path"]
+        log(f"Driver [{path}] found in cache")
+        return path
+
+    def __find_driver_by_browser_version(self, metadata, os_type, driver_name, browser_version):
+        prefix = f"{os_type}_{driver_name}_"
+        suffix = f"_for_{browser_version}"
+        candidates = []
+
+        for key, info in metadata.items():
+            if not key.startswith(prefix) or not key.endswith(suffix):
+                continue
+            path = info.get("binary_path")
+            timestamp = info.get("timestamp")
+            if not path or not os.path.exists(path):
+                continue
+            if not timestamp:
+                continue
+            if not self.__is_valid(info):
+                continue
+            try:
+                datetime.datetime.strptime(timestamp, self._date_format)
+            except ValueError:
+                continue
+            candidates.append((timestamp, path))
+
+        if not candidates:
+            return None
+
+        candidates.sort(key=lambda item: datetime.datetime.strptime(item[0], self._date_format), reverse=True)
+        path = candidates[0][1]
+        log(f"Driver [{path}] found in cache by browser version")
+        return path
+
+    def __is_valid(self, driver_info):
+        dates_diff = get_date_diff(
+            driver_info["timestamp"], datetime.date.today(), self._date_format
+        )
+        return dates_diff < self._cache_valid_days_range
+
+    def load_metadata_content(self):
+        if os.path.exists(self._drivers_json_path):
+            with open(self._drivers_json_path, "r") as outfile:
+                return json.load(outfile)
+        return {}
+
+    def __get_metadata_key(self, driver: Driver):
+        if self._metadata_key:
+            return self._metadata_key
+
+        driver_version = self.get_cache_key_driver_version(driver)
+        browser_version = driver.get_browser_version_from_os()
+        browser_version = browser_version if browser_version else ""
+        self._metadata_key = f"{self.get_os_type()}_{driver.get_name()}_{driver_version}" \
+                             f"_for_{browser_version}"
+        return self._metadata_key
+
+    def get_cache_key_driver_version(self, driver: Driver):
+        if self._cache_key_driver_version:
+            return self._cache_key_driver_version
+        self._cache_key_driver_version = driver.get_driver_version_to_download()
+        return self._cache_key_driver_version
+
+    def __get_path(self, driver: Driver):
+        if self._driver_binary_path is None:
+            self._driver_binary_path = os.path.join(
+                self._drivers_directory,
+                driver.get_name(),
+                self.get_os_type(),
+                self.get_cache_key_driver_version(driver),
+            )
+        return self._driver_binary_path

webdriver_manager/core/file_manager.py

@@ -0,0 +1,117 @@
+import os
+import re
+import sys
+import tarfile
+import zipfile
+
+from webdriver_manager.core.archive import Archive, LinuxZipFileWithPermissions
+from webdriver_manager.core.os_manager import OperationSystemManager
+
+
+class File(object):
+    def __init__(self, stream, file_name):
+        self.content = stream.content
+        self.__stream = stream
+        self.file_name = file_name
+        self.__temp_name = "driver"
+        self.__regex_filename = r"""filename.+"(.+)"|filename.+''(.+)|filename=([\w.-]+)"""
+
+    @property
+    def filename(self) -> str:
+        if self.file_name:
+            return self.file_name
+        try:
+            content = self.__stream.headers["content-disposition"]
+
+            content_disposition_list = re.split(";", content)
+            filenames = [re.findall(self.__regex_filename, element) for element in content_disposition_list]
+            filename = next(filter(None, next(filter(None, next(filter(None, filenames))))))
+        except KeyError:
+            filename = f"{self.__temp_name}.zip"
+        except (IndexError, StopIteration):
+            filename = f"{self.__temp_name}.exe"
+
+        if '"' in filename:
+            filename = filename.replace('"', "")
+
+        return filename
+
+
+class FileManager(object):
+
+    def __init__(self, os_system_manager: OperationSystemManager):
+        self._os_system_manager = os_system_manager
+
+    def save_archive_file(self, file: File, directory: str):
+        os.makedirs(directory, exist_ok=True)
+
+        archive_path = f"{directory}{os.sep}{file.filename}"
+        with open(archive_path, "wb") as code:
+            code.write(file.content)
+        if not os.path.exists(archive_path):
+            raise FileExistsError(f"No file has been saved on such path {archive_path}")
+        return Archive(archive_path)
+
+    def unpack_archive(self, archive_file: Archive, target_dir):
+        file_path = archive_file.file_path
+        if file_path.endswith(".zip"):
+            return self.__extract_zip(archive_file, target_dir)
+        elif file_path.endswith(".tar.gz"):
+            return self.__extract_tar_file(archive_file, target_dir)
+
+    def __extract_zip(self, archive_file, to_directory):
+        zip_class = (LinuxZipFileWithPermissions if self._os_system_manager.get_os_name() == "linux" else zipfile.ZipFile)
+        archive = zip_class(archive_file.file_path)
+        self.__remove_file_dir_conflicts(archive.namelist(), to_directory)
+        try:
+            archive.extractall(to_directory)
+        except Exception as e:
+            if e.args[0] not in [26, 13] and e.args[1] not in [
+                "Text file busy",
+                "Permission denied",
+            ]:
+                raise e
+            file_names = []
+            for n in archive.namelist():
+                if "/" not in n:
+                    file_names.append(n)
+                else:
+                    file_path, file_name = n.rsplit("/", 1)
+                    if not file_name:
+                        continue
+                    full_file_path = os.path.join(to_directory, file_path)
+                    source = os.path.join(full_file_path, file_name)
+                    destination = os.path.join(to_directory, file_name)
+                    if not os.path.exists(source):
+                        continue
+                    os.replace(source, destination)
+                    file_names.append(file_name)
+            return sorted(file_names, key=lambda x: x.lower())
+        return archive.namelist()
+
+    def __remove_file_dir_conflicts(self, names, to_directory):
+        """Remove stale files that conflict with directory entries in archive.
+
+        Example: if cache contains `<to_directory>/operadriver` as a file, and
+        archive now contains `operadriver/<binary>`, extraction would fail with
+        NotADirectoryError.
+        """
+        top_level_dirs = {name.split("/", 1)[0] for name in names if "/" in name}
+        for dir_name in top_level_dirs:
+            path = os.path.join(to_directory, dir_name)
+            if os.path.isfile(path):
+                os.remove(path)
+
+    def __extract_tar_file(self, archive_file, to_directory):
+        try:
+            tar = tarfile.open(archive_file.file_path, mode="r:gz")
+        except tarfile.ReadError:
+            tar = tarfile.open(archive_file.file_path, mode="r:bz2")
+        members = tar.getmembers()
+        # Python 3.13+ requires 'filter' to avoid deprecation warning
+        if sys.version_info >= (3, 13):
+            tar.extractall(to_directory, filter="fully_trusted")
+        else:
+            tar.extractall(to_directory)
+        tar.close()
+        return [x.name for x in members]

webdriver_manager/core/http.py

@@ -0,0 +1,38 @@
+import requests
+from requests import Response, exceptions
+
+from webdriver_manager.core.config import ssl_verify
+
+
+class HttpClient:
+    def get(self, url, params=None, **kwargs) -> Response:
+        raise NotImplementedError
+
+    @staticmethod
+    def validate_response(resp: requests.Response):
+        status_code = resp.status_code
+        if status_code == 404:
+            raise ValueError(f"There is no such driver by url {resp.url}")
+        elif status_code == 401:
+            raise ValueError(f"API Rate limit exceeded. You have to add GH_TOKEN!!!")
+        elif resp.status_code != 200:
+            raise ValueError(
+                f"response body:\n{resp.text}\n"
+                f"request url:\n{resp.request.url}\n"
+                f"response headers:\n{dict(resp.headers)}\n"
+            )
+
+
+class WDMHttpClient(HttpClient):
+    def __init__(self):
+        self._ssl_verify = ssl_verify()
+
+    def get(self, url, **kwargs) -> Response:
+        try:
+            resp = requests.get(
+                url=url, verify=self._ssl_verify, stream=True, **kwargs)
+        except exceptions.ConnectionError:
+            raise exceptions.ConnectionError(f"Could not reach host. Are you offline?")
+        self.validate_response(resp)
+        return resp
+

webdriver_manager/core/logger.py

@@ -0,0 +1,31 @@
+import logging
+
+from webdriver_manager.core.config import wdm_log_level
+
+__logger = logging.getLogger("WDM")
+__logger.addHandler(logging.NullHandler())
+
+
+def log(text):
+    """Emitting the log message."""
+    __logger.log(wdm_log_level(), text)
+
+
+def set_logger(logger):
+    """
+    Set the global logger.
+
+    Parameters
+    ----------
+    logger : object
+        Any logger-like object that provides a callable ``log(level, message)`` method.
+
+    Returns None
+    """
+
+    if not callable(getattr(logger, "log", None)):
+        raise ValueError("The logger must provide a callable log(level, message) method")
+
+    # Bind the logger input to the global logger
+    global __logger
+    __logger = logger