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

osn_selenium/instances/sync/browsing_context.py

@@ -0,0 +1,193 @@
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances._typehints import (
+	BROWSING_CONTEXT_TYPEHINT
+)
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.instances.unified.browsing_context import (
+	UnifiedBrowsingContext
+)
+from osn_selenium.abstract.instances.browsing_context import (
+	AbstractBrowsingContext
+)
+from selenium.webdriver.common.bidi.browsing_context import (
+	BrowsingContext as legacyBrowsingContext,
+	BrowsingContextInfo
+)
+
+
+__all__ = ["BrowsingContext"]
+
+
+class BrowsingContext(UnifiedBrowsingContext, AbstractBrowsingContext):
+	"""
+	Wrapper for the legacy Selenium BiDi BrowsingContext instance.
+
+	Controls browser tabs and windows (contexts), allowing navigation,
+	reloading, closing, screenshotting, and DOM tree inspection.
+	"""
+	
+	def __init__(self, selenium_browsing_context: legacyBrowsingContext) -> None:
+		"""
+		Initializes the BrowsingContext wrapper.
+
+		Args:
+			selenium_browsing_context (legacyBrowsingContext): The legacy Selenium instance to wrap.
+		"""
+		
+		UnifiedBrowsingContext.__init__(self, selenium_browsing_context=selenium_browsing_context)
+	
+	def activate(self, context: str) -> Any:
+		return self._activate_impl(context=context)
+	
+	def add_event_handler(
+			self,
+			event: str,
+			callback: Callable,
+			contexts: Optional[List[str]] = None,
+	) -> int:
+		return self._add_event_handler_impl(event=event, callback=callback, contexts=contexts)
+	
+	def capture_screenshot(
+			self,
+			context: str,
+			origin: str = "viewport",
+			format: Optional[Dict] = None,
+			clip: Optional[Dict] = None,
+	) -> str:
+		return self._capture_screenshot_impl(context=context, origin=origin, format=format, clip=clip)
+	
+	def clear_event_handlers(self) -> None:
+		self._clear_event_handlers_impl()
+	
+	def close(self, context: str, prompt_unload: bool = False) -> None:
+		self._close_impl(context=context, prompt_unload=prompt_unload)
+	
+	def create(
+			self,
+			type: str,
+			reference_context: Optional[str] = None,
+			background: bool = False,
+			user_context: Optional[str] = None,
+	) -> str:
+		return self._create_impl(
+				type=type,
+				reference_context=reference_context,
+				background=background,
+				user_context=user_context
+		)
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: BROWSING_CONTEXT_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium BrowsingContext object.
+
+		This factory method is used to wrap an existing Selenium BrowsingContext
+		instance into the new interface.
+
+		Args:
+			legacy_object (BROWSING_CONTEXT_TYPEHINT): The legacy Selenium BrowsingContext instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing BrowsingContext.
+		"""
+		
+		legacy_browsing_context_obj = get_legacy_instance(instance=legacy_object)
+		if not isinstance(legacy_browsing_context_obj, legacyBrowsingContext):
+			raise CannotConvertTypeError(from_=legacyBrowsingContext, to_=legacy_object)
+		
+		return cls(selenium_browsing_context=legacy_browsing_context_obj)
+	
+	def get_tree(self, max_depth: Optional[int] = None, root: Optional[str] = None) -> List[BrowsingContextInfo]:
+		return self._get_tree_impl(max_depth=max_depth, root=root)
+	
+	def handle_user_prompt(
+			self,
+			context: str,
+			accept: Optional[bool] = None,
+			user_text: Optional[str] = None,
+	) -> None:
+		self._handle_user_prompt_impl(context=context, accept=accept, user_text=user_text)
+	
+	@property
+	def legacy(self) -> legacyBrowsingContext:
+		return self._legacy_impl
+	
+	def locate_nodes(
+			self,
+			context: str,
+			locator: Dict,
+			max_node_count: Optional[int] = None,
+			serialization_options: Optional[Dict] = None,
+			start_nodes: Optional[List[Dict]] = None,
+	) -> List[Dict]:
+		return self._locate_nodes_impl(
+				context=context,
+				locator=locator,
+				max_node_count=max_node_count,
+				serialization_options=serialization_options,
+				start_nodes=start_nodes
+		)
+	
+	def navigate(self, context: str, url: str, wait: Optional[str] = None) -> Dict:
+		return self._navigate_impl(context=context, url=url, wait=wait)
+	
+	def print(
+			self,
+			context: str,
+			background: bool = False,
+			margin: Optional[Dict] = None,
+			orientation: str = "portrait",
+			page: Optional[Dict] = None,
+			page_ranges: Optional[List[Union[int, str]]] = None,
+			scale: float = 1.0,
+			shrink_to_fit: bool = True,
+	) -> str:
+		return self._print_impl(
+				context=context,
+				background=background,
+				margin=margin,
+				orientation=orientation,
+				page=page,
+				page_ranges=page_ranges,
+				scale=scale,
+				shrink_to_fit=shrink_to_fit
+		)
+	
+	def reload(
+			self,
+			context: str,
+			ignore_cache: Optional[bool] = None,
+			wait: Optional[str] = None,
+	) -> Dict:
+		return self._reload_impl(context=context, ignore_cache=ignore_cache, wait=wait)
+	
+	def remove_event_handler(self, event: str, callback_id: int) -> None:
+		self._remove_event_handler_impl(event=event, callback_id=callback_id)
+	
+	def set_viewport(
+			self,
+			context: Optional[str] = None,
+			viewport: Optional[Dict] = None,
+			device_pixel_ratio: Optional[float] = None,
+			user_contexts: Optional[List[str]] = None,
+	) -> None:
+		self._set_viewport_impl(
+				context=context,
+				viewport=viewport,
+				device_pixel_ratio=device_pixel_ratio,
+				user_contexts=user_contexts
+		)
+	
+	def traverse_history(self, context: str, delta: int) -> Dict:
+		return self._traverse_history_impl(context=context, delta=delta)

osn_selenium/instances/sync/dialog.py

@@ -0,0 +1,81 @@
+from typing import List, Optional, Self
+from selenium.webdriver.common.fedcm.account import Account
+from osn_selenium.instances._typehints import DIALOG_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.dialog import UnifiedDialog
+from osn_selenium.abstract.instances.dialog import AbstractDialog
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.fedcm.dialog import (
+	Dialog as legacyDialog
+)
+
+
+__all__ = ["Dialog"]
+
+
+class Dialog(UnifiedDialog, AbstractDialog):
+	"""
+	Wrapper for the legacy Selenium FedCM Dialog instance (Synchronous).
+
+	Handles Federated Credential Management dialogs, including account selection
+	and dismissal.
+	"""
+	
+	def __init__(self, selenium_dialog: legacyDialog) -> None:
+		"""
+		Initializes the Dialog wrapper.
+
+		Args:
+			selenium_dialog (legacyDialog): The legacy Selenium Dialog instance to wrap.
+		"""
+		
+		UnifiedDialog.__init__(self, selenium_dialog=selenium_dialog)
+	
+	def accept(self) -> None:
+		self._accept_impl()
+	
+	def dismiss(self) -> None:
+		self._dismiss_impl()
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: DIALOG_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Dialog object.
+
+		This factory method is used to wrap an existing Selenium Dialog
+		instance into the new interface.
+
+		Args:
+			selenium_dialog (DIALOG_TYPEHINT): The legacy Selenium Dialog instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Dialog.
+		"""
+		
+		legacy_dialog_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_dialog_obj, legacyDialog):
+			raise CannotConvertTypeError(from_=legacyDialog, to_=legacy_object)
+		
+		return cls(selenium_dialog=legacy_dialog_obj)
+	
+	def get_accounts(self) -> List[Account]:
+		return self._get_accounts_impl()
+	
+	@property
+	def legacy(self) -> legacyDialog:
+		return self._legacy_impl
+	
+	def select_account(self, index: int) -> None:
+		self._select_account_impl(index=index)
+	
+	def subtitle(self) -> Optional[str]:
+		return self._subtitle_impl()
+	
+	def title(self) -> str:
+		return self._title_impl()
+	
+	def type(self) -> Optional[str]:
+		return self._type_impl()

osn_selenium/instances/sync/fedcm.py

@@ -0,0 +1,92 @@
+from typing import (
+	Dict,
+	List,
+	Optional,
+	Self
+)
+from osn_selenium.instances._typehints import FEDCM_TYPEHINT
+from osn_selenium.instances.unified.fedcm import UnifiedFedCM
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.abstract.instances.fedcm import AbstractFedCM
+from selenium.webdriver.remote.fedcm import FedCM as legacyFedCM
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+
+
+__all__ = ["FedCM"]
+
+
+class FedCM(UnifiedFedCM, AbstractFedCM):
+	"""
+	Wrapper for the legacy Selenium FedCM instance.
+
+	Provides an interface for controlling the Federated Credential Management API,
+	including dialog delays and cooldown resets.
+	"""
+	
+	def __init__(self, selenium_fedcm: legacyFedCM) -> None:
+		"""
+		Initializes the FedCM wrapper.
+
+		Args:
+			selenium_fedcm (legacyFedCM): The legacy Selenium FedCM instance to wrap.
+		"""
+		
+		UnifiedFedCM.__init__(self, selenium_fedcm=selenium_fedcm)
+	
+	def accept(self) -> None:
+		self._accept_impl()
+	
+	def account_list(self) -> List[Dict]:
+		return self._account_list_impl()
+	
+	def dialog_type(self) -> str:
+		return self._dialog_type_impl()
+	
+	def disable_delay(self) -> None:
+		self._disable_delay_impl()
+	
+	def dismiss(self) -> None:
+		self._dismiss_impl()
+	
+	def enable_delay(self) -> None:
+		self._enable_delay_impl()
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: FEDCM_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium FedCM object.
+
+		This factory method is used to wrap an existing Selenium FedCM
+		instance into the new interface.
+
+		Args:
+			legacy_object (FEDCM_TYPEHINT): The legacy Selenium FedCM instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing FedCM.
+		"""
+		
+		legacy_fedcm_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_fedcm_obj, legacyFedCM):
+			raise CannotConvertTypeError(from_=legacyFedCM, to_=legacy_object)
+		
+		return cls(selenium_fedcm=legacy_fedcm_obj)
+	
+	@property
+	def legacy(self) -> legacyFedCM:
+		return self._legacy_impl
+	
+	def reset_cooldown(self) -> None:
+		self._reset_cooldown_impl()
+	
+	def select_account(self, index: int) -> None:
+		self._select_account_impl(index=index)
+	
+	def subtitle(self) -> Optional[str]:
+		return self._subtitle_impl()
+	
+	def title(self) -> str:
+		return self._title_impl()

osn_selenium/instances/sync/mobile.py

@@ -0,0 +1,75 @@
+from typing import List, Self, Union
+from osn_selenium.instances._typehints import MOBILE_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.mobile import UnifiedMobile
+from osn_selenium.abstract.instances.mobile import AbstractMobile
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.remote.mobile import (
+	Mobile as legacyMobile,
+	_ConnectionType
+)
+
+
+__all__ = ["Mobile"]
+
+
+class Mobile(UnifiedMobile, AbstractMobile):
+	"""
+	Wrapper for the legacy Selenium Mobile instance.
+
+	Manages network connection types and context settings (e.g., native app vs web view)
+	for mobile emulation.
+	"""
+	
+	def __init__(self, selenium_mobile: legacyMobile) -> None:
+		"""
+		Initializes the Mobile wrapper.
+
+		Args:
+			selenium_mobile (legacyMobile): The legacy Selenium Mobile instance to wrap.
+		"""
+		
+		UnifiedMobile.__init__(self, selenium_mobile=selenium_mobile)
+	
+	def context(self) -> str:
+		return self._get_context_impl()
+	
+	def contexts(self) -> List[str]:
+		return self._contexts_impl()
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: MOBILE_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Mobile object.
+
+		This factory method is used to wrap an existing Selenium Mobile
+		instance into the new interface.
+
+		Args:
+			legacy_object (MOBILE_TYPEHINT): The legacy Selenium Mobile instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Mobile.
+		"""
+		
+		legacy_mobile_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_mobile_obj, legacyMobile):
+			raise CannotConvertTypeError(from_=legacyMobile, to_=legacy_object)
+		
+		return cls(selenium_mobile=legacy_mobile_obj)
+	
+	@property
+	def legacy(self) -> legacyMobile:
+		return self._legacy_impl
+	
+	def network_connection(self) -> _ConnectionType:
+		return self._network_connection_impl()
+	
+	def set_context(self, new_context: str) -> None:
+		self._set_context_impl(new_context=new_context)
+	
+	def set_network_connection(self, network: Union[int, _ConnectionType]) -> _ConnectionType:
+		return self._set_network_connection_impl(network=network)

osn_selenium/instances/sync/network.py

@@ -0,0 +1,90 @@
+from typing import (
+	Callable,
+	List,
+	Optional,
+	Self
+)
+from osn_selenium.instances._typehints import NETWORK_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.network import UnifiedNetwork
+from osn_selenium.abstract.instances.network import AbstractNetwork
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.bidi.network import (
+	Network as legacyNetwork
+)
+
+
+__all__ = ["Network"]
+
+
+class Network(UnifiedNetwork, AbstractNetwork):
+	"""
+	Wrapper for the legacy Selenium BiDi Network instance.
+
+	Allows interception of network requests, adding authentication handlers,
+	and managing request callbacks.
+	"""
+	
+	def __init__(self, selenium_network: legacyNetwork) -> None:
+		"""
+		Initializes the Network wrapper.
+
+		Args:
+			selenium_network (legacyNetwork): The legacy Selenium Network instance to wrap.
+		"""
+		
+		UnifiedNetwork.__init__(self, selenium_network=selenium_network)
+	
+	def add_auth_handler(self, username: str, password: str) -> int:
+		return self._add_auth_handler_impl(username=username, password=password)
+	
+	def add_request_handler(
+			self,
+			event: str,
+			callback: Callable,
+			url_patterns: Optional[List[str]] = None,
+			contexts: Optional[List[str]] = None,
+	) -> int:
+		return self._add_request_handler_impl(
+				event=event,
+				callback=callback,
+				url_patterns=url_patterns,
+				contexts=contexts
+		)
+	
+	def clear_request_handlers(self) -> None:
+		self._clear_request_handlers_impl()
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: NETWORK_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Network object.
+
+		This factory method is used to wrap an existing Selenium Network
+		instance into the new interface.
+
+		Args:
+			legacy_object (NETWORK_TYPEHINT): The legacy Selenium Network instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Network.
+		"""
+		
+		legacy_network_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_network_obj, legacyNetwork):
+			raise CannotConvertTypeError(from_=legacyNetwork, to_=legacy_object)
+		
+		return cls(selenium_network=legacy_network_obj)
+	
+	@property
+	def legacy(self) -> legacyNetwork:
+		return self._legacy_impl
+	
+	def remove_auth_handler(self, callback_id: int) -> None:
+		self._remove_auth_handler_impl(callback_id=callback_id)
+	
+	def remove_request_handler(self, event: str, callback_id: int) -> None:
+		self._remove_request_handler_impl(event=event, callback_id=callback_id)

osn_selenium/instances/sync/permissions.py

@@ -0,0 +1,80 @@
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances._typehints import PERMISSIONS_TYPEHINT
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances.unified.permissions import UnifiedPermissions
+from osn_selenium.abstract.instances.permissions import AbstractPermissions
+from selenium.webdriver.common.bidi.permissions import (
+	PermissionDescriptor,
+	Permissions as legacyPermissions
+)
+
+
+__all__ = ["Permissions"]
+
+
+class Permissions(UnifiedPermissions, AbstractPermissions):
+	"""
+	Wrapper for the legacy Selenium Permissions instance.
+
+	Provides methods to set and modify browser permissions (e.g., camera, microphone, geolocation)
+	via the WebDriver BiDi protocol.
+	"""
+	
+	def __init__(self, selenium_permissions: legacyPermissions) -> None:
+		"""
+		Initializes the Permissions wrapper.
+
+		Args:
+			selenium_permissions (legacyPermissions): The legacy Selenium Permissions instance to wrap.
+		"""
+		
+		UnifiedPermissions.__init__(self, selenium_permissions=selenium_permissions)
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: PERMISSIONS_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Permissions object.
+
+		This factory method is used to wrap an existing Selenium Permissions
+		instance into the new interface.
+
+		Args:
+			legacy_object (PERMISSIONS_TYPEHINT): The legacy Selenium Permissions instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Permissions.
+		"""
+		
+		legacy_permissions_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_permissions_obj, legacyPermissions):
+			raise CannotConvertTypeError(from_=legacyPermissions, to_=legacy_object)
+		
+		return cls(selenium_permissions=legacy_permissions_obj)
+	
+	@property
+	def legacy(self) -> legacyPermissions:
+		return self._legacy_impl
+	
+	def set_permission(
+			self,
+			descriptor: Union[Dict[str, Any], PermissionDescriptor],
+			state: str,
+			origin: str,
+			user_context: Optional[str] = None,
+	) -> None:
+		self._set_permission_impl(
+				descriptor=descriptor,
+				state=state,
+				origin=origin,
+				user_context=user_context
+		)

osn_selenium/instances/sync/script.py

@@ -0,0 +1,77 @@
+from typing import Any, Callable, Self
+from osn_selenium.instances._typehints import SCRIPT_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.script import UnifiedScript
+from osn_selenium.abstract.instances.script import AbstractScript
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.bidi.script import (
+	Script as legacyScript
+)
+
+
+__all__ = ["Script"]
+
+
+class Script(UnifiedScript, AbstractScript):
+	"""
+	Wrapper for the legacy Selenium BiDi Script instance.
+
+	Facilitates execution of JavaScript within specific contexts, adding preload scripts,
+	and handling console messages or JS errors.
+	"""
+	
+	def __init__(self, selenium_script: legacyScript) -> None:
+		"""
+		Initializes the Script wrapper.
+
+		Args:
+			selenium_script (legacyScript): The legacy Selenium Script instance to wrap.
+		"""
+		
+		UnifiedScript.__init__(self, selenium_script=selenium_script)
+	
+	def add_console_message_handler(self, handler: Callable[[Any], None]) -> int:
+		return self._add_console_message_handler_impl(handler=handler)
+	
+	def add_javascript_error_handler(self, handler: Callable[[Any], None]) -> int:
+		return self._add_javascript_error_handler_impl(handler=handler)
+	
+	def execute(self, script: str, *args: Any) -> Any:
+		return self._execute_impl(script, *args)
+	
+	@classmethod
+	def from_legacy(cls, legacy_object: SCRIPT_TYPEHINT) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Script object.
+
+		This factory method is used to wrap an existing Selenium Script
+		instance into the new interface.
+
+		Args:
+			legacy_object (SCRIPT_TYPEHINT): The legacy Selenium Script instance or its wrapper.
+
+		Returns:
+			Self: A new instance of a class implementing Script.
+		"""
+		
+		legacy_script_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_script_obj, legacyScript):
+			raise CannotConvertTypeError(from_=legacyScript, to_=legacy_object)
+		
+		return cls(selenium_script=legacy_script_obj)
+	
+	@property
+	def legacy(self) -> legacyScript:
+		return self._legacy_impl
+	
+	def pin(self, script: str) -> str:
+		return self._pin_impl(script=script)
+	
+	def remove_console_message_handler(self, id: int) -> None:
+		self._remove_console_message_handler_impl(id=id)
+	
+	def unpin(self, script_id: str) -> None:
+		self._unpin_impl(script_id=script_id)