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

osn_selenium/instances/trio_threads/network.py

@@ -0,0 +1,108 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+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, TrioThreadMixin, 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,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the Network wrapper.
+
+		Args:
+			selenium_network (legacyNetwork): The legacy Selenium Network instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedNetwork.__init__(self, selenium_network=selenium_network)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def add_auth_handler(self, username: str, password: str) -> int:
+		return await self.sync_to_trio(sync_function=self._add_auth_handler_impl)(username=username, password=password)
+	
+	async def add_request_handler(
+			self,
+			event: str,
+			callback: Callable,
+			url_patterns: Optional[List[str]] = None,
+			contexts: Optional[List[str]] = None,
+	) -> int:
+		return await self.sync_to_trio(sync_function=self._add_request_handler_impl)(
+				event=event,
+				callback=callback,
+				url_patterns=url_patterns,
+				contexts=contexts
+		)
+	
+	async def clear_request_handlers(self) -> None:
+		await self.sync_to_trio(sync_function=self._clear_request_handlers_impl)()
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: NETWORK_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> 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.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		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, lock=lock, limiter=limiter)
+	
+	@property
+	def legacy(self) -> legacyNetwork:
+		return self._legacy_impl
+	
+	async def remove_auth_handler(self, callback_id: int) -> None:
+		await self.sync_to_trio(sync_function=self._remove_auth_handler_impl)(callback_id=callback_id)
+	
+	async def remove_request_handler(self, event: str, callback_id: int) -> None:
+		await self.sync_to_trio(sync_function=self._remove_request_handler_impl)(event=event, callback_id=callback_id)

osn_selenium/instances/trio_threads/permissions.py

@@ -0,0 +1,102 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+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, TrioThreadMixin, 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,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the Permissions wrapper.
+
+		Args:
+			selenium_permissions (legacyPermissions): The legacy Selenium Permissions instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedPermissions.__init__(self, selenium_permissions=selenium_permissions)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: PERMISSIONS_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> 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.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		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,
+				lock=lock,
+				limiter=limiter
+		)
+	
+	@property
+	def legacy(self) -> legacyPermissions:
+		return self._legacy_impl
+	
+	async def set_permission(
+			self,
+			descriptor: Union[Dict[str, Any], PermissionDescriptor],
+			state: str,
+			origin: str,
+			user_context: Optional[str] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._set_permission_impl)(
+				descriptor=descriptor,
+				state=state,
+				origin=origin,
+				user_context=user_context
+		)

osn_selenium/instances/trio_threads/script.py

@@ -0,0 +1,95 @@
+import trio
+from typing import Any, Callable, Self
+from osn_selenium.base_mixin import TrioThreadMixin
+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, TrioThreadMixin, 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,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the Script wrapper.
+
+		Args:
+			selenium_script (legacyScript): The legacy Selenium Script instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedScript.__init__(self, selenium_script=selenium_script)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def add_console_message_handler(self, handler: Callable[[Any], None]) -> int:
+		return await self.sync_to_trio(sync_function=self._add_console_message_handler_impl)(handler=handler)
+	
+	async def add_javascript_error_handler(self, handler: Callable[[Any], None]) -> int:
+		return await self.sync_to_trio(sync_function=self._add_javascript_error_handler_impl)(handler=handler)
+	
+	async def execute(self, script: str, *args: Any) -> Any:
+		return await self.sync_to_trio(sync_function=self._execute_impl)(script, *args)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: SCRIPT_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> 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.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		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, lock=lock, limiter=limiter)
+	
+	@property
+	def legacy(self) -> legacyScript:
+		return self._legacy_impl
+	
+	async def pin(self, script: str) -> str:
+		return await self.sync_to_trio(sync_function=self._pin_impl)(script=script)
+	
+	async def remove_console_message_handler(self, id: int) -> None:
+		await self.sync_to_trio(sync_function=self._remove_console_message_handler_impl)(id=id)
+	
+	async def unpin(self, script_id: str) -> None:
+		await self.sync_to_trio(sync_function=self._unpin_impl)(script_id=script_id)

osn_selenium/instances/trio_threads/shadow_root.py

@@ -0,0 +1,123 @@
+import trio
+from selenium.webdriver.common.by import By
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	List,
+	Optional,
+	Self,
+	TYPE_CHECKING
+)
+from osn_selenium.instances._typehints import SHADOW_ROOT_TYPEHINT
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from osn_selenium.instances.unified.shadow_root import UnifiedShadowRoot
+from osn_selenium.abstract.instances.shadow_root import AbstractShadowRoot
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_trio_thread_instance_wrapper
+)
+
+
+__all__ = ["ShadowRoot"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_threads.web_element import WebElement
+
+
+class ShadowRoot(UnifiedShadowRoot, TrioThreadMixin, AbstractShadowRoot):
+	"""
+	Wrapper for the legacy Selenium ShadowRoot instance.
+
+	Represents the root of a Shadow DOM tree, allowing element search
+	within the encapsulated shadow scope.
+	"""
+	
+	def __init__(
+			self,
+			selenium_shadow_root: legacyShadowRoot,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the ShadowRoot wrapper.
+
+		Args:
+			selenium_shadow_root (legacyShadowRoot): The legacy Selenium ShadowRoot instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedShadowRoot.__init__(self, selenium_shadow_root=selenium_shadow_root)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def find_element(self, by: str = By.ID, value: Optional[str] = None) -> "WebElement":
+		legacy_element = await self.sync_to_trio(sync_function=self._find_element_impl)(by=by, value=value)
+		
+		from osn_selenium.instances.trio_threads.web_element import WebElement
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebElement,
+				legacy_object=legacy_element,
+				lock=self._lock,
+				limiter=self._capacity_limiter
+		)
+	
+	async def find_elements(self, by: str = By.ID, value: Optional[str] = None) -> List["WebElement"]:
+		legacy_elements = await self.sync_to_trio(sync_function=self._find_elements_impl)(by=by, value=value)
+		
+		from osn_selenium.instances.trio_threads.web_element import WebElement
+		
+		return [
+			get_trio_thread_instance_wrapper(
+					wrapper_class=WebElement,
+					legacy_object=legacy_element,
+					lock=self._lock,
+					limiter=self._capacity_limiter
+			)
+			for legacy_element in legacy_elements
+		]
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: SHADOW_ROOT_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium ShadowRoot object.
+
+		This factory method is used to wrap an existing Selenium ShadowRoot
+		instance into the new interface.
+
+		Args:
+			legacy_object (SHADOW_ROOT_TYPEHINT): The legacy Selenium ShadowRoot instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing ShadowRoot.
+		"""
+		
+		legacy_shadow_root_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_shadow_root_obj, legacyShadowRoot):
+			raise CannotConvertTypeError(from_=legacyShadowRoot, to_=legacy_object)
+		
+		return cls(
+				selenium_shadow_root=legacy_shadow_root_obj,
+				lock=lock,
+				limiter=limiter
+		)
+	
+	async def id(self) -> str:
+		return await self.sync_to_trio(sync_function=self._id_impl)()
+	
+	@property
+	def legacy(self) -> legacyShadowRoot:
+		return self._legacy_impl

osn_selenium/instances/trio_threads/storage.py

@@ -0,0 +1,109 @@
+import trio
+from typing import (
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.instances._typehints import STORAGE_TYPEHINT
+from osn_selenium.instances.convert import get_legacy_instance
+from osn_selenium.instances.unified.storage import UnifiedStorage
+from osn_selenium.abstract.instances.storage import AbstractStorage
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.common.bidi.storage import (
+	BrowsingContextPartitionDescriptor,
+	CookieFilter,
+	DeleteCookiesResult,
+	GetCookiesResult,
+	PartialCookie,
+	SetCookieResult,
+	Storage as legacyStorage,
+	StorageKeyPartitionDescriptor
+)
+
+
+__all__ = ["Storage"]
+
+
+class Storage(UnifiedStorage, TrioThreadMixin, AbstractStorage):
+	"""
+	Wrapper for the legacy Selenium BiDi Storage instance.
+
+	Manages browser storage mechanisms, primarily focusing on getting, setting,
+	and deleting cookies with specific filters and partition descriptors.
+	"""
+	
+	def __init__(
+			self,
+			selenium_storage: legacyStorage,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the Storage wrapper.
+
+		Args:
+			selenium_storage (legacyStorage): The legacy Selenium Storage instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedStorage.__init__(self, selenium_storage=selenium_storage)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def delete_cookies(
+			self,
+			filter: Optional[CookieFilter] = None,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> DeleteCookiesResult:
+		return await self.sync_to_trio(sync_function=self._delete_cookies_impl)(filter=filter, partition=partition)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: STORAGE_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium Storage object.
+
+		This factory method is used to wrap an existing Selenium Storage
+		instance into the new interface.
+
+		Args:
+			legacy_object (STORAGE_TYPEHINT): The legacy Selenium Storage instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing Storage.
+		"""
+		
+		legacy_storage_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_storage_obj, legacyStorage):
+			raise CannotConvertTypeError(from_=legacyStorage, to_=legacy_object)
+		
+		return cls(selenium_storage=legacy_storage_obj, lock=lock, limiter=limiter)
+	
+	async def get_cookies(
+			self,
+			filter: Optional[CookieFilter] = None,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> GetCookiesResult:
+		return await self.sync_to_trio(sync_function=self._get_cookies_impl)(filter=filter, partition=partition)
+	
+	@property
+	def legacy(self) -> legacyStorage:
+		return self._legacy_impl
+	
+	async def set_cookie(
+			self,
+			cookie: PartialCookie,
+			partition: Optional[Union[BrowsingContextPartitionDescriptor, StorageKeyPartitionDescriptor]] = None,
+	) -> SetCookieResult:
+		return await self.sync_to_trio(sync_function=self._set_cookie_impl)(cookie=cookie, partition=partition)

osn_selenium/instances/trio_threads/switch_to.py

@@ -0,0 +1,124 @@
+import trio
+from typing import (
+	Optional,
+	Self,
+	Union
+)
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.instances.trio_threads.alert import Alert
+from osn_selenium.instances.unified.switch_to import UnifiedSwitchTo
+from osn_selenium.abstract.instances.switch_to import AbstractSwitchTo
+from osn_selenium.instances.trio_threads.web_element import WebElement
+from osn_selenium.exceptions.instance import (
+	CannotConvertTypeError
+)
+from selenium.webdriver.remote.switch_to import (
+	SwitchTo as legacySwitchTo
+)
+from osn_selenium.instances._typehints import (
+	SWITCH_TO_TYPEHINT,
+	WEB_ELEMENT_TYPEHINT
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_trio_thread_instance_wrapper
+)
+
+
+__all__ = ["SwitchTo"]
+
+
+class SwitchTo(UnifiedSwitchTo, TrioThreadMixin, AbstractSwitchTo):
+	"""
+	Wrapper for the legacy Selenium SwitchTo instance.
+
+	Provides mechanisms to change the driver's focus to different frames,
+	windows, or alerts.
+	"""
+	
+	def __init__(
+			self,
+			selenium_switch_to: legacySwitchTo,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> None:
+		"""
+		Initializes the SwitchTo wrapper.
+
+		Args:
+			selenium_switch_to (legacySwitchTo): The legacy Selenium SwitchTo instance to wrap.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+		"""
+		
+		UnifiedSwitchTo.__init__(self, selenium_switch_to=selenium_switch_to)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def active_element(self) -> WebElement:
+		legacy_element = await self.sync_to_trio(sync_function=self._active_element_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebElement,
+				legacy_object=legacy_element,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def alert(self) -> Alert:
+		legacy_alert_instance = await self.sync_to_trio(sync_function=self._alert_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Alert,
+				legacy_object=legacy_alert_instance,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def default_content(self) -> None:
+		await self.sync_to_trio(sync_function=self._default_content_impl)()
+	
+	async def frame(self, frame_reference: Union[str, int, WEB_ELEMENT_TYPEHINT]) -> None:
+		await self.sync_to_trio(sync_function=self._frame_impl)(frame_reference=frame_reference)
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: SWITCH_TO_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+	) -> Self:
+		"""
+		Creates an instance from a legacy Selenium SwitchTo object.
+
+		This factory method is used to wrap an existing Selenium SwitchTo
+		instance into the new interface.
+
+		Args:
+			legacy_object (SWITCH_TO_TYPEHINT): The legacy Selenium SwitchTo instance or its wrapper.
+			lock (trio.Lock): A Trio lock for managing concurrent access.
+			limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+		Returns:
+			Self: A new instance of a class implementing SwitchTo.
+		"""
+		
+		legacy_switch_to_obj = get_legacy_instance(instance=legacy_object)
+		
+		if not isinstance(legacy_switch_to_obj, legacySwitchTo):
+			raise CannotConvertTypeError(from_=legacySwitchTo, to_=legacy_object)
+		
+		return cls(selenium_switch_to=legacy_switch_to_obj, lock=lock, limiter=limiter)
+	
+	@property
+	def legacy(self) -> legacySwitchTo:
+		return self._legacy_impl
+	
+	async def new_window(self, type_hint: Optional[str] = None) -> None:
+		await self.sync_to_trio(sync_function=self._new_window_impl)(type_hint=type_hint)
+	
+	async def parent_frame(self) -> None:
+		await self.sync_to_trio(sync_function=self._parent_frame_impl)()
+	
+	async def window(self, window_name: str) -> None:
+		await self.sync_to_trio(sync_function=self._window_impl)(window_name=window_name)