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

osn_selenium/executors/trio_bidi/javascript.py

@@ -0,0 +1,101 @@
+import trio
+from osn_selenium.javascript.models import JS_Scripts
+from osn_selenium.trio_bidi.mixin import TrioBiDiMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional,
+	Union
+)
+from osn_selenium.javascript.fingerprint import FingerprintSettings
+from osn_selenium.instances.trio_threads.web_element import WebElement
+from osn_selenium.executors.unified.javascript import UnifiedJSExecutor
+from osn_selenium.models import (
+	Point,
+	Position,
+	Rectangle,
+	Size
+)
+from osn_selenium.abstract.executors.javascript import AbstractJSExecutor
+
+
+__all__ = ["JSExecutor"]
+
+
+class JSExecutor(UnifiedJSExecutor, TrioBiDiMixin, AbstractJSExecutor):
+	"""
+	An asynchronous JavaScript executor that integrates Trio's BiDi mixin.
+	"""
+	
+	def __init__(
+			self,
+			execute_function: Callable[[str, Any], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken],
+			bidi_buffer_size: Union[int, float],
+	):
+		"""
+		Initialize the JSExecutor with Trio synchronization primitives and execution logic.
+
+		Args:
+			execute_function (Callable[[str, Any], Any]): The function used to run JavaScript code.
+			lock (trio.Lock): Trio lock for synchronizing access.
+			limiter (trio.CapacityLimiter): Trio limiter for controlling concurrency.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+		"""
+		
+		UnifiedJSExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioBiDiMixin.__init__(
+				self,
+				lock=lock,
+				limiter=limiter,
+				token=trio_token,
+				buffer_size=bidi_buffer_size
+		)
+	
+	async def check_element_in_viewport(self, element: WebElement) -> bool:
+		return await self.sync_to_trio(sync_function=self._check_element_in_viewport_impl)(element=element)
+	
+	async def execute(self, script: str, *args: Any) -> Any:
+		return await self.sync_to_trio(sync_function=self._execute_impl)(script, *args)
+	
+	async def get_document_scroll_size(self) -> Size:
+		return await self.sync_to_trio(sync_function=self._get_document_scroll_size_impl)()
+	
+	async def get_element_css_style(self, element: WebElement) -> Dict[str, str]:
+		return await self.sync_to_trio(sync_function=self._get_element_css_style_impl)(element=element)
+	
+	async def get_element_rect_in_viewport(self, element: WebElement) -> Optional[Rectangle]:
+		return await self.sync_to_trio(sync_function=self._get_element_rect_in_viewport_impl)(element=element)
+	
+	async def get_random_element_point(self, element: WebElement) -> Optional[Point]:
+		return await self.sync_to_trio(sync_function=self._get_random_element_point_impl)(element=element)
+	
+	async def get_random_element_point_in_viewport(self, element: WebElement, step: int = 1) -> Optional[Position]:
+		return await self.sync_to_trio(sync_function=self._get_random_element_point_in_viewport_impl)(element=element, step=step)
+	
+	async def get_viewport_position(self) -> Position:
+		return await self.sync_to_trio(sync_function=self._get_viewport_position_impl)()
+	
+	async def get_viewport_rect(self) -> Rectangle:
+		return await self.sync_to_trio(sync_function=self._get_viewport_rect_impl)()
+	
+	async def get_viewport_size(self) -> Size:
+		return await self.sync_to_trio(sync_function=self._get_viewport_size_impl)()
+	
+	async def open_new_tab(self, link: str = "") -> None:
+		await self.sync_to_trio(sync_function=self._open_new_tab_impl)(link=link)
+	
+	@property
+	def scripts(self) -> JS_Scripts:
+		return self._scripts_impl
+	
+	async def start_fingerprint_detection(self, fingerprint_settings: FingerprintSettings) -> None:
+		await self.sync_to_trio(sync_function=self._start_fingerprint_detection_impl)(fingerprint_settings=fingerprint_settings)
+	
+	async def stop_window_loading(self) -> None:
+		await self.sync_to_trio(sync_function=self._stop_window_loading_impl)()

osn_selenium/executors/trio_threads/cdp.py

@@ -27,11 +27,6 @@ class CDPExecutor(AbstractCDPExecutor):
 		self._execute_function = execute_function
 		self._lock = lock
 		self._limiter = limiter
-		self._v140 = None
-		self._v141 = None
-		self._v142 = None
-		self._v143 = None
-		self._v144 = None
 
 	def get(self, version: int) -> Any:
 		"""

osn_selenium/flags/base.py

@@ -151,7 +151,7 @@ class BrowserFlagsManager:
 	def clear_attributes(self):
 		"""Clears all configured browser attributes."""
 		
-		self._attributes = {}
+		self._attributes.clear()
 	
 	def remove_attribute(self, attribute_name: str):
 		"""
@@ -236,7 +236,7 @@ class BrowserFlagsManager:
 	def clear_experimental_options(self):
 		"""Clears all configured experimental options."""
 		
-		self._experimental_options = {}
+		self._experimental_options.clear()
 	
 	def remove_experimental_option(self, experimental_option_name: str):
 		"""
@@ -338,7 +338,7 @@ class BrowserFlagsManager:
 	def clear_arguments(self):
 		"""Clears all configured browser arguments."""
 		
-		self._arguments = {}
+		self._arguments.clear()
 	
 	def remove_argument(self, argument_name: str):
 		"""
@@ -463,7 +463,9 @@ class BrowserFlagsManager:
 		
 		for type_name, type_functions in self._flags_types.items():
 			options = type_functions.build_options_function(options)
-		
+
+		options.set_capability("webSocketUrl", True)
+
 		return options
 	
 	def remove_option(self, option: FlagDefinition):

osn_selenium/flags/blink.py

@@ -770,8 +770,8 @@ class BlinkFlagsManager(BrowserFlagsManager):
 	def clear_blink_features(self):
 		"""Clears all configured Blink features."""
 		
-		self._enable_blink_features = {}
-		self._disable_blink_features = {}
+		self._enable_blink_features.clear()
+		self._disable_blink_features.clear()
 	
 	def remove_blink_feature(self, blink_feature_name: str):
 		"""

osn_selenium/flags/chrome.py

@@ -42,21 +42,21 @@ class ChromeFlagsManager(BlinkFlagsManager):
 		debugging port, user agent, proxy, and BiDi protocol.
 		"""
 		
-		yandex_flags_types = {}
+		chrome_flags_types = {}
 		
 		if flags_types is not None:
-			yandex_flags_types.update(flags_types)
+			chrome_flags_types.update(flags_types)
 		
-		yandex_flags_definitions = {}
+		chrome_flags_definitions = {}
 		
 		if flags_definitions is not None:
-			yandex_flags_definitions.update(flags_definitions)
+			chrome_flags_definitions.update(flags_definitions)
 		
 		super().__init__(
 				browser_exe=browser_exe,
 				start_page_url=start_page_url,
-				flags_types=yandex_flags_types,
-				flags_definitions=yandex_flags_definitions,
+				flags_types=chrome_flags_types,
+				flags_definitions=chrome_flags_definitions,
 		)
 	
 	def _build_options_arguments(self, options: Options) -> Options:

osn_selenium/flags/edge.py

@@ -42,21 +42,21 @@ class EdgeFlagsManager(BlinkFlagsManager):
 		debugging port, user agent, proxy, and BiDi protocol.
 		"""
 		
-		yandex_flags_types = {}
+		edge_flags_types = {}
 		
 		if flags_types is not None:
-			yandex_flags_types.update(flags_types)
+			edge_flags_types.update(flags_types)
 		
-		yandex_flags_definitions = {}
+		edge_flags_definitions = {}
 		
 		if flags_definitions is not None:
-			yandex_flags_definitions.update(flags_definitions)
+			edge_flags_definitions.update(flags_definitions)
 		
 		super().__init__(
 				browser_exe=browser_exe,
 				start_page_url=start_page_url,
-				flags_types=yandex_flags_types,
-				flags_definitions=yandex_flags_definitions,
+				flags_types=edge_flags_types,
+				flags_definitions=edge_flags_definitions,
 		)
 	
 	def _build_options_arguments(self, options: Options) -> Options:

osn_selenium/instances/convert.py

@@ -52,13 +52,14 @@ from selenium.webdriver.common.bidi.permissions import (
 from selenium.webdriver.common.bidi.webextension import (
 	WebExtension as legacyWebExtension
 )
+from selenium.webdriver.common.bidi.browsing_context import (
+	BrowsingContext as legacyBrowsingContext
+)
 from osn_selenium.instances.protocols import (
 	SyncInstanceWrapper,
+	TrioBiDiInstanceWrapper,
 	TrioThreadInstanceWrapper
 )
-from selenium.webdriver.common.bidi.browsing_context import (
-	BrowsingContext as legacyBrowsingContext
-)
 from osn_selenium.instances._typehints import (
 	ACTION_CHAINS_TYPEHINT,
 	ALERT_TYPEHINT,
@@ -85,11 +86,13 @@ __all__ = [
 	"get_legacy_frame_reference",
 	"get_legacy_instance",
 	"get_sync_instance_wrapper",
+	"get_trio_bidi_instance_wrapper",
 	"get_trio_thread_instance_wrapper"
 ]
 
 _SYNC_WRAPPER_TYPE = TypeVar("_SYNC_WRAPPER_TYPE", bound=SyncInstanceWrapper)
 _TRIO_THREAD_WRAPPER_TYPE = TypeVar("_TRIO_THREAD_WRAPPER_TYPE", bound=TrioThreadInstanceWrapper)
+_TRIO_BIDI_WRAPPER_TYPE = TypeVar("_TRIO_BIDI_WRAPPER_TYPE", bound=TrioBiDiInstanceWrapper)
 
 
 @overload
@@ -243,6 +246,44 @@ def get_trio_thread_instance_wrapper(
 	return wrapper_class.from_legacy(legacy_object=legacy_object, lock=lock, limiter=limiter)
 
 
+def get_trio_bidi_instance_wrapper(
+		wrapper_class: Type[_TRIO_BIDI_WRAPPER_TYPE],
+		legacy_object: Any,
+		lock: trio.Lock,
+		limiter: trio.CapacityLimiter,
+		trio_token: Optional[trio.lowlevel.TrioToken],
+		bidi_buffer_size: Union[int, float],
+) -> _TRIO_BIDI_WRAPPER_TYPE:
+	"""
+	Creates a Trio-compatible BiDi instance wrapper for a legacy Selenium object.
+
+	Args:
+		wrapper_class (Type[_TRIO_BIDI_WRAPPER_TYPE]): The class used to wrap the legacy object.
+		legacy_object (Any): The legacy Selenium object to be wrapped.
+		lock (trio.Lock): The lock for Trio synchronization.
+		limiter (trio.CapacityLimiter): The capacity limiter for Trio.
+		trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+		bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+
+	Returns:
+		_TRIO_BIDI_WRAPPER_TYPE: An instance of the wrapper class.
+
+	Raises:
+		TypeIsNotWrapper: If the provided wrapper_class does not implement TrioBiDiInstanceWrapper.
+	"""
+	
+	if not isinstance(wrapper_class, TrioBiDiInstanceWrapper):
+		raise ProtocolComplianceError(instance=wrapper_class, expected_protocols=TrioBiDiInstanceWrapper)
+	
+	return wrapper_class.from_legacy(
+			legacy_object=legacy_object,
+			lock=lock,
+			limiter=limiter,
+			trio_token=trio_token,
+			bidi_buffer_size=bidi_buffer_size
+	)
+
+
 def get_sync_instance_wrapper(wrapper_class: Type[_SYNC_WRAPPER_TYPE], legacy_object: Any) -> _SYNC_WRAPPER_TYPE:
 	"""
 	Creates a synchronous instance wrapper for a legacy Selenium object.

osn_selenium/instances/protocols.py

@@ -1,8 +1,10 @@
 import trio
 from typing import (
+	Optional,
 	Protocol,
 	Self,
 	TypeVar,
+	Union,
 	runtime_checkable
 )
 
@@ -10,6 +12,7 @@ from typing import (
 __all__ = [
 	"AnyInstanceWrapper",
 	"SyncInstanceWrapper",
+	"TrioBiDiInstanceWrapper",
 	"TrioThreadInstanceWrapper"
 ]
 
@@ -27,7 +30,7 @@ class TrioThreadInstanceWrapper(Protocol):
 			cls,
 			legacy_object: _LEGACY_OBJECT,
 			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
+			limiter: trio.CapacityLimiter,
 	) -> Self:
 		"""
 		Creates an instance of the wrapper from a legacy object.
@@ -55,6 +58,49 @@ class TrioThreadInstanceWrapper(Protocol):
 		...
 
 
+@runtime_checkable
+class TrioBiDiInstanceWrapper(Protocol):
+	"""
+	Protocol for instances that wrap legacy objects and operate within Trio threads.
+	"""
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: _LEGACY_OBJECT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken],
+			bidi_buffer_size: Union[int, float],
+	) -> Self:
+		"""
+		Creates an instance of the wrapper from a legacy object.
+
+		Args:
+			legacy_object (_LEGACY_OBJECT): The legacy Selenium object to wrap.
+			lock (trio.Lock): Trio lock for synchronization.
+			limiter (trio.CapacityLimiter): Trio capacity limiter.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+
+		Returns:
+			Self: An instance of the wrapper.
+		"""
+		
+		...
+	
+	@property
+	def legacy(self) -> _LEGACY_OBJECT:
+		"""
+		Returns the underlying legacy Selenium object.
+
+		Returns:
+			_LEGACY_OBJECT: The legacy Selenium instance.
+		"""
+		
+		...
+
+
 @runtime_checkable
 class SyncInstanceWrapper(Protocol):
 	"""

osn_selenium/instances/sync/browsing_context.py

@@ -47,8 +47,8 @@ class BrowsingContext(UnifiedBrowsingContext, AbstractBrowsingContext):
 		
 		UnifiedBrowsingContext.__init__(self, selenium_browsing_context=selenium_browsing_context)
 	
-	def activate(self, context: str) -> Any:
-		return self._activate_impl(context=context)
+	def activate(self, context: str) -> None:
+		self._activate_impl(context=context)
 	
 	def add_event_handler(
 			self,

osn_selenium/instances/sync/script.py

@@ -1,4 +1,9 @@
-from typing import Any, Callable, Self
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	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
@@ -38,7 +43,7 @@ class Script(UnifiedScript, AbstractScript):
 	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:
+	def execute(self, script: str, *args: Any) -> Dict[str, Any]:
 		return self._execute_impl(script, *args)
 	
 	@classmethod

osn_selenium/instances/sync/web_element.py

@@ -126,7 +126,7 @@ class WebElement(UnifiedWebElement, AbstractWebElement):
 		
 		return self.from_legacy(legacy_object=web_element)
 	
-	def rect(self) -> Dict:
+	def rect(self) -> Dict[str, int]:
 		return self._rect_impl()
 	
 	def screenshot(self, filename: str) -> bool:

osn_selenium/instances/trio_bidi/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/instances/trio_bidi/shadow_root.py

@@ -0,0 +1,180 @@
+import math
+import trio
+from selenium.webdriver.common.by import By
+from osn_selenium.trio_bidi.mixin import TrioBiDiMixin
+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 typing import (
+	List,
+	Optional,
+	Self,
+	TYPE_CHECKING,
+	Type,
+	Union
+)
+from selenium.webdriver.remote.shadowroot import (
+	ShadowRoot as legacyShadowRoot
+)
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+from osn_selenium.instances.convert import (
+	get_legacy_instance,
+	get_trio_bidi_instance_wrapper
+)
+
+
+__all__ = ["ShadowRoot"]
+
+if TYPE_CHECKING:
+	from osn_selenium.instances.trio_bidi.web_element import WebElement
+
+_WEB_ELEMENT_TYPE: Optional[Type["WebElement"]] = None
+
+
+def _build_web_element(
+		legacy_element: legacyWebElement,
+		lock: trio.Lock,
+		limiter: trio.CapacityLimiter,
+		trio_token: Optional[trio.lowlevel.TrioToken] = None,
+		bidi_buffer_size: Union[int, float] = math.inf,
+):
+	"""
+	Builds a wrapped WebElement from a legacy element.
+
+	Args:
+		legacy_element (legacyWebElement): The legacy Selenium WebElement instance.
+		lock (trio.Lock): A Trio lock for managing concurrent access.
+		limiter (trio.CapacityLimiter): A Trio capacity limiter for rate limiting.
+
+	Returns:
+		WebElement: The wrapped WebElement instance.
+	"""
+	
+	global _WEB_ELEMENT_TYPE
+	
+	if _WEB_ELEMENT_TYPE is None:
+		from osn_selenium.instances.trio_bidi.web_element import WebElement
+		_WEB_ELEMENT_TYPE = WebElement
+	
+	return get_trio_bidi_instance_wrapper(
+			wrapper_class=_WEB_ELEMENT_TYPE,
+			legacy_object=legacy_element,
+			lock=lock,
+			limiter=limiter,
+			trio_token=trio_token,
+			bidi_buffer_size=bidi_buffer_size,
+	)
+
+
+class ShadowRoot(UnifiedShadowRoot, TrioBiDiMixin, 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,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> 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.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+		"""
+		
+		UnifiedShadowRoot.__init__(self, selenium_shadow_root=selenium_shadow_root)
+		
+		TrioBiDiMixin.__init__(
+				self,
+				lock=lock,
+				limiter=limiter,
+				token=trio_token,
+				buffer_size=bidi_buffer_size
+		)
+	
+	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)
+		
+		return _build_web_element(
+				legacy_element=legacy_element,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+				trio_token=self._trio_token,
+				bidi_buffer_size=self._trio_bidi_buffer_size,
+		)
+	
+	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)
+		
+		return [
+			_build_web_element(
+					legacy_element=legacy_element,
+					lock=self._lock,
+					limiter=self._capacity_limiter,
+					trio_token=self._trio_token,
+					bidi_buffer_size=self._trio_bidi_buffer_size,
+			)
+			for legacy_element in legacy_elements
+		]
+	
+	@classmethod
+	def from_legacy(
+			cls,
+			legacy_object: SHADOW_ROOT_TYPEHINT,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			trio_token: Optional[trio.lowlevel.TrioToken] = None,
+			bidi_buffer_size: Union[int, float] = math.inf,
+	) -> 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.
+			trio_token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			bidi_buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+
+		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,
+				trio_token=trio_token,
+				bidi_buffer_size=bidi_buffer_size,
+		)
+	
+	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