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

osn_selenium/executors/unified/cdp/target.py

@@ -0,0 +1,165 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["UnifiedTargetCDPExecutor"]
+
+
+class UnifiedTargetCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _activate_target_impl(self, target_id: str) -> None:
+		return self._execute_function("Target.activateTarget", {"target_id": target_id})
+	
+	def _attach_to_browser_target_impl(self) -> str:
+		return self._execute_function("Target.attachToBrowserTarget", {})
+	
+	def _attach_to_target_impl(self, target_id: str, flatten: Optional[bool] = None) -> str:
+		return self._execute_function("Target.attachToTarget", {"target_id": target_id, "flatten": flatten})
+	
+	def _auto_attach_related_impl(
+			self,
+			target_id: str,
+			wait_for_debugger_on_start: bool,
+			filter_: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return self._execute_function(
+				"Target.autoAttachRelated",
+				{
+					"target_id": target_id,
+					"wait_for_debugger_on_start": wait_for_debugger_on_start,
+					"filter_": filter_
+				}
+		)
+	
+	def _close_target_impl(self, target_id: str) -> bool:
+		return self._execute_function("Target.closeTarget", {"target_id": target_id})
+	
+	def _create_browser_context_impl(
+			self,
+			dispose_on_detach: Optional[bool] = None,
+			proxy_server: Optional[str] = None,
+			proxy_bypass_list: Optional[str] = None,
+			origins_with_universal_network_access: Optional[List[str]] = None
+	) -> str:
+		return self._execute_function(
+				"Target.createBrowserContext",
+				{
+					"dispose_on_detach": dispose_on_detach,
+					"proxy_server": proxy_server,
+					"proxy_bypass_list": proxy_bypass_list,
+					"origins_with_universal_network_access": origins_with_universal_network_access
+				}
+		)
+	
+	def _create_target_impl(
+			self,
+			url: str,
+			left: Optional[int] = None,
+			top: Optional[int] = None,
+			width: Optional[int] = None,
+			height: Optional[int] = None,
+			window_state: Optional[str] = None,
+			browser_context_id: Optional[str] = None,
+			enable_begin_frame_control: Optional[bool] = None,
+			new_window: Optional[bool] = None,
+			background: Optional[bool] = None,
+			for_tab: Optional[bool] = None,
+			hidden: Optional[bool] = None
+	) -> str:
+		return self._execute_function(
+				"Target.createTarget",
+				{
+					"url": url,
+					"left": left,
+					"top": top,
+					"width": width,
+					"height": height,
+					"window_state": window_state,
+					"browser_context_id": browser_context_id,
+					"enable_begin_frame_control": enable_begin_frame_control,
+					"new_window": new_window,
+					"background": background,
+					"for_tab": for_tab,
+					"hidden": hidden
+				}
+		)
+	
+	def _detach_from_target_impl(self, session_id: Optional[str] = None, target_id: Optional[str] = None) -> None:
+		return self._execute_function(
+				"Target.detachFromTarget",
+				{"session_id": session_id, "target_id": target_id}
+		)
+	
+	def _dispose_browser_context_impl(self, browser_context_id: str) -> None:
+		return self._execute_function(
+				"Target.disposeBrowserContext",
+				{"browser_context_id": browser_context_id}
+		)
+	
+	def _expose_dev_tools_protocol_impl(
+			self,
+			target_id: str,
+			binding_name: Optional[str] = None,
+			inherit_permissions: Optional[bool] = None
+	) -> None:
+		return self._execute_function(
+				"Target.exposeDevToolsProtocol",
+				{
+					"target_id": target_id,
+					"binding_name": binding_name,
+					"inherit_permissions": inherit_permissions
+				}
+		)
+	
+	def _get_browser_contexts_impl(self) -> List[str]:
+		return self._execute_function("Target.getBrowserContexts", {})
+	
+	def _get_target_info_impl(self, target_id: Optional[str] = None) -> Dict[str, Any]:
+		return self._execute_function("Target.getTargetInfo", {"target_id": target_id})
+	
+	def _get_targets_impl(self, filter_: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]:
+		return self._execute_function("Target.getTargets", {"filter_": filter_})
+	
+	def _open_dev_tools_impl(self, target_id: str) -> str:
+		return self._execute_function("Target.openDevTools", {"target_id": target_id})
+	
+	def _send_message_to_target_impl(
+			self,
+			message: str,
+			session_id: Optional[str] = None,
+			target_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Target.sendMessageToTarget",
+				{"message": message, "session_id": session_id, "target_id": target_id}
+		)
+	
+	def _set_auto_attach_impl(
+			self,
+			auto_attach: bool,
+			wait_for_debugger_on_start: bool,
+			flatten: Optional[bool] = None,
+			filter_: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return self._execute_function(
+				"Target.setAutoAttach",
+				{
+					"auto_attach": auto_attach,
+					"wait_for_debugger_on_start": wait_for_debugger_on_start,
+					"flatten": flatten,
+					"filter_": filter_
+				}
+		)
+	
+	def _set_discover_targets_impl(self, discover: bool, filter_: Optional[List[Dict[str, Any]]] = None) -> None:
+		return self._execute_function("Target.setDiscoverTargets", {"discover": discover, "filter_": filter_})
+	
+	def _set_remote_locations_impl(self, locations: List[Dict[str, Any]]) -> None:
+		return self._execute_function("Target.setRemoteLocations", {"locations": locations})

osn_selenium/executors/unified/cdp/tethering.py

@@ -0,0 +1,15 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedTetheringCDPExecutor"]
+
+
+class UnifiedTetheringCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _bind_impl(self, port: int) -> None:
+		return self._execute_function("Tethering.bind", {"port": port})
+	
+	def _unbind_impl(self, port: int) -> None:
+		return self._execute_function("Tethering.unbind", {"port": port})

osn_selenium/executors/unified/cdp/tracing.py

@@ -0,0 +1,62 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedTracingCDPExecutor"]
+
+
+class UnifiedTracingCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _end_impl(self) -> None:
+		return self._execute_function("Tracing.end", {})
+	
+	def _get_categories_impl(self) -> List[str]:
+		return self._execute_function("Tracing.getCategories", {})
+	
+	def _record_clock_sync_marker_impl(self, sync_id: str) -> None:
+		return self._execute_function("Tracing.recordClockSyncMarker", {"sync_id": sync_id})
+	
+	def _request_memory_dump_impl(
+			self,
+			deterministic: Optional[bool] = None,
+			level_of_detail: Optional[str] = None
+	) -> Tuple[str, bool]:
+		return self._execute_function(
+				"Tracing.requestMemoryDump",
+				{"deterministic": deterministic, "level_of_detail": level_of_detail}
+		)
+	
+	def _start_impl(
+			self,
+			categories: Optional[str] = None,
+			options: Optional[str] = None,
+			buffer_usage_reporting_interval: Optional[float] = None,
+			transfer_mode: Optional[str] = None,
+			stream_format: Optional[str] = None,
+			stream_compression: Optional[str] = None,
+			trace_config: Optional[Dict[str, Any]] = None,
+			perfetto_config: Optional[str] = None,
+			tracing_backend: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Tracing.start",
+				{
+					"categories": categories,
+					"options": options,
+					"buffer_usage_reporting_interval": buffer_usage_reporting_interval,
+					"transfer_mode": transfer_mode,
+					"stream_format": stream_format,
+					"stream_compression": stream_compression,
+					"trace_config": trace_config,
+					"perfetto_config": perfetto_config,
+					"tracing_backend": tracing_backend
+				}
+		)

osn_selenium/executors/unified/cdp/web_audio.py

@@ -0,0 +1,18 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedWebAudioCDPExecutor"]
+
+
+class UnifiedWebAudioCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("WebAudio.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("WebAudio.enable", {})
+	
+	def _get_realtime_data_impl(self, context_id: str) -> Dict[str, Any]:
+		return self._execute_function("WebAudio.getRealtimeData", {"context_id": context_id})

osn_selenium/executors/unified/cdp/web_authn.py

@@ -0,0 +1,103 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["UnifiedWebAuthnCDPExecutor"]
+
+
+class UnifiedWebAuthnCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _add_credential_impl(self, authenticator_id: str, credential: Dict[str, Any]) -> None:
+		return self._execute_function(
+				"WebAuthn.addCredential",
+				{"authenticator_id": authenticator_id, "credential": credential}
+		)
+	
+	def _add_virtual_authenticator_impl(self, options: Dict[str, Any]) -> str:
+		return self._execute_function("WebAuthn.addVirtualAuthenticator", {"options": options})
+	
+	def _clear_credentials_impl(self, authenticator_id: str) -> None:
+		return self._execute_function("WebAuthn.clearCredentials", {"authenticator_id": authenticator_id})
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("WebAuthn.disable", {})
+	
+	def _enable_impl(self, enable_ui: Optional[bool] = None) -> None:
+		return self._execute_function("WebAuthn.enable", {"enable_ui": enable_ui})
+	
+	def _get_credential_impl(self, authenticator_id: str, credential_id: str) -> Dict[str, Any]:
+		return self._execute_function(
+				"WebAuthn.getCredential",
+				{"authenticator_id": authenticator_id, "credential_id": credential_id}
+		)
+	
+	def _get_credentials_impl(self, authenticator_id: str) -> List[Dict[str, Any]]:
+		return self._execute_function("WebAuthn.getCredentials", {"authenticator_id": authenticator_id})
+	
+	def _remove_credential_impl(self, authenticator_id: str, credential_id: str) -> None:
+		return self._execute_function(
+				"WebAuthn.removeCredential",
+				{"authenticator_id": authenticator_id, "credential_id": credential_id}
+		)
+	
+	def _remove_virtual_authenticator_impl(self, authenticator_id: str) -> None:
+		return self._execute_function(
+				"WebAuthn.removeVirtualAuthenticator",
+				{"authenticator_id": authenticator_id}
+		)
+	
+	def _set_automatic_presence_simulation_impl(self, authenticator_id: str, enabled: bool) -> None:
+		return self._execute_function(
+				"WebAuthn.setAutomaticPresenceSimulation",
+				{"authenticator_id": authenticator_id, "enabled": enabled}
+		)
+	
+	def _set_credential_properties_impl(
+			self,
+			authenticator_id: str,
+			credential_id: str,
+			backup_eligibility: Optional[bool] = None,
+			backup_state: Optional[bool] = None
+	) -> None:
+		return self._execute_function(
+				"WebAuthn.setCredentialProperties",
+				{
+					"authenticator_id": authenticator_id,
+					"credential_id": credential_id,
+					"backup_eligibility": backup_eligibility,
+					"backup_state": backup_state
+				}
+		)
+	
+	def _set_response_override_bits_impl(
+			self,
+			authenticator_id: str,
+			is_bogus_signature: Optional[bool] = None,
+			is_bad_uv: Optional[bool] = None,
+			is_bad_up: Optional[bool] = None
+	) -> None:
+		return self._execute_function(
+				"WebAuthn.setResponseOverrideBits",
+				{
+					"authenticator_id": authenticator_id,
+					"is_bogus_signature": is_bogus_signature,
+					"is_bad_uv": is_bad_uv,
+					"is_bad_up": is_bad_up
+				}
+		)
+	
+	def _set_user_verified_impl(self, authenticator_id: str, is_user_verified: bool) -> None:
+		return self._execute_function(
+				"WebAuthn.setUserVerified",
+				{
+					"authenticator_id": authenticator_id,
+					"is_user_verified": is_user_verified
+				}
+		)

osn_selenium/executors/unified/javascript.py

@@ -0,0 +1,104 @@
+from osn_selenium.javascript.models import JS_Scripts
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+from osn_selenium.javascript.functions import get_js_scripts
+from osn_selenium.javascript.fingerprint import FingerprintSettings
+from osn_selenium.models import (
+	Point,
+	Position,
+	Rectangle,
+	Size
+)
+
+
+__all__ = ["UnifiedJSExecutor"]
+
+
+class UnifiedJSExecutor:
+	"""
+	A unified executor for JavaScript scripts within the Selenium environment.
+	"""
+	
+	def __init__(self, execute_function: Callable[[str, Any], Any]):
+		"""
+		Initialize the UnifiedJSExecutor with an execution function.
+
+		Args:
+			execute_function (Callable[[str, Any], Any]): The function that performs the actual JS execution.
+		"""
+		
+		self._execute_function = execute_function
+		self._scripts = get_js_scripts()
+	
+	def _execute_impl(self, script: str, *args: Any) -> Any:
+		return self._execute_function(script, *args)
+	
+	def _check_element_in_viewport_impl(self, element: Any) -> bool:
+		return self._execute_impl(self._scripts.check_element_in_viewport, element)
+	
+	def _get_document_scroll_size_impl(self) -> Size:
+		size = self._execute_impl(self._scripts.get_document_scroll_size)
+		
+		return Size.model_validate(size)
+	
+	def _get_element_css_style_impl(self, element: Any) -> Dict[str, str]:
+		return self._execute_impl(self._scripts.get_element_css, element)
+	
+	def _get_element_rect_in_viewport_impl(self, element: Any) -> Rectangle:
+		rectangle = self._execute_impl(self._scripts.get_element_rect_in_viewport, element)
+		
+		return Rectangle.model_validate(rectangle)
+	
+	def _get_random_element_point_in_viewport_impl(self, element: Any, step: int = 1) -> Optional[Position]:
+		position = self._execute_impl(self._scripts.get_random_element_point_in_viewport, element, step)
+		
+		if position is not None:
+			return Position.model_validate(position)
+		
+		return None
+	
+	def _get_random_element_point_impl(self, element: Any) -> Optional[Point]:
+		point_in_viewport = self._get_random_element_point_in_viewport_impl(element=element, step=1)
+		
+		if point_in_viewport is not None:
+			element_viewport_pos = self._get_element_rect_in_viewport_impl(element=element)
+		
+			if element_viewport_pos is not None:
+				x = int(element_viewport_pos.x + point_in_viewport.x)
+				y = int(element_viewport_pos.y + point_in_viewport.y)
+		
+				return Point(x=x, y=y)
+		
+		return None
+	
+	def _get_viewport_position_impl(self) -> Position:
+		position = self._execute_impl(self._scripts.get_viewport_position)
+		
+		return Position.model_validate(position)
+	
+	def _get_viewport_rect_impl(self) -> Rectangle:
+		rectangle = self._execute_impl(self._scripts.get_viewport_rect)
+		
+		return Rectangle.model_validate(rectangle)
+	
+	def _get_viewport_size_impl(self) -> Size:
+		size = self._execute_impl(self._scripts.get_viewport_size)
+		
+		return Size.model_validate(size)
+	
+	def _open_new_tab_impl(self, link: str = "") -> None:
+		self._execute_impl(self._scripts.open_new_tab, link)
+	
+	@property
+	def _scripts_impl(self) -> JS_Scripts:
+		return self._scripts
+	
+	def _start_fingerprint_detection_impl(self, fingerprint_settings: FingerprintSettings) -> None:
+		self._execute_impl(fingerprint_settings.generate_js())
+	
+	def _stop_window_loading_impl(self) -> None:
+		self._execute_impl(self._scripts.stop_window_loading)

osn_selenium/flags/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/flags/_functions.py

@@ -0,0 +1,45 @@
+from osn_selenium._functions import validate_path
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.values import ArgumentValue
+
+
+__all__ = ["argument_to_flag", "build_first_start_argument"]
+
+
+def build_first_start_argument(browser_exe: PATH_TYPEHINT) -> str:
+	"""
+	Builds the first command line argument to start a browser executable.
+
+	This function constructs the initial command line argument needed to execute a browser,
+	handling different operating systems and executable path formats.
+
+	Args:
+		browser_exe (PATH_TYPEHINT): Path to the browser executable or just the executable name.
+
+	Returns:
+		str: The constructed command line argument string.
+
+	Raises:
+		TypeError: If `browser_exe` is not of type str or Path.
+	"""
+	
+	path = validate_path(path=browser_exe).resolve()
+	
+	return f"\"{str(path)}\""
+
+
+def argument_to_flag(argument: ArgumentValue) -> str:
+	"""
+	Format a command-line argument.
+
+	Args:
+		argument (ArgumentValue): Argument to format.
+
+	Returns:
+		str: Formatted argument.
+	"""
+	
+	if "{value}" in argument.command_line:
+		return argument.command_line.format(value=argument.value)
+	
+	return argument.command_line

osn_selenium/flags/_typehints.py

@@ -0,0 +1,34 @@
+from selenium import webdriver
+from typing import (
+	Any,
+	Literal,
+	Mapping,
+	Union
+)
+
+
+__all__ = [
+	"ANY_FLAGS_TYPEHINT",
+	"ANY_WEBDRIVER_OPTION_TYPEHINT",
+	"AUTOPLAY_POLICY_TYPEHINT",
+	"BLINK_WEBDRIVER_OPTION_TYPEHINT",
+	"LOG_LEVEL_TYPEHINT",
+	"USE_GL_TYPEHINT",
+	"VALID_AUTOPLAY_POLICIES",
+	"VALID_LOG_LEVELS",
+	"VALID_USE_GLS"
+]
+
+AUTOPLAY_POLICY_TYPEHINT = Literal["user-gesture-required", "no-user-gesture-required"]
+VALID_AUTOPLAY_POLICIES = ["user-gesture-required", "no-user-gesture-required"]
+
+LOG_LEVEL_TYPEHINT = Literal[0, 1, 2, 3]
+VALID_LOG_LEVELS = [0, 1, 2, 3]
+
+USE_GL_TYPEHINT = Literal["desktop", "egl", "swiftshader"]
+VALID_USE_GLS = ["desktop", "egl", "swiftshader"]
+
+ANY_FLAGS_TYPEHINT = Mapping[str, Any]
+
+ANY_WEBDRIVER_OPTION_TYPEHINT = Union[webdriver.ChromeOptions, webdriver.EdgeOptions]
+BLINK_WEBDRIVER_OPTION_TYPEHINT = Union[webdriver.ChromeOptions, webdriver.EdgeOptions]

osn_selenium/flags/_validators.py

@@ -0,0 +1,101 @@
+import os
+import pathlib
+from typing import Optional
+from osn_selenium._typehints import PATH_TYPEHINT
+
+
+__all__ = [
+	"bool_adding_validation_function",
+	"int_adding_validation_function",
+	"optional_bool_adding_validation_function",
+	"path_adding_validation_function",
+	"str_adding_validation_function"
+]
+
+
+def str_adding_validation_function(value: Optional[str]) -> bool:
+	"""
+	Validation function that checks if a value is a non-empty string.
+
+	Args:
+		value (Optional[str]): The value to validate.
+
+	Returns:
+		bool: `True` if the value is a non-empty string, `False` otherwise.
+	"""
+	
+	if value is not None and not isinstance(value, str):
+		return False
+	
+	return bool(value)
+
+
+def path_adding_validation_function(value: Optional[PATH_TYPEHINT]) -> bool:
+	"""
+	Validation function that checks if a value is a non-empty string or a Path object.
+
+	Args:
+		value (Optional[PATH_TYPEHINT]): The value to validate.
+
+	Returns:
+		bool: `True` if the value is a valid path-like object, `False` otherwise.
+	"""
+	
+	if value is not None and not isinstance(value, (str, bytes, pathlib.Path, os.PathLike)):
+		return False
+	
+	return bool(value)
+
+
+def optional_bool_adding_validation_function(value: Optional[bool]) -> bool:
+	"""
+	Validation function that checks if a value is a boolean or None.
+
+	The function returns `True` if the value is not None, allowing the flag
+	to be added.
+
+	Args:
+		value (Optional[bool]): The value to validate.
+
+	Returns:
+		bool: `True` if the value is not None, `False` if the value is not a boolean.
+	"""
+	
+	if value is not None and not isinstance(value, bool):
+		return False
+	
+	return value is not None
+
+
+def int_adding_validation_function(value: Optional[int]) -> bool:
+	"""
+	Validation function that checks if a value is an integer.
+
+	Args:
+		value (Optional[int]): The value to validate.
+
+	Returns:
+		bool: `True` if the value is an integer or None, `False` otherwise.
+	"""
+	
+	if value is not None and not isinstance(value, int):
+		return False
+	
+	return True
+
+
+def bool_adding_validation_function(value: Optional[bool]) -> bool:
+	"""
+	Validation function that checks if a value is a boolean and `True`.
+
+	Args:
+		value (Optional[bool]): The value to validate.
+
+	Returns:
+		bool: `True` if the value is `True`, `False` otherwise.
+	"""
+	
+	if not isinstance(value, bool):
+		return False
+	
+	return value