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

osn_selenium/abstract/executors/cdp/web_authn.py

@@ -0,0 +1,76 @@
+from abc import ABC, abstractmethod
+from typing import (
+	Any,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["AbstractWebAuthnCDPExecutor"]
+
+
+class AbstractWebAuthnCDPExecutor(ABC):
+	@abstractmethod
+	def add_credential(self, authenticator_id: str, credential: Dict[str, Any]) -> None:
+		...
+	
+	@abstractmethod
+	def add_virtual_authenticator(self, options: Dict[str, Any]) -> str:
+		...
+	
+	@abstractmethod
+	def clear_credentials(self, authenticator_id: str) -> None:
+		...
+	
+	@abstractmethod
+	def disable(self) -> None:
+		...
+	
+	@abstractmethod
+	def enable(self, enable_ui: Optional[bool] = None) -> None:
+		...
+	
+	@abstractmethod
+	def get_credential(self, authenticator_id: str, credential_id: str) -> Dict[str, Any]:
+		...
+	
+	@abstractmethod
+	def get_credentials(self, authenticator_id: str) -> List[Dict[str, Any]]:
+		...
+	
+	@abstractmethod
+	def remove_credential(self, authenticator_id: str, credential_id: str) -> None:
+		...
+	
+	@abstractmethod
+	def remove_virtual_authenticator(self, authenticator_id: str) -> None:
+		...
+	
+	@abstractmethod
+	def set_automatic_presence_simulation(self, authenticator_id: str, enabled: bool) -> None:
+		...
+	
+	@abstractmethod
+	def set_credential_properties(
+			self,
+			authenticator_id: str,
+			credential_id: str,
+			backup_eligibility: Optional[bool] = None,
+			backup_state: Optional[bool] = None
+	) -> None:
+		...
+	
+	@abstractmethod
+	def set_response_override_bits(
+			self,
+			authenticator_id: str,
+			is_bogus_signature: Optional[bool] = None,
+			is_bad_uv: Optional[bool] = None,
+			is_bad_up: Optional[bool] = None
+	) -> None:
+		...
+	
+	@abstractmethod
+	def set_user_verified(self, authenticator_id: str, is_user_verified: bool) -> None:
+		...

osn_selenium/abstract/executors/javascript.py

@@ -0,0 +1,203 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+from osn_selenium.javascript.models import JS_Scripts
+from selenium.webdriver.remote.webelement import WebElement
+from osn_selenium.javascript.fingerprint import FingerprintSettings
+from osn_selenium.models import (
+	Point,
+	Position,
+	Rectangle,
+	Size
+)
+
+
+__all__ = ["AbstractJSExecutor"]
+
+
+class AbstractJSExecutor(ABC):
+	"""
+	Abstract base class for executing JavaScript commands in a browser context.
+
+	This class defines the interface for interacting with JavaScript scripts,
+	including checking element visibility, getting computed styles, and managing
+	viewport properties.
+	"""
+	
+	@abstractmethod
+	def check_element_in_viewport(self, element: WebElement) -> bool:
+		"""
+		Checks if the element is currently visible within the viewport.
+
+		Args:
+			element (WebElement): The element to check.
+
+		Returns:
+			bool: True if the element is fully within the viewport,
+				otherwise False.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def execute(self, script: str, *args: Any) -> Any:
+		"""
+		Executes a JavaScript snippet.
+
+		Args:
+			script (str): The JavaScript code to execute.
+			*args (Any): Arguments to pass to the script.
+
+		Returns:
+			Any: The result of the script execution.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_document_scroll_size(self) -> Size:
+		"""
+		Gets the total scrollable width and height of the document.
+
+		Returns:
+			Size: An object containing the scroll width and height.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_element_css_style(self, element: WebElement) -> Dict[str, str]:
+		"""
+		Retrieves all computed CSS properties for an element.
+
+		Args:
+			element (WebElement): The element to get the style from.
+
+		Returns:
+			Dict[str, str]: A dictionary of CSS properties and their values.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_element_rect_in_viewport(self, element: WebElement) -> Rectangle:
+		"""
+		Gets the element's position and size relative to the viewport.
+
+		Args:
+			element (WebElement): The element to measure.
+
+		Returns:
+			Rectangle: An object with the x, y, width, and height of the
+				element.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_random_element_point(self, element: WebElement) -> Optional[Point]:
+		"""
+		Gets a random point within an element, relative to the viewport.
+
+		Args:
+			element (WebElement): The element to find a point in.
+
+		Returns:
+			Optional[Point]: An object with the x and y coordinates of the random
+				point relative to the viewport, or None if no point is found.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_random_element_point_in_viewport(self, element: WebElement, step: int = 1) -> Optional[Position]:
+		"""
+		Calculates a random point within an element's visible area.
+
+		Args:
+			element (WebElement): The element to find a point within.
+			step (int): The grid step for sampling points. Defaults to 1.
+
+		Returns:
+			Optional[Position]: An object with x and y coordinates relative to
+				the element's top-left corner, or None if no point is found.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_viewport_position(self) -> Position:
+		"""
+		Gets the viewport's current scroll position relative to the document.
+
+		Returns:
+			Position: An object containing the x (horizontal) and y
+				(vertical) scroll offsets.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_viewport_rect(self) -> Rectangle:
+		"""
+		Gets the viewport's position and size relative to the document.
+
+		Returns:
+			Rectangle: An object with the scroll offsets (x, y) and
+				dimensions (width, height) of the viewport.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_viewport_size(self) -> Size:
+		"""
+		Gets the current dimensions of the browser's viewport.
+
+		Returns:
+			Size: An object containing the width and height of the viewport.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def open_new_tab(self, link: str = "") -> None:
+		"""
+		Opens a new browser tab.
+
+		Args:
+			link (str): The URL to open. If empty, a blank tab is opened.
+				Defaults to "".
+		"""
+		
+		...
+	
+	@property
+	@abstractmethod
+	def scripts(self) -> JS_Scripts:
+		"""
+		Provides access to the loaded JavaScript snippets.
+
+		Returns:
+			JS_Scripts: An object holding the predefined JS scripts.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def start_fingerprint_detection(self, fingerprint_settings: FingerprintSettings) -> None:
+		"""
+		Initiate fingerprint detection based on the provided settings.
+
+		Args:
+			fingerprint_settings (FingerprintSettings): The settings used for fingerprint detection.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def stop_window_loading(self) -> None:
+		"""
+		Stops the current page from loading.
+		"""
+		
+		...

osn_selenium/abstract/instances/action_chains/__init__.py

@@ -0,0 +1,12 @@
+from abc import ABC
+
+
+__all__ = ["AbstractActionChains"]
+
+
+class AbstractActionChains(ABC):
+	"""
+	Abstract base class for action chains, serving as the core interface for complex interaction sequences.
+	"""
+	
+	pass

osn_selenium/abstract/instances/action_chains/base.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from selenium.webdriver.common.action_chains import (
+	ActionChains as legacyActionChains
+)
+
+
+__all__ = ["AbstractBaseMixin"]
+
+
+class AbstractBaseMixin(ABC):
+	"""
+	Base mixin class providing access to the legacy Selenium ActionChains.
+	"""
+	
+	@property
+	@abstractmethod
+	def legacy(self) -> legacyActionChains:
+		"""
+		Returns the legacy Selenium ActionChains object.
+
+		Returns:
+			legacyActionChains: The underlying Selenium action chain object.
+		"""
+		
+		...

osn_selenium/abstract/instances/action_chains/click.py

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+
+
+__all__ = ["AbstractClickMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+
+
+class AbstractClickMixin(ABC):
+	"""
+	Mixin class providing abstract methods for mouse click interactions.
+	"""
+	
+	@abstractmethod
+	def click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "AbstractActionChains":
+		"""
+		Performs a click action.
+
+		Args:
+			on_element (Optional[WEB_ELEMENT_TYPEHINT]): The element to click.
+				If None, clicks at the current mouse position.
+
+		Returns:
+			AbstractActionChains: The instance of ActionChains for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def click_and_hold(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "AbstractActionChains":
+		"""
+		Clicks and holds the mouse button down.
+
+		Args:
+			on_element (Optional[WEB_ELEMENT_TYPEHINT]): The element to click on.
+				If None, clicks at the current mouse position.
+
+		Returns:
+			AbstractActionChains: The instance of ActionChains for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def context_click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "AbstractActionChains":
+		"""
+		Performs a right-click action.
+
+		Args:
+			on_element (Optional[WEB_ELEMENT_TYPEHINT]): The element to right-click.
+				If None, right-clicks at the current mouse position.
+
+		Returns:
+			AbstractActionChains: The instance of ActionChains for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def double_click(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "AbstractActionChains":
+		"""
+		Performs a double-click action.
+
+		Args:
+			on_element (Optional[WEB_ELEMENT_TYPEHINT]): The element to double-click.
+				If None, double-clicks at the current mouse position.
+
+		Returns:
+			AbstractActionChains: The instance of ActionChains for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def release(self, on_element: Optional[WEB_ELEMENT_TYPEHINT]) -> "AbstractActionChains":
+		"""
+		Releases a held mouse button.
+
+		Args:
+			on_element (Optional[WEB_ELEMENT_TYPEHINT]): The element on which to release the button.
+				If None, releases at the current mouse position.
+
+		Returns:
+			AbstractActionChains: The instance of ActionChains for method chaining.
+		"""
+		
+		...

osn_selenium/abstract/instances/action_chains/drag_and_drop.py

@@ -0,0 +1,46 @@
+from typing import TYPE_CHECKING
+from abc import ABC, abstractmethod
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+
+
+__all__ = ["AbstractDragAndDropMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+
+
+class AbstractDragAndDropMixin(ABC):
+	"""
+	Mixin class providing abstract methods for drag and drop interactions.
+	"""
+	
+	@abstractmethod
+	def drag_and_drop(self, source: WEB_ELEMENT_TYPEHINT, target: WEB_ELEMENT_TYPEHINT) -> "AbstractActionChains":
+		"""
+		Drags an element and drops it onto another element.
+
+		Args:
+			source (WEB_ELEMENT_TYPEHINT): The element to drag.
+			target (WEB_ELEMENT_TYPEHINT): The element to drop on.
+
+		Returns:
+			AbstractActionChains: The instance of ActionChains for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def drag_and_drop_by_offset(self, source: WEB_ELEMENT_TYPEHINT, xoffset: int, yoffset: int) -> "AbstractActionChains":
+		"""
+		Drags an element by a given offset.
+
+		Args:
+			source (WEB_ELEMENT_TYPEHINT): The element to drag.
+			xoffset (int): The horizontal offset to drag by.
+			yoffset (int): The vertical offset to drag by.
+
+		Returns:
+			AbstractActionChains: The instance of ActionChains for method chaining.
+		"""
+		
+		...

osn_selenium/abstract/instances/action_chains/hm_keyboard.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING
+from abc import ABC, abstractmethod
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+
+
+__all__ = ["AbstractHMKeyboardMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+
+
+class AbstractHMKeyboardMixin(ABC):
+	"""
+	Mixin class providing abstract methods for human-like keyboard interactions.
+	"""
+	
+	@abstractmethod
+	def hm_send_keys(self, text: str) -> "AbstractActionChains":
+		"""
+		Simulates human-like text input with variable delays.
+
+		Args:
+			text (str): The text to be typed.
+
+		Returns:
+			"AbstractActionChains": The instance for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def hm_send_keys_to_element(self, element: WEB_ELEMENT_TYPEHINT, text: str) -> "AbstractActionChains":
+		"""
+		Simulates human-like text input into a specific element with variable delays.
+
+		Args:
+			element (WEB_ELEMENT_TYPEHINT): The target element to type into.
+			text (str): The text to be typed.
+
+		Returns:
+			"AbstractActionChains": The instance for method chaining.
+		"""
+		
+		...

osn_selenium/abstract/instances/action_chains/hm_move.py

@@ -0,0 +1,104 @@
+from abc import ABC, abstractmethod
+from osn_selenium.models import Point
+from typing import TYPE_CHECKING, Tuple
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+
+
+__all__ = ["AbstractHMMoveMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+
+
+class AbstractHMMoveMixin(ABC):
+	"""
+	Mixin class providing abstract methods for human-like mouse movement interactions.
+	"""
+	
+	@abstractmethod
+	def hm_move(self, start_position: Point, end_position: Point) -> "AbstractActionChains":
+		"""
+		Moves the mouse cursor from a start to an end position in a human-like curve.
+
+		Args:
+			start_position (Point): The starting coordinates.
+			end_position (Point): The ending coordinates.
+
+		Returns:
+			AbstractActionChains: The instance for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def hm_move_by_offset(self, start_position: Point, xoffset: int, yoffset: int) -> Tuple["AbstractActionChains", Point]:
+		"""
+		Moves the mouse cursor by a given offset from a starting Point in a human-like way.
+
+		Args:
+			start_position (Point): The starting coordinates of the mouse.
+			xoffset (int): The horizontal offset to move by.
+			yoffset (int): The vertical offset to move by.
+
+		Returns:
+			Tuple[AbstractActionChains, Point]: A tuple containing the instance for
+				method chaining and the final Point coordinates of the cursor.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def hm_move_to_element(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple["AbstractActionChains", Point]:
+		"""
+		Moves the mouse cursor to the center of an element in a human-like way.
+
+		Args:
+			start_position (Point): The starting coordinates of the mouse.
+			element (WEB_ELEMENT_TYPEHINT): The target element to move to.
+
+		Returns:
+			Tuple[AbstractActionChains, Point]: A tuple containing the instance for
+				method chaining and the final Point coordinates of the cursor.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def hm_move_to_element_with_offset(
+			self,
+			start_position: Point,
+			element: WEB_ELEMENT_TYPEHINT,
+			xoffset: int,
+			yoffset: int
+	) -> Tuple["AbstractActionChains", Point]:
+		"""
+		Moves the mouse cursor to a specific offset within an element in a human-like way.
+
+		Args:
+			start_position (Point): The starting coordinates of the mouse.
+			element (WEB_ELEMENT_TYPEHINT): The target element.
+			xoffset (int): The horizontal offset from the element's top-left corner.
+			yoffset (int): The vertical offset from the element's top-left corner.
+
+		Returns:
+			Tuple[AbstractActionChains, Point]: A tuple containing the instance for
+				method chaining and the final Point coordinates of the cursor.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def hm_move_to_element_with_random_offset(self, start_position: Point, element: WEB_ELEMENT_TYPEHINT) -> Tuple["AbstractActionChains", Point]:
+		"""
+		Moves the mouse cursor to a random Point within an element in a human-like way.
+
+		Args:
+			start_position (Point): The starting coordinates of the mouse.
+			element (WEB_ELEMENT_TYPEHINT): The target element to move to.
+
+		Returns:
+			Tuple[AbstractActionChains, Point]: A tuple containing the instance for
+				method chaining and the final Point coordinates of the cursor.
+		"""
+		
+		...

osn_selenium/abstract/instances/action_chains/hm_scroll.py

@@ -0,0 +1,75 @@
+from abc import ABC, abstractmethod
+from typing import (
+	Optional,
+	TYPE_CHECKING
+)
+from osn_selenium.instances._typehints import WEB_ELEMENT_TYPEHINT
+from selenium.webdriver.common.actions.wheel_input import ScrollOrigin
+
+
+__all__ = ["AbstractHMScrollMixin"]
+
+if TYPE_CHECKING:
+	from osn_selenium.abstract.instances.action_chains import AbstractActionChains
+
+
+class AbstractHMScrollMixin(ABC):
+	"""
+	Mixin class providing abstract methods for human-like scrolling interactions.
+	"""
+	
+	@abstractmethod
+	def hm_scroll_by_amount(self, delta_x: int, delta_y: int) -> "AbstractActionChains":
+		"""
+		Simulates smooth, human-like scrolling by a specific amount.
+
+		Args:
+			delta_x (int): The horizontal distance to scroll.
+			delta_y (int): The vertical distance to scroll.
+
+		Returns:
+			AbstractActionChains: The instance for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def hm_scroll_from_origin(self, delta_x: int, delta_y: int, origin: Optional[ScrollOrigin] = None) -> "AbstractActionChains":
+		"""
+		Simulates smooth, human-like scrolling from a specific origin.
+
+		Args:
+			delta_x (int): The horizontal distance to scroll.
+			delta_y (int): The vertical distance to scroll.
+			origin (Optional[ScrollOrigin]): The origin Point for scrolling. If None, it's determined automatically.
+
+		Returns:
+			AbstractActionChains: The instance for method chaining.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def hm_scroll_to_element(
+			self,
+			element: WEB_ELEMENT_TYPEHINT,
+			additional_lower_y_offset: int = 0,
+			additional_upper_y_offset: int = 0,
+			additional_right_x_offset: int = 0,
+			additional_left_x_offset: int = 0
+	) -> "AbstractActionChains":
+		"""
+		Scrolls smoothly to bring an element into view, avoiding viewport edges.
+
+		Args:
+			element (WEB_ELEMENT_TYPEHINT): The target element to scroll to.
+			additional_lower_y_offset (int): Additional offset from the bottom edge of the viewport.
+			additional_upper_y_offset (int): Additional offset from the top edge of the viewport.
+			additional_right_x_offset (int): Additional offset from the right edge of the viewport.
+			additional_left_x_offset (int): Additional offset from the left edge of the viewport.
+
+		Returns:
+			AbstractActionChains: The instance for method chaining.
+		"""
+		
+		...