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

osn_selenium/trio_bidi/mapping/response_functions/_window.py

@@ -0,0 +1,119 @@
+from typing import Any, Dict
+from selenium.webdriver.remote.command import Command
+from osn_selenium.trio_bidi.mapping.response_functions._args_helpers import map_void_response
+from osn_selenium.trio_bidi._typehints import (
+	MAP_RESPONSE_FUNCTION_TYPEHINT,
+	REQUEST_PARAMS_TYPEHINT
+)
+from osn_selenium.trio_bidi.mapping.response_functions._args_validators import (
+	validate_javascript_error
+)
+
+
+__all__ = ["MAPPED_RESPONSE_WINDOW_COMMANDS"]
+
+
+def _map_w3c_get_window_handles_response(bidi_result: Dict[str, Any], request_params: REQUEST_PARAMS_TYPEHINT) -> Dict[str, Any]:
+	"""
+	Maps BiDi context tree into a list of W3C window handles.
+
+	Args:
+		bidi_result (Dict[str, Any]): BiDi result containing 'contexts'.
+		request_params (REQUEST_PARAMS_TYPEHINT): Original request parameters.
+
+	Returns:
+		Dict[str, Any]: W3C response with a list of handles.
+	"""
+	
+	contexts = bidi_result.get("contexts", [])
+	handles = [ctx["context"] for ctx in contexts]
+	
+	return {"value": handles}
+
+
+def _map_w3c_get_current_window_handle_response(bidi_result: Dict[str, Any], request_params: REQUEST_PARAMS_TYPEHINT) -> Dict[str, Any]:
+	"""
+	Maps specific BiDi context ID to W3C window handle response.
+
+	Args:
+		bidi_result (Dict[str, Any]): BiDi result containing single context info.
+		request_params (REQUEST_PARAMS_TYPEHINT): Original request parameters.
+
+	Returns:
+		Dict[str, Any]: W3C response with the handle string.
+	"""
+	
+	return {"value": bidi_result["contexts"][0]["context"]}
+
+
+def _map_set_screen_orientation_response(bidi_result: Dict[str, Any], request_params: REQUEST_PARAMS_TYPEHINT) -> Dict[str, Any]:
+	"""
+	Maps screen orientation script execution result to void response.
+
+	Args:
+		bidi_result (Dict[str, Any]): BiDi response.
+		request_params (REQUEST_PARAMS_TYPEHINT): Original request parameters.
+
+	Returns:
+		Dict[str, Any]: W3C void response.
+	"""
+	
+	javascript_error_validation = validate_javascript_error(bidi_result=bidi_result, request_params=request_params)
+	if javascript_error_validation is not None:
+		return javascript_error_validation
+	
+	return map_void_response(bidi_result=bidi_result, request_params=request_params)
+
+
+def _map_get_screen_orientation_response(bidi_result: Dict[str, Any], request_params: REQUEST_PARAMS_TYPEHINT) -> Dict[str, Any]:
+	"""
+	Maps BiDi screen orientation script result into W3C orientation dictionary.
+
+	Args:
+		bidi_result (Dict[str, Any]): BiDi result containing raw orientation string.
+		request_params (REQUEST_PARAMS_TYPEHINT): Original request parameters.
+
+	Returns:
+		Dict[str, Any]: W3C response with orientation info.
+	"""
+	
+	javascript_error_validation = validate_javascript_error(bidi_result=bidi_result, request_params=request_params)
+	if javascript_error_validation is not None:
+		return javascript_error_validation
+	
+	raw_value = bidi_result.get("result", {}).get("value", "").upper()
+	
+	if "LANDSCAPE" in raw_value:
+		orientation = "LANDSCAPE"
+	elif "PORTRAIT" in raw_value:
+		orientation = "PORTRAIT"
+	else:
+		orientation = "LANDSCAPE"
+	
+	return {"value": {"orientation": orientation}}
+
+
+def _map_close_response(bidi_result: Dict[str, Any], request_params: REQUEST_PARAMS_TYPEHINT) -> Dict[str, Any]:
+	"""
+	Maps window closing result to W3C void response.
+
+	Args:
+		bidi_result (Dict[str, Any]): BiDi response.
+		request_params (REQUEST_PARAMS_TYPEHINT): Original request parameters.
+
+	Returns:
+		Dict[str, Any]: W3C void response.
+	"""
+	
+	return map_void_response(bidi_result=bidi_result, request_params=request_params)
+
+
+MAPPED_RESPONSE_WINDOW_COMMANDS: Dict[str, MAP_RESPONSE_FUNCTION_TYPEHINT] = {
+	Command.W3C_GET_WINDOW_HANDLES: _map_w3c_get_window_handles_response,
+	Command.W3C_GET_CURRENT_WINDOW_HANDLE: _map_w3c_get_current_window_handle_response,
+	Command.CLOSE: _map_close_response,
+	Command.GET_SCREEN_ORIENTATION: _map_get_screen_orientation_response,
+	Command.SET_SCREEN_ORIENTATION: _map_set_screen_orientation_response,
+}
+
+# TODO create mappings for Command.GET_WINDOW_RECT, Command.SET_WINDOW_RECT, Command.W3C_MAXIMIZE_WINDOW, Command.MINIMIZE_WINDOW, Command.FULLSCREEN_WINDOW

osn_selenium/trio_bidi/mixin.py

@@ -0,0 +1,186 @@
+import trio
+from contextlib import asynccontextmanager
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.trio_bidi.connection_pool import BiDiConnectionPool
+from osn_selenium.trio_bidi._context_vars import (
+	CURRENT_BROWSING_CONTEXT
+)
+from osn_selenium.trio_bidi.remote_connection import (
+	BiDiBridgeRemoteConnection
+)
+from osn_selenium.trio_bidi._typehints import (
+	CURRENT_BROWSING_CONTEXT_TYPEHINT
+)
+from osn_selenium._trio_threads_helpers import (
+	sync_to_trio,
+	sync_to_trio_context
+)
+from typing import (
+	Any,
+	AsyncContextManager,
+	AsyncGenerator,
+	Callable,
+	ContextManager,
+	Coroutine,
+	Optional,
+	ParamSpec,
+	TypeVar,
+	Union
+)
+
+
+__all__ = ["TrioBiDiMixin"]
+
+_METHOD_INPUT = ParamSpec("_METHOD_INPUT")
+_METHOD_OUTPUT = TypeVar("_METHOD_OUTPUT")
+
+
+class TrioBiDiMixin(TrioThreadMixin):
+	"""
+	Mixin that provides WebDriver with Trio-based BiDi context switching capabilities.
+	"""
+	
+	def __init__(
+			self,
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter,
+			token: Optional[trio.lowlevel.TrioToken],
+			buffer_size: Union[int, float],
+	) -> None:
+		"""
+		Initializes the TrioBiDiMixin.
+
+		Args:
+			lock (trio.Lock): Trio lock for synchronization.
+			limiter (trio.CapacityLimiter): Limiter for concurrent operations.
+			token (Optional[trio.lowlevel.TrioToken]): The Trio token for the current event loop.
+			buffer_size (Union[int, float]): Buffer size for the BiDi task channel.
+		"""
+		
+		super().__init__(lock=lock, limiter=limiter)
+		
+		self._trio_token = token if token is not None else trio.lowlevel.current_trio_token()
+		
+		self._trio_bidi_buffer_size = buffer_size
+		self._bidi_bridge_connection_pool: Optional[BiDiConnectionPool] = None
+		self._bidi_bridge_remote_connection: Optional[BiDiBridgeRemoteConnection] = None
+	
+	@property
+	def current_context_id(self) -> CURRENT_BROWSING_CONTEXT_TYPEHINT:
+		"""
+		Returns the browsing context ID (tab ID) associated with the current Trio task.
+		This operation is instant and does not require a driver call.
+
+		Returns:
+			CURRENT_BROWSING_CONTEXT_TYPEHINT: The current context ID.
+		"""
+		
+		return CURRENT_BROWSING_CONTEXT.get()
+	
+	@staticmethod
+	def switch_context(context_id: CURRENT_BROWSING_CONTEXT_TYPEHINT) -> None:
+		"""
+		Updates the target context for the CURRENT task only.
+		Equivalent to `driver.switch_to.window` but strictly local to the coroutine.
+
+		Args:
+			context_id (CURRENT_BROWSING_CONTEXT_TYPEHINT): The ID of the browsing context to switch to.
+		"""
+		
+		CURRENT_BROWSING_CONTEXT.set(context_id)
+	
+	def sync_to_trio(
+			self,
+			sync_function: Callable[_METHOD_INPUT, _METHOD_OUTPUT],
+			lock: bool = False,
+			exchange_context:bool = True,
+	) -> Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]:
+		"""
+		Wraps a synchronous function to run within a Trio thread pool using a lock and limiter.
+
+		Args:
+			sync_function (Callable[_METHOD_INPUT, _METHOD_OUTPUT]): The synchronous function to wrap.
+			lock (bool): Whether to use the internal lock for synchronization.
+			exchange_context (bool): Whether to synchronize context variables between threads.
+
+		Returns:
+			Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]: An async wrapper for the sync function.
+		"""
+		
+		return sync_to_trio(
+				sync_function=sync_function,
+				lock_object=self._lock,
+				capacity_limiter_object=self._capacity_limiter,
+				lock=lock,
+				exchange_context=exchange_context,
+		)
+	
+	def sync_to_trio_context(
+			self,
+			context_manager_factory: Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]],
+			lock: bool = False,
+			exchange_context: bool = True,
+	) -> Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]:
+		"""
+		Converts a synchronous context manager factory to an asynchronous Trio-compatible context manager.
+
+		Args:
+			context_manager_factory (Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]]): Factory function returning a context manager.
+			lock (bool): Whether to use the internal lock for synchronization.
+			exchange_context (bool): Whether to synchronize context variables between threads.
+
+		Returns:
+			Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]: An async function returning an async context manager.
+		"""
+		
+		return sync_to_trio_context(
+				context_manager_factory=context_manager_factory,
+				lock_object=self._lock,
+				capacity_limiter_object=self._capacity_limiter,
+				lock=lock,
+				exchange_context=exchange_context,
+		)
+	
+	@property
+	def trio_bidi_buffer_size(self) -> Union[int, float]:
+		"""
+		Returns the configured buffer size for BiDi operations.
+
+		Returns:
+			Union[int, float]: The buffer size.
+		"""
+		
+		return self._trio_bidi_buffer_size
+	
+	@property
+	def trio_token(self) -> trio.lowlevel.TrioToken:
+		"""
+		Returns the Trio token associated with this driver.
+
+		Returns:
+			trio.lowlevel.TrioToken: The event loop token.
+		"""
+		
+		return self._trio_token
+	
+	@asynccontextmanager
+	async def use_context(self, context_id: CURRENT_BROWSING_CONTEXT_TYPEHINT) -> AsyncGenerator[None, Any]:
+		"""
+		Context manager for temporary context switching.
+
+		Args:
+			context_id (CURRENT_BROWSING_CONTEXT_TYPEHINT): The ID of the browsing context to switch to.
+
+		EXAMPLES
+		________
+		>>> async with driver.use_context(tab_id):
+		...	 await driver.get("https://example.com")
+		... # Context automatically reverts here
+		"""
+		
+		token = CURRENT_BROWSING_CONTEXT.set(context_id)
+		
+		try:
+			yield
+		finally:
+			CURRENT_BROWSING_CONTEXT.reset(token)

osn_selenium/trio_bidi/remote_connection.py

@@ -0,0 +1,164 @@
+import trio
+from typing import Any, Dict, Optional
+from selenium.webdriver.remote.command import Command
+from selenium.webdriver.remote.client_config import ClientConfig
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.trio_bidi._typehints import (
+	REQUEST_PARAMS_TYPEHINT
+)
+from osn_selenium.trio_bidi._models import (
+	W3CTask,
+	W3CTaskContainer
+)
+from osn_selenium.trio_bidi._context_vars import (
+	CURRENT_BROWSING_CONTEXT
+)
+from osn_selenium.trio_bidi._internal_mappings import (
+	OSN_SWITCH_CONTEXT_KEY
+)
+
+
+__all__ = ["BiDiBridgeRemoteConnection"]
+
+
+def _processing_in_trio_loop() -> bool:
+	"""
+	Checks if the current code is executing within a Trio event loop.
+
+	Returns:
+		bool: True if in a Trio loop, False otherwise.
+	"""
+	
+	is_in_trio = False
+	
+	try:
+		trio.lowlevel.current_task()
+		is_in_trio = True
+	except RuntimeError:
+		pass
+	
+	return is_in_trio
+
+
+def _handle_response(w3c_task_container: W3CTaskContainer) -> Dict[str, Any]:
+	"""
+	Processes the result of a W3C task, handling errors and context switching.
+
+	Args:
+		w3c_task_container (W3CTaskContainer): The container holding the task result.
+
+	Returns:
+		Dict[str, Any]: The processed W3C response.
+
+	Raises:
+		Exception: The error received from the BiDi bridge if the task failed.
+	"""
+	
+	if w3c_task_container.response["error"]:
+		raise w3c_task_container.response["error"]
+	
+	osn_switch_context_value = w3c_task_container.response["response"].get(OSN_SWITCH_CONTEXT_KEY, None)
+	if osn_switch_context_value is not None:
+		CURRENT_BROWSING_CONTEXT.set(osn_switch_context_value)
+	
+	return w3c_task_container.response["response"]
+
+
+class BiDiBridgeRemoteConnection(RemoteConnection):
+	"""
+	Remote connection implementation that bridges W3C commands to a BiDi-capable backend via Trio.
+	"""
+	
+	def __init__(
+			self,
+			send_channel: trio.MemorySendChannel[W3CTaskContainer],
+			trio_token: trio.lowlevel.TrioToken,
+			legacy_remote_connection: RemoteConnection,
+			remote_server_addr: Optional[str] = "http://localhost:9999",
+			keep_alive: bool = True,
+			ignore_proxy: bool = False,
+			ignore_certificates: Optional[bool] = False,
+			init_args_for_pool_manager: Optional[Dict] = None,
+			client_config: Optional[ClientConfig] = None,
+	):
+		"""
+		Initializes the BiDiBridgeRemoteConnection.
+
+		Args:
+			send_channel (trio.MemorySendChannel[W3CTaskContainer]): The channel to send W3C tasks to.
+			trio_token (trio.lowlevel.TrioToken): The token for the Trio event loop.
+			legacy_remote_connection (RemoteConnection): The underlying legacy connection.
+			remote_server_addr (Optional[str]): The address of the remote Selenium server.
+			keep_alive (bool): Whether to keep the connection alive.
+			ignore_proxy (bool): Whether to ignore proxy settings.
+			ignore_certificates (Optional[bool]): Whether to ignore SSL certificate errors.
+			init_args_for_pool_manager (Optional[Dict]): Additional arguments for the pool manager.
+			client_config (Optional[ClientConfig]): Configuration object for the client.
+		"""
+		
+		super().__init__(
+				remote_server_addr=remote_server_addr,
+				keep_alive=keep_alive,
+				ignore_proxy=ignore_proxy,
+				ignore_certificates=ignore_certificates,
+				init_args_for_pool_manager=init_args_for_pool_manager,
+				client_config=client_config,
+		)
+		
+		self._legacy_remote_connection = legacy_remote_connection
+		self._trio_send_channel = send_channel
+		self._trio_token = trio_token
+	
+	def _OSN_GET_CURRENT_WINDOW_HANDLE(self, command: str, params: REQUEST_PARAMS_TYPEHINT) -> Optional[str]:
+		"""
+		Internal method to manage browsing context handle via local cache or legacy call.
+
+		Args:
+			command (str): Current command name.
+			params (Optional[Dict[str, Any]]): Current command parameters.
+
+		Returns:
+			Optional[str]: The browsing context ID.
+		"""
+		
+		context_id = CURRENT_BROWSING_CONTEXT.get()
+		
+		if context_id is not None:
+			return context_id
+		
+		context_id = self._legacy_remote_connection.execute(command, params)["value"]
+		CURRENT_BROWSING_CONTEXT.set(context_id)
+		
+		return context_id
+	
+	def execute(self, command: str, params: REQUEST_PARAMS_TYPEHINT) -> Dict[str, Any]:
+		"""
+		Executes a W3C command by sending it through the BiDi bridge or legacy connection.
+
+		Args:
+			command (str): The name of the command to execute.
+			params (Optional[Dict[str, Any]]): The parameters for the command.
+
+		Returns:
+			Dict[str, Any]: The response from the remote end.
+		"""
+		
+		if _processing_in_trio_loop():
+			return self._legacy_remote_connection.execute(command, params)
+		
+		context_id = self._OSN_GET_CURRENT_WINDOW_HANDLE(command=command, params=params)
+		
+		if command == Command.W3C_GET_CURRENT_WINDOW_HANDLE:
+			return {"value": context_id}
+		
+		w3c_task_container = W3CTaskContainer(task=W3CTask(command=command, params=params, context_id=context_id))
+		
+		trio.from_thread.run(
+				self._trio_send_channel.send,
+				w3c_task_container,
+				trio_token=self._trio_token
+		)
+		
+		w3c_task_container.pending_event.wait()
+		
+		return _handle_response(w3c_task_container=w3c_task_container)

osn_selenium/{base_mixin.py → trio_threads_mixin.py}

@@ -1,10 +1,11 @@
-import sys
 import trio
-from contextlib import asynccontextmanager
+from osn_selenium._trio_threads_helpers import (
+	sync_to_trio,
+	sync_to_trio_context
+)
 from typing import (
 	Any,
 	AsyncContextManager,
-	AsyncIterator,
 	Callable,
 	ContextManager,
 	Coroutine,
@@ -23,11 +24,6 @@ class TrioThreadMixin:
 	"""
 	Provides utilities for running synchronous functions in a Trio event loop
 	with a controlled concurrency, ensuring thread safety and resource limits.
-
-	Attributes:
-		_lock (trio.Lock): A Trio Lock to ensure exclusive access for certain operations.
-		_capacity_limiter (trio.CapacityLimiter): A Trio CapacityLimiter to control the number
-			of concurrent synchronous operations.
 	"""
 	
 	def __init__(self, lock: trio.Lock, limiter: trio.CapacityLimiter) -> None:
@@ -64,59 +60,54 @@ class TrioThreadMixin:
 		
 		return self._lock
 	
-	def sync_to_trio(self, sync_function: Callable[_METHOD_INPUT, _METHOD_OUTPUT]) -> Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]:
+	def sync_to_trio(
+			self,
+			sync_function: Callable[_METHOD_INPUT, _METHOD_OUTPUT],
+			lock: bool = True,
+			exchange_context:bool = True,
+	) -> Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]:
 		"""
 		Wraps a synchronous function to run within a Trio thread pool using a lock and limiter.
 
 		Args:
 			sync_function (Callable[_METHOD_INPUT, _METHOD_OUTPUT]): The synchronous function to wrap.
+			lock (bool): Whether to use the internal lock for synchronization.
+			exchange_context (bool): Whether to synchronize context variables between threads.
 
 		Returns:
 			Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]: An async wrapper for the sync function.
 		"""
 		
-		async def wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
-			def function_with_kwargs(*args_) -> _METHOD_OUTPUT:
-				return sync_function(*args_, **kwargs)
-			
-			async with self._lock:
-				result = await trio.to_thread.run_sync(function_with_kwargs, *args, limiter=self._capacity_limiter)
-			
-				return result
-		
-		return wrapper
+		return sync_to_trio(
+				sync_function=sync_function,
+				lock_object=self._lock,
+				capacity_limiter_object=self._capacity_limiter,
+				lock=lock,
+				exchange_context=exchange_context,
+		)
 	
 	def sync_to_trio_context(
 			self,
-			context_manager_factory: Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]]
+			context_manager_factory: Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]],
+			lock: bool = True,
+			exchange_context:bool = True,
 	) -> Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]:
 		"""
 		Converts a synchronous context manager factory to an asynchronous Trio-compatible context manager.
 
 		Args:
 			context_manager_factory (Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]]): A factory function returning a context manager.
+			lock (bool): Whether to use the internal lock for synchronization.
+			exchange_context (bool): Whether to synchronize context variables between threads.
 
 		Returns:
 			Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]: An async function returning an async context manager.
 		"""
 		
-		@asynccontextmanager
-		async def wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> AsyncIterator[_METHOD_OUTPUT]:
-			sync_context_manager = await self.sync_to_trio(sync_function=context_manager_factory)(*args, **kwargs)
-			
-			enter_ = self.sync_to_trio(sync_function=sync_context_manager.__enter__)
-			exit_ = self.sync_to_trio(sync_function=sync_context_manager.__exit__)
-			
-			try:
-				result = await enter_()
-			
-				yield result
-			except Exception as e:
-				exc_type, exc_val, exc_tb = sys.exc_info()
-			
-				if not await exit_(exc_type, exc_val, exc_tb):
-					raise e
-			else:
-				await exit_(None, None, None)
-		
-		return wrapper
+		return sync_to_trio_context(
+				context_manager_factory=context_manager_factory,
+				lock_object=self._lock,
+				capacity_limiter_object=self._capacity_limiter,
+				lock=lock,
+				exchange_context=exchange_context,
+		)