osn-selenium 0.0.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

osn_selenium/instances/unified/shadow_root.py

@@ -0,0 +1,46 @@
+from typing import Any, List, Optional
+from selenium.webdriver.common.by import By
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+
+
+__all__ = ["UnifiedShadowRoot"]
+
+
+class UnifiedShadowRoot:
+	def __init__(self, selenium_shadow_root: legacyShadowRoot):
+		if not isinstance(selenium_shadow_root, legacyShadowRoot):
+			raise NotExpectedTypeError(expected_type=legacyShadowRoot, received_instance=selenium_shadow_root)
+		
+		self._selenium_shadow_root = selenium_shadow_root
+	
+	def __repr__(self) -> str:
+		return self._legacy_impl.__repr__()
+	
+	@property
+	def _legacy_impl(self) -> legacyShadowRoot:
+		return self._selenium_shadow_root
+	
+	def __eq__(self, other: Any) -> bool:
+		return self._legacy_impl == get_legacy_instance(instance=other)
+	
+	def __hash__(self) -> int:
+		return self._legacy_impl.__hash__()
+	
+	def __ne__(self, other: Any) -> bool:
+		return self._legacy_impl != get_legacy_instance(instance=other)
+	
+	def _find_element_impl(self, by: str = By.ID, value: Optional[str] = None) -> legacyWebElement:
+		return self._legacy_impl.find_element(by=by, value=value)
+	
+	def _find_elements_impl(self, by: str = By.ID, value: Optional[str] = None) -> List[legacyWebElement]:
+		return self._legacy_impl.find_elements(by=by, value=value)
+	
+	def _id_impl(self) -> str:
+		return self._legacy_impl.id

osn_selenium/instances/unified/storage.py

@@ -0,0 +1,48 @@
+from typing import Optional, Union
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.common.bidi.storage import (
+	BrowsingContextPartitionDescriptor,
+	CookieFilter,
+	DeleteCookiesResult,
+	GetCookiesResult,
+	PartialCookie,
+	SetCookieResult,
+	Storage as legacyStorage,
+	StorageKeyPartitionDescriptor
+)
+
+
+__all__ = ["UnifiedStorage"]
+
+
+class UnifiedStorage:
+	def __init__(self, selenium_storage: legacyStorage):
+		if not isinstance(selenium_storage, legacyStorage):
+			raise NotExpectedTypeError(expected_type=legacyStorage, received_instance=selenium_storage)
+		
+		self._selenium_storage = selenium_storage
+	
+	def _delete_cookies_impl(
+			self,
+			filter: Optional[CookieFilter] = None,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> DeleteCookiesResult:
+		return self._legacy_impl.delete_cookies(filter=filter, partition=partition)
+	
+	def _get_cookies_impl(
+			self,
+			filter: Optional[CookieFilter],
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> GetCookiesResult:
+		return self._legacy_impl.get_cookies(filter=filter, partition=partition)
+	
+	@property
+	def _legacy_impl(self) -> legacyStorage:
+		return self._selenium_storage
+	
+	def _set_cookie_impl(
+			self,
+			cookie: PartialCookie,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> SetCookieResult:
+		return self._legacy_impl.set_cookie(cookie=cookie, partition=partition)

osn_selenium/instances/unified/switch_to.py

@@ -0,0 +1,49 @@
+from typing import Optional, Union
+from selenium.webdriver.common.alert import Alert as legacyAlert
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from osn_selenium.instances.convert import (
+	get_legacy_frame_reference
+)
+from selenium.webdriver.remote.switch_to import (
+	SwitchTo as legacySwitchTo
+)
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+
+
+__all__ = ["UnifiedSwitchTo"]
+
+
+class UnifiedSwitchTo:
+	def __init__(self, selenium_switch_to: legacySwitchTo):
+		if not isinstance(selenium_switch_to, legacySwitchTo):
+			raise NotExpectedTypeError(expected_type=legacySwitchTo, received_instance=selenium_switch_to)
+		
+		self._selenium_switch_to = selenium_switch_to
+	
+	def _active_element_impl(self) -> legacyWebElement:
+		return self._legacy_impl.active_element
+	
+	def _alert_impl(self) -> legacyAlert:
+		return self._legacy_impl.alert
+	
+	def _default_content_impl(self) -> None:
+		self._legacy_impl.default_content()
+	
+	def _frame_impl(self, frame_reference: Union[str, int, WEB_ELEMENT_TYPEHINT]) -> None:
+		self._legacy_impl.frame(frame_reference=get_legacy_frame_reference(frame_reference))
+	
+	@property
+	def _legacy_impl(self) -> legacySwitchTo:
+		return self._selenium_switch_to
+	
+	def _new_window_impl(self, type_hint: Optional[str] = None) -> None:
+		self._legacy_impl.new_window(type_hint=type_hint)
+	
+	def _parent_frame_impl(self) -> None:
+		self._legacy_impl.parent_frame()
+	
+	def _window_impl(self, window_name: str) -> None:
+		self._legacy_impl.window(window_name=window_name)

osn_selenium/instances/unified/web_driver_wait.py

@@ -0,0 +1,45 @@
+from typing import Callable, TypeVar
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from osn_selenium.instances._typehints import (
+	WebDriverWaitInputType
+)
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+
+
+__all__ = ["OUTPUT", "UnifiedWebDriverWait"]
+
+OUTPUT = TypeVar("OUTPUT")
+
+
+class UnifiedWebDriverWait:
+	def __init__(self, selenium_webdriver_wait: legacyWebDriverWait):
+		if not isinstance(selenium_webdriver_wait, legacyWebDriverWait):
+			raise NotExpectedTypeError(
+					expected_type=legacyWebDriverWait,
+					received_instance=selenium_webdriver_wait
+			)
+		
+		self._selenium_webdriver_wait = selenium_webdriver_wait
+	
+	def __repr__(self) -> str:
+		return self._legacy_impl.__repr__()
+	
+	@property
+	def _legacy_impl(self) -> legacyWebDriverWait:
+		return self._selenium_webdriver_wait
+	
+	def _until_impl(
+			self,
+			method: Callable[[WebDriverWaitInputType], OUTPUT],
+			message: str = ""
+	) -> OUTPUT:
+		return self._legacy_impl.until(method=method, message=message)
+	
+	def _until_not_impl(
+			self,
+			method: Callable[[WebDriverWaitInputType], OUTPUT],
+			message: str = ""
+	) -> OUTPUT:
+		return self._legacy_impl.until_not(method=method, message=message)

osn_selenium/instances/unified/web_element.py

@@ -0,0 +1,145 @@
+from selenium.webdriver.common.by import By
+from osn_selenium.instances.convert import get_legacy_instance
+from typing import (
+	Any,
+	Dict,
+	Iterable,
+	List,
+	Optional
+)
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+
+
+__all__ = ["UnifiedWebElement"]
+
+
+class UnifiedWebElement:
+	def __init__(self, selenium_web_element: legacyWebElement):
+		if not isinstance(selenium_web_element, legacyWebElement):
+			raise ExpectedTypeError(
+					expected_class=legacyWebElement,
+					received_instance=selenium_web_element
+			)
+		
+		self._selenium_web_element = selenium_web_element
+	
+	def __repr__(self) -> str:
+		return self._legacy_impl.__repr__()
+	
+	@property
+	def _legacy_impl(self) -> legacyWebElement:
+		return self._selenium_web_element
+	
+	def __eq__(self, other: Any) -> bool:
+		return self._legacy_impl == get_legacy_instance(instance=other)
+	
+	def __hash__(self) -> int:
+		return self._legacy_impl.__hash__()
+	
+	def __ne__(self, other: Any) -> bool:
+		return self._legacy_impl != get_legacy_instance(instance=other)
+	
+	def _accessible_name_impl(self) -> str:
+		return self._legacy_impl.accessible_name
+	
+	def _aria_role_impl(self) -> str:
+		return self._legacy_impl.aria_role
+	
+	def _clear_impl(self) -> None:
+		self._legacy_impl.clear()
+	
+	def _click_impl(self) -> None:
+		self._legacy_impl.click()
+	
+	def _find_element_impl(self, by: str = By.ID, value: Any = None) -> legacyWebElement:
+		return self._legacy_impl.find_element(by=by, value=value)
+	
+	def _find_elements_impl(self, by: str = By.ID, value: Any = None) -> List[legacyWebElement]:
+		return self._legacy_impl.find_elements(by=by, value=value)
+	
+	def _get_attribute_impl(self, name: str) -> Optional[str]:
+		return self._legacy_impl.get_attribute(name=name)
+	
+	def _get_dom_attribute_impl(self, name: str) -> Optional[str]:
+		return self._legacy_impl.get_dom_attribute(name=name)
+	
+	def _get_property_impl(self, name: str) -> Any:
+		return self._legacy_impl.get_property(name=name)
+	
+	def _id_impl(self) -> str:
+		return self._legacy_impl.id
+	
+	def _is_displayed_impl(self) -> bool:
+		return self._legacy_impl.is_displayed()
+	
+	def _is_enabled_impl(self) -> bool:
+		return self._legacy_impl.is_enabled()
+	
+	def _is_selected_impl(self) -> bool:
+		return self._legacy_impl.is_selected()
+	
+	def _location_impl(self) -> Dict:
+		return self._legacy_impl.location
+	
+	def _location_once_scrolled_into_view_impl(self) -> Dict:
+		return self._legacy_impl.location_once_scrolled_into_view
+	
+	def _parent_impl(self) -> Any:
+		return self._legacy_impl.parent
+	
+	def _rect_impl(self) -> Dict:
+		return self._legacy_impl.rect
+	
+	def _screenshot_as_base64_impl(self) -> str:
+		return self._legacy_impl.screenshot_as_base64
+	
+	def _screenshot_as_png_impl(self) -> bytes:
+		return self._legacy_impl.screenshot_as_png
+	
+	def _screenshot_impl(self, filename: str) -> bool:
+		return self._legacy_impl.screenshot(filename=filename)
+	
+	def _send_keys_impl(self, *value: str) -> None:
+		self._legacy_impl.send_keys(*value)
+	
+	def _session_id_impl(self) -> str:
+		return self._legacy_impl.session_id
+	
+	def _shadow_root_impl(self) -> legacyShadowRoot:
+		return self._legacy_impl.shadow_root
+	
+	def _size_impl(self) -> Dict:
+		return self._legacy_impl.size
+	
+	def _submit_impl(self) -> None:
+		self._legacy_impl.submit()
+	
+	def _tag_name_impl(self) -> str:
+		return self._legacy_impl.tag_name
+	
+	def _text_impl(self) -> str:
+		return self._legacy_impl.text
+	
+	def _value_of_css_property_impl(self, property_name: str) -> str:
+		return self._legacy_impl.value_of_css_property(property_name=property_name)
+	
+	def _web_driver_wait_impl(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> legacyWebDriverWait:
+		return legacyWebDriverWait(
+				driver=self._legacy_impl,
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions
+		)

osn_selenium/instances/unified/web_extension.py

@@ -0,0 +1,38 @@
+from typing import (
+	Dict,
+	Optional,
+	Union
+)
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+from selenium.webdriver.common.bidi.webextension import (
+	WebExtension as legacyWebExtension
+)
+
+
+__all__ = ["UnifiedWebExtension"]
+
+
+class UnifiedWebExtension:
+	def __init__(self, selenium_web_extension: legacyWebExtension):
+		if not isinstance(selenium_web_extension, legacyWebExtension):
+			raise NotExpectedTypeError(
+					expected_type=legacyWebExtension,
+					received_instance=selenium_web_extension
+			)
+		
+		self._selenium_web_extension = selenium_web_extension
+	
+	def _install_impl(
+			self,
+			path: Optional[str] = None,
+			archive_path: Optional[str] = None,
+			base64_value: Optional[str] = None,
+	) -> Dict:
+		return self._legacy_impl.install(path=path, archive_path=archive_path, base64_value=base64_value)
+	
+	@property
+	def _legacy_impl(self) -> legacyWebExtension:
+		return self._selenium_web_extension
+	
+	def _uninstall_impl(self, extension_id_or_result: Union[str, Dict]) -> None:
+		self._legacy_impl.uninstall(extension_id_or_result=extension_id_or_result)

osn_selenium/javascript/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/javascript/_functions.py

@@ -0,0 +1,63 @@
+from typing import (
+	Any,
+	Iterable,
+	Mapping
+)
+
+
+__all__ = ["convert_to_js_value", "inject_data_in_js_script"]
+
+
+def convert_to_js_value(value: Any) -> str:
+	"""
+	Converts a Python value to its JavaScript string representation.
+
+	Args:
+		value (Any): The value to convert. Can be a boolean, string, mapping, iterable, or None.
+
+	Returns:
+		str: The JavaScript string representation of the value.
+	"""
+	
+	if isinstance(value, (str, bytes)):
+		return f'"{value}"'
+	
+	if isinstance(value, bool):
+		return "true" if value else "false"
+	
+	if value is None:
+		return "null"
+	
+	if isinstance(value, Mapping):
+		return f"{{{', '.join(f'{k}: {convert_to_js_value(value=v)}' for k, v in value.items())}}}"
+	
+	if isinstance(value, Iterable):
+		return f"[{', '.join(convert_to_js_value(value=v) for v in value)}]"
+	
+	return str(value)
+
+
+def inject_data_in_js_script(script: str, data: Mapping[str, Any], convert_to_js: bool = True) -> str:
+	"""
+	Injects data into a JavaScript template string by replacing placeholders.
+
+	Args:
+		script (str): The JavaScript template string.
+		data (Mapping[str, Any]): A dictionary mapping placeholders to values.
+		convert_to_js (bool): If True, converts values to JS syntax before replacement.
+
+	Returns:
+		str: The modified JavaScript string with data injected.
+	"""
+	
+	injected_script = script
+	
+	for placeholder, value in data.items():
+		if convert_to_js:
+			replacement = convert_to_js_value(value)
+		else:
+			replacement = str(value)
+	
+		injected_script = injected_script.replace(placeholder, replacement)
+	
+	return injected_script

osn_selenium/javascript/fingerprint/__init__.py

@@ -0,0 +1,120 @@
+from pydantic import Field
+from typing import Dict, List, Literal
+from osn_selenium.models import DictModel
+from osn_selenium.javascript.functions import get_js_scripts
+from osn_selenium.javascript.fingerprint._functions import add_code_level
+from osn_selenium.javascript.fingerprint.registry.models import RegistryItem
+from osn_selenium.javascript.fingerprint._detect.functions import get_hook_js
+from osn_selenium.javascript.fingerprint.registry import FINGERPRINT_REGISTRY
+from osn_selenium.javascript.fingerprint._typehints import SPOOF_RULE_TYPEHINT
+from osn_selenium.javascript._functions import (
+	convert_to_js_value,
+	inject_data_in_js_script
+)
+
+
+__all__ = ["FingerprintSettings"]
+
+
+class FingerprintSettings(DictModel):
+	"""
+	Configuration settings for browser fingerprinting detection and spoofing.
+
+	Attributes:
+		optimize_events (bool): Whether to optimize event reporting to avoid duplicates.
+		detect_events_mode (Literal["disable", "always", "not_spoofed"]): Logic for reporting detected events.
+		registry (Dict[str, RegistryItem]): Custom registry items to override or extend defaults.
+		use_preset_registry (bool): Whether to include the default built-in registry.
+	"""
+	
+	optimize_events: bool = True
+	detect_events_mode: Literal["disable", "always", "not_spoofed"] = "not_spoofed"
+	
+	registry: Dict[str, RegistryItem] = Field(default_factory=dict)
+	use_preset_registry: bool = True
+	
+	def _get_registry(self) -> Dict[str, RegistryItem]:
+		"""
+		Compiles the final registry by merging presets with custom user overrides.
+
+		Returns:
+			Dict[str, RegistryItem]: The active registry map.
+		"""
+		
+		if self.use_preset_registry:
+			registry_ = FINGERPRINT_REGISTRY.copy()
+		else:
+			registry_ = {}
+		
+		if self.registry:
+			registry_.update(**self.registry)
+		
+		return registry_
+	
+	def _generate_hooks_js(self) -> str:
+		"""
+		Generates the JavaScript code that hooks into browser APIs for detection and spoofing.
+
+		Returns:
+			str: The generated hooks block.
+		"""
+		
+		registry_ = self._get_registry()
+		
+		hooks: List[str] = []
+		register_items = {item.path: item for item in registry_.values()}
+		
+		for path, entry in register_items.items():
+			is_spoofed: bool = entry is not None and entry.spoofing_rule is not None
+			is_detected: bool = (
+					self.detect_events_mode == "always"
+					or self.detect_events_mode == "not_spoofed"
+					and not is_spoofed
+			)
+		
+			hooks.append(
+					get_hook_js(path=path, entry=entry, is_detected=is_detected, is_spoofed=is_spoofed)
+			)
+		
+		return "\n".join(hooks)
+	
+	def _generate_modifiers_js(self) -> str:
+		"""
+		Generates the JavaScript code that defines spoofing modifiers.
+
+		Returns:
+			str: The generated modifiers block.
+		"""
+		
+		registry_ = self._get_registry()
+		lines = []
+		
+		for key, parameter in registry_.items():
+			if parameter.spoofing_rule is not None:
+				js_func = parameter.spoofing_rule.generate_js(path=parameter.path)
+				lines.append(f"MODIFIERS['{parameter.path}'] = {js_func};")
+		
+		return "\n".join(lines)
+	
+	def generate_js(self) -> str:
+		"""
+		Generates the complete JavaScript code to inject into the browser.
+
+		This methods combines the fingerprint injection script with the dynamic
+		modifiers and detection hooks based on the current configuration.
+
+		Returns:
+			str: The executable JavaScript code.
+		"""
+		
+		scripts = get_js_scripts()
+		
+		return inject_data_in_js_script(
+				script=scripts.start_fingerprint_detection,
+				data={
+					"__MODIFIERS_PLACEHOLDER__": add_code_level(code=self._generate_modifiers_js(), num=1),
+					"__DETECTION_PLACEHOLDER__": add_code_level(code=self._generate_hooks_js(), num=1),
+					"__SETTINGS__PLACEHOLDER__": convert_to_js_value(value={"optimize_events": self.optimize_events})
+				},
+				convert_to_js=False,
+		)

osn_selenium/javascript/fingerprint/_decorators.py

@@ -0,0 +1,41 @@
+import functools
+from typing import (
+	Any,
+	Callable,
+	ParamSpec,
+	TypeVar
+)
+from osn_selenium.javascript.fingerprint._functions import add_code_level
+
+
+__all__ = ["indent_code"]
+
+_METHOD_INPUT = ParamSpec("_METHOD_INPUT")
+_METHOD_OUTPUT = TypeVar("_METHOD_OUTPUT")
+_METHOD = TypeVar("_METHOD", bound=Callable[..., Any])
+
+
+def indent_code(func: _METHOD) -> _METHOD:
+	"""
+	Decorator that indents the result of a function which returns a string code block.
+
+	If the result is empty, it returns an empty string. Otherwise, it adds one level
+	of indentation (tab) to the result.
+
+	Args:
+		func (_METHOD): The function to wrap.
+
+	Returns:
+		_METHOD: The wrapped function.
+	"""
+	
+	@functools.wraps(func)
+	def wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
+		result = func(*args, **kwargs)
+		
+		if not result:
+			return ""
+		
+		return add_code_level(code=result, num=1)
+	
+	return wrapper

osn_selenium/javascript/fingerprint/_detect/__init__.py

@@ -0,0 +1 @@
+