osn-selenium 0.0.0__py3-none-any.whl

osn_selenium/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/browsers_handler/__init__.py

@@ -0,0 +1,70 @@
+import sys
+import pathlib
+from typing import Optional
+from osn_selenium.browsers_handler.types import Browser
+from osn_selenium.errors import (
+	PlatformNotSupportedError
+)
+from osn_selenium.browsers_handler._windows import (
+	get_installed_browsers_win32
+)
+
+
+def get_installed_browsers() -> list[Browser]:
+	"""
+	Retrieves a list of installed browsers on the system.
+
+	This function detects and lists the browsers installed on the operating system.
+	It supports different operating systems and uses platform-specific methods to find installed browsers.
+
+	Returns:
+		list[Browser]: A list of installed browsers. Each item in the list is a dictionary of type `Browser` containing information about the browser like name, version, and path.
+
+	Raises:
+		PlatformNotSupportedError: If the operating system is not supported.
+	"""
+	
+	if sys.platform == "win32":
+		return get_installed_browsers_win32()
+	else:
+		raise PlatformNotSupportedError(sys.platform)
+
+
+def get_version_of_browser(browser_name: str) -> Optional[str]:
+	"""
+	Retrieves the version of a specific installed browser.
+
+	This function searches for an installed browser by its name and returns its version if found.
+
+	Args:
+		browser_name (str): The name of the browser to find the version for (e.g., "Chrome", "Firefox").
+
+	Returns:
+		Optional[str]: The version string of the browser if found, otherwise None.
+	"""
+	
+	for browser in get_installed_browsers():
+		if browser["name"] == browser_name:
+			return browser["version"]
+	
+	return None
+
+
+def get_path_to_browser(browser_name: str) -> Optional[pathlib.Path]:
+	"""
+	Retrieves the installation path of a specific installed browser.
+
+	This function searches for an installed browser by its name and returns its installation path as a pathlib.Path object if found.
+
+	Args:
+		browser_name (str): The name of the browser to find the path for (e.g., "Chrome", "Firefox").
+
+	Returns:
+		Optional[pathlib.Path]: The pathlib.Path object representing the browser's installation path if found, otherwise None.
+	"""
+	
+	for browser in get_installed_browsers():
+		if browser["name"] == browser_name:
+			return browser["path"]
+	
+	return None

osn_selenium/browsers_handler/_windows.py

@@ -0,0 +1,130 @@
+import re
+import winreg
+import pathlib
+import subprocess
+from typing import Optional, Union
+from osn_selenium.browsers_handler.types import Browser
+from win32api import (
+	GetFileVersionInfo,
+	HIWORD,
+	LOWORD
+)
+
+
+def get_webdriver_version(driver_path: Union[pathlib.Path, str]) -> Optional[str]:
+	"""
+	Retrieves the version of a given webdriver executable.
+
+	Args:
+		driver_path (Union[pathlib.Path, str]): The path to the webdriver executable. It can be a string or a pathlib.Path object.
+
+	Returns:
+		Optional[str]: The version of the webdriver as a string, or None if the version cannot be determined.
+
+	Raises:
+		FileNotFoundError: If the webdriver executable does not exist at the given path.
+		Exception: If there is an error executing the webdriver or parsing the output.
+	"""
+	
+	if isinstance(driver_path, str):
+		driver_path = pathlib.Path(driver_path)
+	
+	if not driver_path.exists():
+		raise FileNotFoundError(f"{driver_path} not found.")
+	
+	try:
+		process = subprocess.Popen(
+				[driver_path, "--version"],
+				stdout=subprocess.PIPE,
+				stderr=subprocess.PIPE
+		)
+		stdout, stderr = process.communicate()
+	
+		output = stdout.decode("utf-8").strip()
+		error = stderr.decode("utf-8").strip()
+	
+		if error:
+			raise Exception(error)
+	
+		match = re.search(r"([\d.]+)", output)
+		if match:
+			return match.group(1)
+	
+		return None
+	except Exception as e:
+		raise e
+
+
+def get_browser_version(browser_path: Union[pathlib.Path, str]) -> str:
+	"""
+	Retrieves the version of a browser given its file path.
+
+	This function uses the `GetFileVersionInfo` function from the `win32api` module to extract the browser's version information from the executable file.
+
+	Args:
+		browser_path (pathlib.Path): The file path to the browser executable.
+
+	Returns:
+		str: The version of the browser as a string, or "unknown" if the file does not exist.
+	"""
+	
+	if isinstance(browser_path, str):
+		browser_path = pathlib.Path(browser_path)
+	
+	if not browser_path.exists():
+		return "unknown"
+	
+	info = GetFileVersionInfo(str(browser_path.resolve()), "\\")
+	ms = info["FileVersionMS"]
+	ls = info["FileVersionLS"]
+	
+	return ".".join(map(str, (HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))))
+
+
+def get_installed_browsers_win32() -> list[Browser]:
+	"""
+	Retrieves a list of installed browsers on a Windows system by querying the registry.
+
+	This function iterates through different registry locations to identify installed browsers and their paths.
+	It constructs a list of unique `Browser` objects, each representing an installed browser.
+
+	Returns:
+		list[Browser]: A list of unique installed browsers.
+	"""
+	
+	installed_browsers = []
+	
+	for root_key, access in [
+		(winreg.HKEY_CURRENT_USER, winreg.KEY_READ),
+		(winreg.HKEY_LOCAL_MACHINE, winreg.KEY_READ | winreg.KEY_WOW64_64KEY),
+		(winreg.HKEY_LOCAL_MACHINE, winreg.KEY_READ | winreg.KEY_WOW64_32KEY)
+	]:
+		with winreg.OpenKey(root_key, r"SOFTWARE\Clients\StartMenuInternet", access=access) as key:
+			num_subkeys = winreg.QueryInfoKey(key)[0]
+	
+			for i in range(num_subkeys):
+				try:
+					subkey = winreg.EnumKey(key, i)
+	
+					browser_name = winreg.QueryValue(key, subkey)
+					if not browser_name or not isinstance(browser_name, str):
+						browser_name = subkey
+	
+					with winreg.OpenKey(key, rf"{subkey}\shell\open\command") as subkey:
+						browser_path = pathlib.Path(winreg.QueryValue(subkey, None).strip('"'))
+	
+						if not browser_path.exists():
+							continue
+	
+						found_browser = Browser(
+								name=browser_name,
+								path=browser_path,
+								version=get_browser_version(browser_path)
+						)
+	
+						if found_browser not in installed_browsers:
+							installed_browsers.append(found_browser)
+				except (OSError, AttributeError, TypeError, ValueError, FileNotFoundError):
+					pass
+	
+	return installed_browsers

osn_selenium/browsers_handler/types.py

@@ -0,0 +1,20 @@
+import pathlib
+from typing import TypedDict
+
+
+class Browser(TypedDict):
+	"""
+	Represents a browser installed on the system.
+
+	This class is a TypedDict, which provides a way to define the structure of a dictionary with specific keys and value types.
+	It is used to store information about a browser, such as its name, installation path, and version.
+
+	Attributes:
+		name (str): The name of the browser (e.g., "Chrome", "Firefox").
+		path (pathlib.Path): The file path to the browser executable.
+		version (str): The version number of the browser.
+	"""
+	
+	name: str
+	path: pathlib.Path
+	version: str

osn_selenium/captcha_workers/__init__.py

@@ -0,0 +1,26 @@
+from typing import (
+	Callable,
+	TYPE_CHECKING,
+	TypedDict
+)
+
+
+if TYPE_CHECKING:
+	from osn_selenium.webdrivers.BaseDriver.webdriver import BrowserWebDriver
+
+
+class CaptchaWorkerSettings(TypedDict):
+	"""
+	Typed dictionary for defining a captcha worker.
+
+	Attributes:
+		name (str): A unique name for the captcha worker.
+		check_func (Callable[["BrowserWebDriver"], bool]): A callable function that takes a
+			`BrowserWebDriver` instance and returns `True` if a captcha is detected.
+		solve_func (Callable[["BrowserWebDriver"], None]): A callable function that takes a
+			`BrowserWebDriver` instance and attempts to solve the captcha.
+	"""
+	
+	name: str
+	check_func: Callable[["BrowserWebDriver"], bool]
+	solve_func: Callable[["BrowserWebDriver"], None]

osn_selenium/dev_tools/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/dev_tools/_types.py

@@ -0,0 +1,22 @@
+from typing import (
+	Awaitable,
+	Callable,
+	Literal,
+	TYPE_CHECKING
+)
+
+
+if TYPE_CHECKING:
+	from osn_selenium.dev_tools.manager import DevToolsTarget
+
+
+devtools_background_func_type = Callable[["DevToolsTarget"], Awaitable[None]]
+LogLevelsType = Literal[
+	"INFO",
+	"ERROR",
+	"DEBUG",
+	"WARNING",
+	"RequestPaused",
+	"AuthRequired",
+	"Building Kwargs"
+]

osn_selenium/dev_tools/domains/__init__.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import (
+	Literal,
+	Optional,
+	TypedDict,
+	Union
+)
+from osn_selenium.dev_tools.domains.fetch import (
+	FetchSettings,
+	_Fetch
+)
+
+
+class Domains(TypedDict, total=False):
+	"""
+	Settings for configuring callbacks for different DevTools event domains.
+
+	This TypedDict aggregates settings for various DevTools event types, allowing for structured configuration
+	of event handling within the DevTools integration. Currently, it specifically includes settings for the 'fetch' domain.
+
+	Attributes:
+		fetch (_Fetch): Configuration settings for the Fetch domain events.
+			This includes settings to enable/disable fetch event handling and specific configurations for 'requestPaused' events.
+	"""
+	
+	fetch: _Fetch
+
+
+@dataclass
+class DomainsSettings:
+	"""
+	A dataclass container for configuration settings across different DevTools domains.
+
+	This class provides a structured way to define the desired behavior for various
+	CDP domains like Fetch, Network, etc., when the DevTools context is active.
+
+	Attributes:
+		fetch (Optional[FetchSettings]): Configuration settings for the Fetch domain. If None, the Fetch domain will not be enabled or handled. Defaults to None.
+	"""
+	
+	fetch: Optional[FetchSettings] = None
+	
+	def to_dict(self) -> Domains:
+		"""
+		Converts the dataclass instance to its dictionary representation.
+
+		This method is used internally to transform the structured settings from the
+		dataclass into the `Domains` TypedDict format expected by the DevTools manager.
+
+		Returns:
+			Domains: A dictionary containing the settings for each configured domain.
+		"""
+		
+		kwargs = {}
+		
+		if self.fetch is not None:
+			kwargs["fetch"] = self.fetch.to_dict()
+		
+		return Domains(**kwargs)
+
+
+domains_type = Literal["fetch"]
+domains_classes_type = Union[_Fetch]