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

osn_selenium/abstract/webdriver/core/components.py

@@ -0,0 +1,82 @@
+from abc import ABC, abstractmethod
+from osn_selenium.abstract.instances.dialog import AbstractDialog
+from osn_selenium.abstract.instances.mobile import AbstractMobile
+from osn_selenium.abstract.instances.browser import AbstractBrowser
+from osn_selenium.abstract.instances.permissions import AbstractPermissions
+from osn_selenium.abstract.instances.web_extension import AbstractWebExtension
+from osn_selenium.abstract.instances.browsing_context import (
+	AbstractBrowsingContext
+)
+
+
+__all__ = ["AbstractCoreComponentsMixin"]
+
+
+class AbstractCoreComponentsMixin(ABC):
+	"""Mixin responsible for accessing various sub-components of the browser."""
+	
+	@abstractmethod
+	def browser(self) -> AbstractBrowser:
+		"""
+		Provides access to browser-level actions.
+
+		Returns:
+			AbstractBrowser: An object for controlling browser-level features.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def browsing_context(self) -> AbstractBrowsingContext:
+		"""
+		Provides access to the browsing context interface (e.g., tabs, windows).
+
+		Returns:
+			AbstractBrowsingContext: An object for managing browsing contexts.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def dialog(self) -> AbstractDialog:
+		"""
+		Provides access to the dialog (alert, prompt, confirm) interface.
+
+		Returns:
+			AbstractDialog: An object for interacting with browser dialogs.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def mobile(self) -> AbstractMobile:
+		"""
+		Provides access to mobile-specific functionality.
+
+		Returns:
+			AbstractMobile: An object for mobile-specific interactions.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def permissions(self) -> AbstractPermissions:
+		"""
+		Provides access to the permissions management interface.
+
+		Returns:
+			AbstractPermissions: An object for managing browser permissions.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def webextension(self) -> AbstractWebExtension:
+		"""
+		Provides access to the web extension management interface.
+
+		Returns:
+			AbstractWebExtension: An object to manage browser extensions.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/devtools.py

@@ -0,0 +1,69 @@
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
+from typing import (
+	Any,
+	AsyncGenerator,
+	Dict,
+	Tuple
+)
+from osn_selenium.abstract.instances.network import AbstractNetwork
+from selenium.webdriver.remote.bidi_connection import BidiConnection
+from selenium.webdriver.remote.websocket_connection import WebSocketConnection
+
+
+__all__ = ["AbstractCoreDevToolsMixin"]
+
+
+class AbstractCoreDevToolsMixin(ABC):
+	"""
+	Mixin responsible for CDP (Chrome DevTools Protocol), BiDi, and Network interactions.
+	"""
+	
+	@asynccontextmanager
+	@abstractmethod
+	async def bidi_connection(self) -> AsyncGenerator[BidiConnection, Any]:
+		"""
+		Returns a context manager for a BiDi (WebDriver Bi-Directional) connection.
+
+		Returns:
+			AsyncGenerator[BidiConnection, Any]: The BiDi connection context manager.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def execute_cdp_cmd(self, cmd: str, cmd_args: Dict[str, Any]) -> Dict[str, Any]:
+		"""
+		Executes a Chrome DevTools Protocol command.
+
+		Args:
+			cmd (str): The CDP command to execute.
+			cmd_args (Dict[str, Any]): The arguments for the command.
+
+		Returns:
+			Dict[str, Any]: The result of the command execution.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def network(self) -> AbstractNetwork:
+		"""
+		Provides access to the network interception and monitoring interface.
+
+		Returns:
+			AbstractNetwork: An object for interacting with network events.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def start_devtools(self) -> Tuple[Any, WebSocketConnection]:
+		"""
+		Starts a connection to the browser's developer tools.
+
+		Returns:
+			Tuple[Any, WebSocketConnection]: A tuple containing the DevTools session info and WebSocket connection.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/element.py

@@ -0,0 +1,55 @@
+from typing import List, Optional
+from abc import ABC, abstractmethod
+from selenium.webdriver.common.by import By
+from osn_selenium.abstract.instances.web_element import AbstractWebElement
+
+
+__all__ = ["AbstractCoreElementMixin"]
+
+
+class AbstractCoreElementMixin(ABC):
+	"""Mixin responsible for finding and creating web elements."""
+	
+	@abstractmethod
+	def create_web_element(self, element_id: str) -> AbstractWebElement:
+		"""
+		Creates a WebElement from an element ID.
+
+		Args:
+			element_id (str): The ID of the element.
+
+		Returns:
+			AbstractWebElement: The created WebElement instance.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def find_element(self, by: By = By.ID, value: Optional[str] = None) -> AbstractWebElement:
+		"""
+		Finds an element within the current context using the given mechanism.
+
+		Args:
+			by (By): The strategy to use for finding the element (e.g., By.ID).
+			value (Optional[str]): The value to search for.
+
+		Returns:
+			AbstractWebElement: The found WebElement.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def find_elements(self, by: By = By.ID, value: Optional[str] = None) -> List[AbstractWebElement]:
+		"""
+		Finds all elements within the current context using the given mechanism.
+
+		Args:
+			by (By): The strategy to use for finding elements (e.g., By.ID).
+			value (Optional[str]): The value to search for.
+
+		Returns:
+			List[AbstractWebElement]: A list of found WebElements.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/file.py

@@ -0,0 +1,82 @@
+from typing import Any, List
+from abc import ABC, abstractmethod
+
+
+__all__ = ["AbstractCoreFileMixin"]
+
+
+class AbstractCoreFileMixin(ABC):
+	"""
+	Mixin responsible for browser-level file handling and detection.
+	"""
+	
+	@abstractmethod
+	def delete_downloadable_files(self) -> None:
+		"""
+		Deletes all files currently available for download in the browser session.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def download_file(self, file_name: str, target_directory: str) -> None:
+		"""
+		Downloads a specified file from the browser to a local target directory.
+
+		Args:
+			file_name (str): The name of the file to download.
+			target_directory (str): The absolute path to the local directory.
+		"""
+		
+		...
+	
+	@property
+	@abstractmethod
+	def file_detector(self) -> Any:
+		"""
+		Gets the file detector used for uploading files to the remote server.
+
+		Returns:
+			Any: The file detector instance.
+		"""
+		
+		...
+	
+	@file_detector.setter
+	@abstractmethod
+	def file_detector(self, value: Any) -> None:
+		"""
+		Sets the file detector for the current session.
+
+		Args:
+			value (Any): The new file detector instance.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def file_detector_context(self, file_detector_class: Any, *args: Any, **kwargs: Any) -> Any:
+		"""
+		Context manager to temporarily use a specific file detector.
+
+		Args:
+			file_detector_class (Any): The class of the file detector to use.
+			*args (Any): Variable positional arguments for the detector.
+			**kwargs (Any): Variable keyword arguments for the detector.
+
+		Returns:
+			Any: The context manager instance.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_downloadable_files(self) -> List[str]:
+		"""
+		Gets a list of files available for download from the browser.
+
+		Returns:
+			List[str]: A list of downloadable file names.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/lifecycle.py

@@ -0,0 +1,103 @@
+from abc import ABC, abstractmethod
+from osn_selenium.models import WindowRect
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Union
+)
+from osn_selenium.flags.models.base import BrowserFlags
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+
+
+__all__ = ["AbstractCoreLifecycleMixin"]
+
+
+class AbstractCoreLifecycleMixin(ABC):
+	"""Mixin responsible for driver lifecycle, creation, session, and connection management."""
+	
+	@abstractmethod
+	def close_webdriver(self) -> None:
+		"""
+		Closes the WebDriver instance and all associated windows.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def quit(self) -> None:
+		"""
+		Quits the driver and closes every associated window.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def remote_connect_driver(self, command_executor: Union[str, RemoteConnection]) -> None:
+		"""
+		Connects to a remote WebDriver server.
+
+		Args:
+			command_executor (Union[str, RemoteConnection]): The URL of the remote server or a RemoteConnection object.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def restart_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		"""
+		Closes the current WebDriver instance and starts a new one.
+
+		Args:
+			flags (Optional[BrowserFlags]): Browser flags for the new instance.
+			window_rect (Optional[WindowRect]): Window dimensions for the new instance.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def start_client(self) -> None:
+		"""
+		Starts the underlying webdriver client.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def start_session(self, capabilities: Dict[str, Any]) -> None:
+		"""
+		Starts a new WebDriver session with the given capabilities.
+
+		Args:
+			capabilities (Dict[str, Any]): A dictionary of desired capabilities.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def start_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		"""
+		Starts the WebDriver instance.
+
+		Args:
+			flags (Optional[BrowserFlags]): Browser flags to apply on startup.
+			window_rect (Optional[WindowRect]): Initial window dimensions and position.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def stop_client(self) -> None:
+		"""
+		Stops the underlying webdriver client.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/navigation.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+
+
+__all__ = ["AbstractCoreNavigationMixin"]
+
+
+class AbstractCoreNavigationMixin(ABC):
+	"""Mixin responsible for page navigation."""
+	
+	@abstractmethod
+	def back(self) -> None:
+		"""
+		Goes one step backward in the browser history.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def current_url(self) -> str:
+		"""
+		Gets the URL of the current page.
+
+		Returns:
+			str: The URL of the current page.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def forward(self) -> None:
+		"""
+		Goes one step forward in the browser history.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get(self, url: str) -> None:
+		"""
+		Loads a web page in the current browser session.
+
+		Args:
+			url (str): The URL to load.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def refresh(self) -> None:
+		"""
+		Refreshes the current page.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def title(self) -> str:
+		"""
+		Gets the title of the current page.
+
+		Returns:
+			str: The title of the current page.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/script.py

@@ -0,0 +1,88 @@
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional
+from osn_selenium.abstract.instances.script import AbstractScript
+
+
+__all__ = ["AbstractCoreScriptMixin"]
+
+
+class AbstractCoreScriptMixin(ABC):
+	"""Mixin responsible for Javascript execution and script management."""
+	
+	@abstractmethod
+	def execute_async_script(self, script: str, *args: Any) -> Any:
+		"""
+		Asynchronously executes JavaScript in the current window/frame.
+
+		Args:
+			script (str): The JavaScript to execute.
+			*args (Any): Any arguments to pass to the script.
+
+		Returns:
+			Any: The value returned by the script's callback.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def execute_script(self, script: str, *args: Any) -> Any:
+		"""
+		Synchronously executes JavaScript in the current window/frame.
+
+		Args:
+			script (str): The JavaScript to execute.
+			*args (Any): Any arguments to pass to the script.
+
+		Returns:
+			Any: The value returned by the script.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_pinned_scripts(self) -> List[str]:
+		"""
+		Gets a list of all currently pinned scripts.
+
+		Returns:
+			List[str]: A list of pinned scripts.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def pin_script(self, script: str, script_key: Optional[Any] = None) -> Any:
+		"""
+		Pins a script to the browser for faster execution.
+
+		Args:
+			script (str): The JavaScript to pin.
+			script_key (Optional[Any]): An optional key to identify the script.
+
+		Returns:
+			Any: The key associated with the pinned script.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def script(self) -> AbstractScript:
+		"""
+		Provides access to the script execution interface.
+
+		Returns:
+			AbstractScript: An object for managing and executing scripts.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def unpin(self, script_key: Any) -> None:
+		"""
+		Unpins a previously pinned script.
+
+		Args:
+			script_key (Any): The key of the script to unpin.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/settings.py

@@ -0,0 +1,43 @@
+from typing import Optional
+from abc import ABC, abstractmethod
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.models.base import BrowserFlags
+
+
+__all__ = ["AbstractCoreSettingsMixin"]
+
+
+class AbstractCoreSettingsMixin(ABC):
+	"""Mixin responsible for browser flags and settings."""
+	
+	@abstractmethod
+	def reset_settings(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		"""
+		Resets the WebDriver settings to a default or specified state.
+
+		Args:
+			flags (Optional[BrowserFlags]): Browser flags to reset to.
+			window_rect (Optional[WindowRect]): Window dimensions to reset to.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def update_settings(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		"""
+		Updates the WebDriver settings with new flags or window dimensions.
+
+		Args:
+			flags (Optional[BrowserFlags]): Browser flags to add or update.
+			window_rect (Optional[WindowRect]): New window dimensions and position.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/storage.py

@@ -0,0 +1,81 @@
+from abc import ABC, abstractmethod
+from typing import (
+	Any,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.abstract.instances.storage import AbstractStorage
+
+
+__all__ = ["AbstractCoreStorageMixin"]
+
+
+class AbstractCoreStorageMixin(ABC):
+	"""Mixin responsible for cookies and storage."""
+	
+	@abstractmethod
+	def add_cookie(self, cookie_dict: Dict[str, Any]) -> None:
+		"""
+		Adds a cookie to the current session.
+
+		Args:
+			cookie_dict (Dict[str, Any]): A dictionary representing the cookie to add.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def delete_all_cookies(self) -> None:
+		"""
+		Deletes all cookies for the current session.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def delete_cookie(self, name: str) -> None:
+		"""
+		Deletes a single cookie with the given name.
+
+		Args:
+			name (str): The name of the cookie to delete.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_cookie(self, name: str) -> Optional[Dict[str, Any]]:
+		"""
+		Gets a single cookie with the given name.
+
+		Args:
+			name (str): The name of the cookie.
+
+		Returns:
+			Optional[Dict[str, Any]]: The cookie dictionary, or None if not found.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def get_cookies(self) -> List[Dict[str, Any]]:
+		"""
+		Returns all cookies for the current session.
+
+		Returns:
+			List[Dict[str, Any]]: A list of dictionaries, each representing a cookie.
+		"""
+		
+		...
+	
+	@abstractmethod
+	def storage(self) -> AbstractStorage:
+		"""
+		Provides access to the browser's storage mechanisms (e.g., cookies, local storage).
+
+		Returns:
+			AbstractStorage: An object for interacting with browser storage.
+		"""
+		
+		...