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

osn_selenium/trio_bidi/_error_mappings.py

@@ -0,0 +1,123 @@
+from typing import Any, Dict
+from selenium.webdriver.remote.errorhandler import ErrorCode
+from osn_selenium.exceptions.bidi_bridge import BiDiExecutionError
+
+
+__all__ = [
+	"BIDI_TO_W3C_ERROR_MAP",
+	"create_w3c_error_response",
+	"map_bidi_error_to_w3c"
+]
+
+_UNMAPPABLE_ERROR = (-1, "unmappable error")
+
+BIDI_TO_W3C_ERROR_MAP = {
+	"invalid argument": ErrorCode.INVALID_ARGUMENT,
+	"invalid selector": ErrorCode.INVALID_SELECTOR,
+	"invalid session id": ErrorCode.INVALID_SESSION_ID,
+	"move target out of bounds": ErrorCode.MOVE_TARGET_OUT_OF_BOUNDS,
+	"no such alert": ErrorCode.NO_ALERT_OPEN,
+	"no such element": ErrorCode.NO_SUCH_ELEMENT,
+	"no such frame": ErrorCode.NO_SUCH_FRAME,
+	"no such window": ErrorCode.NO_SUCH_WINDOW,
+	"no such cookie": ErrorCode.NO_SUCH_COOKIE,
+	"stale element reference": ErrorCode.STALE_ELEMENT_REFERENCE,
+	"element not interactable": ErrorCode.ELEMENT_NOT_INTERACTABLE,
+	"element click intercepted": ErrorCode.ELEMENT_CLICK_INTERCEPTED,
+	"javascript error": ErrorCode.JAVASCRIPT_ERROR,
+	"timeout": ErrorCode.TIMEOUT,
+	"script timeout": ErrorCode.SCRIPT_TIMEOUT,
+	"session not created": ErrorCode.SESSION_NOT_CREATED,
+	"unable to capture screen": ErrorCode.UNABLE_TO_CAPTURE_SCREEN,
+	"unable to set cookie": ErrorCode.UNABLE_TO_SET_COOKIE,
+	"unexpected alert open": ErrorCode.UNEXPECTED_ALERT_OPEN,
+	"unknown command": ErrorCode.UNKNOWN_COMMAND,
+	"unknown error": ErrorCode.UNKNOWN_ERROR,
+	"unsupported operation": ErrorCode.METHOD_NOT_ALLOWED,
+	"detached shadow root": ErrorCode.DETACHED_SHADOW_ROOT,
+	"no such node": ErrorCode.NO_SUCH_ELEMENT,
+	"no such handle": ErrorCode.NO_SUCH_ELEMENT,
+	"no such client window": ErrorCode.NO_SUCH_WINDOW,
+	"invalid web extension": _UNMAPPABLE_ERROR,
+	"unable to set file input": _UNMAPPABLE_ERROR,
+	"no such script": _UNMAPPABLE_ERROR,
+	"no such history entry": _UNMAPPABLE_ERROR,
+	"no such network collector": _UNMAPPABLE_ERROR,
+	"no such intercept": _UNMAPPABLE_ERROR,
+	"no such network data": _UNMAPPABLE_ERROR,
+	"no such request": _UNMAPPABLE_ERROR,
+	"no such storage partition": _UNMAPPABLE_ERROR,
+	"no such user context": _UNMAPPABLE_ERROR,
+	"no such web extension": _UNMAPPABLE_ERROR,
+	"unable to close browser": _UNMAPPABLE_ERROR,
+	"underspecified storage partition": _UNMAPPABLE_ERROR,
+	"unavailable network data": _UNMAPPABLE_ERROR,
+}
+
+
+def create_w3c_error_response(
+		status_code: int,
+		error_string: str,
+		message: str,
+		stacktrace: str = ""
+) -> Dict[str, Any]:
+	"""
+	Creates a standardized W3C WebDriver error response dictionary.
+
+	Args:
+		status_code (int): The numeric status code for the error.
+		error_string (str): The string identifier for the error.
+		message (str): The descriptive error message.
+		stacktrace (str): The stacktrace associated with the error.
+
+	Returns:
+		Dict[str, Any]: Formatted W3C error response.
+	"""
+	
+	return {
+		"status": status_code,
+		"value": {"error": error_string, "message": message, "stacktrace": stacktrace}
+	}
+
+
+def map_bidi_error_to_w3c(bidi_error_data: Dict[str, Any]) -> Dict[str, Any]:
+	"""
+	Maps a BiDi protocol error to the corresponding W3C WebDriver error response.
+
+	Args:
+		bidi_error_data (Dict[str, Any]): Dictionary containing error details from BiDi.
+
+	Returns:
+		Dict[str, Any]: Formatted W3C error response.
+
+	Raises:
+		BiDiExecutionError: If error data is malformed or represents an unmappable BiDi error.
+	"""
+	
+	bidi_error = bidi_error_data.get("error", "unknown error")
+	message = bidi_error_data.get("message", bidi_error)
+	stacktrace = bidi_error_data.get("stacktrace", "")
+	
+	error_data = BIDI_TO_W3C_ERROR_MAP.get(bidi_error, ErrorCode.UNKNOWN_ERROR)
+	
+	if len(error_data) == 2:
+		status_code, error_string = error_data
+	else:
+		status_code = 13
+		error_string = error_data[0]
+	
+	try:
+		status_code = int(status_code)
+		error_string = str(error_string)
+	except (ValueError, TypeError):
+		raise BiDiExecutionError(error=bidi_error, message=f"Malformed error data: {message}")
+	
+	if (status_code, error_string) == _UNMAPPABLE_ERROR:
+		raise BiDiExecutionError(error=error_string, message=message)
+	
+	return create_w3c_error_response(
+			status_code=status_code,
+			error_string=error_string,
+			message=message,
+			stacktrace=stacktrace,
+	)

osn_selenium/trio_bidi/_error_redirects.py

@@ -0,0 +1,194 @@
+from typing import Any, Dict
+from selenium.webdriver.remote.command import Command
+from selenium.webdriver.remote.errorhandler import ErrorCode
+from osn_selenium.trio_bidi._error_mappings import (
+	create_w3c_error_response,
+	map_bidi_error_to_w3c
+)
+
+
+__all__ = ["redirect_error_response"]
+
+
+class _Redirect_:
+	"""
+	Internal container for logic to redirect certain error types to others based on the command.
+	"""
+	
+	class InvalidArgument_:
+		"""
+		Logic for InvalidArgument redirection.
+		"""
+		
+		to_NoAlertPresent_Commands = [
+			Command.W3C_GET_ALERT_TEXT,
+			Command.W3C_ACCEPT_ALERT,
+			Command.W3C_DISMISS_ALERT,
+			Command.W3C_SET_ALERT_VALUE
+		]
+		
+		@staticmethod
+		def to_NoAlertPresent(error_response: Dict[str, Any]) -> Dict[str, Any]:
+			"""
+			Redirects INVALID_ARGUMENT to NO_ALERT_OPEN if related to alerts/prompts.
+
+			Args:
+				error_response (Dict[str, Any]): The initial W3C error response.
+
+			Returns:
+				Dict[str, Any]: The redirected error response.
+			"""
+			
+			value = error_response.get("value", {})
+			
+			if value.get("error") == ErrorCode.INVALID_ARGUMENT[1]:
+				message = value.get("message", "").lower()
+			
+				if "alert" in message or "prompt" in message or "no such alert" in message:
+					status_code, error_string = ErrorCode.NO_ALERT_OPEN
+			
+					return create_w3c_error_response(
+							status_code=status_code,
+							error_string=error_string,
+							message="no such alert"
+					)
+			
+			return error_response
+	
+	class NoSuchElement_:
+		"""
+		Logic for NoSuchElement redirection.
+		"""
+		
+		to_DetachedShadowRoot_Commands = [
+			Command.FIND_ELEMENT_FROM_SHADOW_ROOT,
+			Command.FIND_ELEMENTS_FROM_SHADOW_ROOT,
+		]
+		
+		to_StaleElementReference_Commands = [
+			Command.GET_ELEMENT_TAG_NAME,
+			Command.GET_ELEMENT_TEXT,
+			Command.CLICK_ELEMENT,
+			Command.CLEAR_ELEMENT,
+			Command.GET_ELEMENT_PROPERTY,
+			Command.GET_ELEMENT_ATTRIBUTE,
+			Command.IS_ELEMENT_SELECTED,
+			Command.IS_ELEMENT_ENABLED,
+			Command.SEND_KEYS_TO_ELEMENT,
+			Command.GET_SHADOW_ROOT,
+			Command.GET_ELEMENT_RECT,
+			Command.GET_ELEMENT_VALUE_OF_CSS_PROPERTY,
+			Command.GET_ELEMENT_ARIA_ROLE,
+			Command.GET_ELEMENT_ARIA_LABEL,
+			Command.ELEMENT_SCREENSHOT,
+			Command.FIND_CHILD_ELEMENT,
+			Command.FIND_CHILD_ELEMENTS,
+		]
+		
+		@staticmethod
+		def to_DetachedShadowRoot(error_response: Dict[str, Any]) -> Dict[str, Any]:
+			"""
+			Redirects NO_SUCH_ELEMENT to DETACHED_SHADOW_ROOT.
+
+			Args:
+				error_response (Dict[str, Any]): The initial W3C error response.
+
+			Returns:
+				Dict[str, Any]: The redirected error response.
+			"""
+			
+			if error_response.get("status") == ErrorCode.NO_SUCH_ELEMENT[0]:
+				status_code, error_string = ErrorCode.DETACHED_SHADOW_ROOT
+				message = "detached shadow root: shadow root is no longer attached to the document"
+			
+				return create_w3c_error_response(status_code=status_code, error_string=error_string, message=message)
+			
+			return error_response
+		
+		@staticmethod
+		def to_StaleElementReference(error_response: Dict[str, Any]) -> Dict[str, Any]:
+			"""
+			Redirects NO_SUCH_ELEMENT to STALE_ELEMENT_REFERENCE.
+
+			Args:
+				error_response (Dict[str, Any]): The initial W3C error response.
+
+			Returns:
+				Dict[str, Any]: The redirected error response.
+			"""
+			
+			if error_response.get("status") == ErrorCode.NO_SUCH_ELEMENT[0]:
+				status_code, error_string = ErrorCode.STALE_ELEMENT_REFERENCE
+				message = "stale element reference: element is not attached to the page document"
+			
+				return create_w3c_error_response(status_code=status_code, error_string=error_string, message=message)
+			
+			return error_response
+	
+	class NoSuchFrame_:
+		"""
+		Logic for NoSuchFrame redirection.
+		"""
+		
+		to_NoSuchWindow_Commands = [
+			Command.SWITCH_TO_WINDOW,
+			Command.GET_CURRENT_URL,
+			Command.GET_TITLE,
+			Command.CLOSE,
+			Command.SCREENSHOT,
+			Command.PRINT_PAGE,
+			Command.GET_PAGE_SOURCE,
+			Command.SET_SCREEN_ORIENTATION,
+			Command.GET_SCREEN_ORIENTATION,
+		]
+		
+		@staticmethod
+		def to_NoSuchWindow(error_response: Dict[str, Any]):
+			"""
+			Redirects NO_SUCH_FRAME to NO_SUCH_WINDOW.
+
+			Args:
+				error_response (Dict[str, Any]): The initial W3C error response.
+
+			Returns:
+				Dict[str, Any]: The redirected error response.
+			"""
+			
+			value = error_response.get("value", {})
+			
+			if value.get("error") == ErrorCode.NO_SUCH_FRAME[1]:
+				status_code, error_string = ErrorCode.NO_SUCH_WINDOW
+				message = "no such window"
+			
+				return create_w3c_error_response(status_code=status_code, error_string=error_string, message=message)
+			
+			return error_response
+
+
+def redirect_error_response(command: str, bidi_response: Dict[str, Any]) -> Dict[str, Any]:
+	"""
+	Main entry point for mapping BiDi errors to W3C and applying redirection logic.
+
+	Args:
+		command (str): The original W3C command.
+		bidi_response (Dict[str, Any]): The raw error data from BiDi.
+
+	Returns:
+		Dict[str, Any]: The finalized W3C error response.
+	"""
+	
+	error_response = map_bidi_error_to_w3c(bidi_error_data=bidi_response)
+	
+	if command in _Redirect_.NoSuchFrame_.to_NoSuchWindow_Commands:
+		return _Redirect_.NoSuchFrame_.to_NoSuchWindow(error_response=error_response)
+	
+	if command in _Redirect_.InvalidArgument_.to_NoAlertPresent_Commands:
+		return _Redirect_.InvalidArgument_.to_NoAlertPresent(error_response=error_response)
+	
+	if command in _Redirect_.NoSuchElement_.to_StaleElementReference_Commands:
+		return _Redirect_.NoSuchElement_.to_StaleElementReference(error_response=error_response)
+	
+	if command in _Redirect_.NoSuchElement_.to_DetachedShadowRoot_Commands:
+		return _Redirect_.NoSuchElement_.to_DetachedShadowRoot(error_response=error_response)
+	
+	return error_response

osn_selenium/trio_bidi/_file_functions.py

@@ -0,0 +1,28 @@
+import os
+import base64
+import zipfile
+import tempfile
+from io import BytesIO
+
+
+__all__ = ["unzip_file"]
+
+
+def unzip_file(base64_zip: str) -> str:
+	"""
+	Decodes a base64 encoded zip file and extracts its first content to a temporary directory.
+
+	Args:
+		base64_zip (str): The base64 encoded string of the zip file.
+
+	Returns:
+		str: The path to the extracted file.
+	"""
+	
+	zip_data = base64.b64decode(base64_zip)
+	
+	with zipfile.ZipFile(BytesIO(zip_data)) as zipped_file:
+		temp_dir = tempfile.mkdtemp()
+		zipped_file.extractall(temp_dir)
+	
+		return os.path.join(temp_dir, zipped_file.namelist()[0])

osn_selenium/trio_bidi/_internal_mappings.py

@@ -0,0 +1,10 @@
+__all__ = [
+	"GET_INTERNAL_ALERT_TEXT",
+	"OSN_SWITCH_CONTEXT_KEY",
+	"UPLOAD_INTERNAL_FILE"
+]
+
+GET_INTERNAL_ALERT_TEXT = "BRIDGE.GET_INTERNAL_ALERT_TEXT"
+UPLOAD_INTERNAL_FILE = "BRIDGE.UPLOAD_INTERNAL_FILE"
+
+OSN_SWITCH_CONTEXT_KEY = "OSN_SWITCH_CONTEXT"

osn_selenium/trio_bidi/_models.py

@@ -0,0 +1,199 @@
+import trio
+import threading
+from dataclasses import dataclass, field
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Self
+)
+from osn_selenium.trio_bidi._typehints import (
+	REQUEST_PARAMS_TYPEHINT
+)
+
+
+__all__ = ["BiDiTask", "BiDiTaskContainer", "W3CTask", "W3CTaskContainer"]
+
+
+@dataclass(slots=True)
+class W3CTask:
+	"""
+	Representation of a W3C WebDriver task.
+
+	Attributes:
+		command (str): The command name.
+		request_params (REQUEST_PARAMS_TYPEHINT): The command parameters.
+		context_id (CURRENT_BROWSING_CONTEXT_TYPEHINT): The browsing context ID.
+	"""
+	
+	command: str
+	params: REQUEST_PARAMS_TYPEHINT
+	context_id: Optional[str]
+	
+	@classmethod
+	def from_dict(cls, data: Dict[str, Any]) -> Self:
+		"""
+		Creates a W3CTask instance from a dictionary.
+
+		Args:
+			data (Dict[str, Any]): The dictionary containing task data.
+
+		Returns:
+			Self: A new W3CTask instance.
+		"""
+		
+		return cls(
+				command=data["command"],
+				params=data["params"],
+				context_id=data["context_id"],
+		)
+	
+	def to_dict(self) -> Dict[str, Any]:
+		"""
+		Converts the task to a dictionary.
+
+		Returns:
+			Dict[str, Any]: The task as a dictionary.
+		"""
+		
+		return {
+			"command": self.command,
+			"params": self.params,
+			"context_id": self.context_id,
+		}
+
+
+@dataclass(slots=True)
+class W3CTaskContainer:
+	"""
+	Container for a W3C task including response and synchronization event.
+
+	Attributes:
+		task (W3CTask): The W3C task.
+		response (Dict[str, Any]): The response and error information.
+		pending_event (threading.Event): Event to wait for task completion.
+	"""
+	
+	task: W3CTask
+	response: Dict[str, Any] = field(default_factory=lambda: {"response": None, "error": None})
+	pending_event: threading.Event = field(default_factory=threading.Event)
+	
+	@classmethod
+	def from_dict(cls, data: Dict[str, Any]) -> Self:
+		"""
+		Creates a W3CTaskContainer instance from a dictionary.
+
+		Args:
+			data (Dict[str, Any]): The dictionary containing container data.
+
+		Returns:
+			Self: A new W3CTaskContainer instance.
+		"""
+		
+		return cls(
+				task=W3CTask.from_dict(data["task"]),
+				response=data["response"],
+				pending_event=data["pending_event"],
+		)
+	
+	def to_dict(self) -> Dict[str, Any]:
+		"""
+		Converts the container to a dictionary.
+
+		Returns:
+			Dict[str, Any]: The container as a dictionary.
+		"""
+		
+		return {
+			"task": self.task.to_dict(),
+			"response": self.response,
+			"pending_event": self.pending_event,
+		}
+
+
+@dataclass(slots=True)
+class BiDiTask:
+	"""
+	Representation of a WebDriver BiDi task.
+
+	Attributes:
+		id (int): The task ID.
+		method (str): The BiDi method.
+		request_params (REQUEST_PARAMS_TYPEHINT): The BiDi parameters.
+	"""
+	
+	id: int
+	method: str
+	params: REQUEST_PARAMS_TYPEHINT
+	
+	@classmethod
+	def from_dict(cls, data: Dict[str, Any]) -> Self:
+		"""
+		Creates a BiDiTask instance from a dictionary.
+
+		Args:
+			data (Dict[str, Any]): The dictionary containing task data.
+
+		Returns:
+			Self: A new BiDiTask instance.
+		"""
+		
+		return cls(id=data["id"], method=data["method"], params=data["params"])
+	
+	def to_dict(self) -> Dict[str, Any]:
+		"""
+		Converts the task to a dictionary.
+
+		Returns:
+			Dict[str, Any]: The task as a dictionary.
+		"""
+		
+		return {"id": self.id, "method": self.method, "params": self.params}
+
+
+@dataclass(slots=True)
+class BiDiTaskContainer:
+	"""
+	Container for a BiDi task including response and synchronization event.
+
+	Attributes:
+		task (BiDiTask): The BiDi task.
+		response (Dict[str, Any]): The response data.
+		pending_event (trio.Event): Trio event to wait for task completion.
+	"""
+	
+	task: BiDiTask
+	response: Dict[str, Any] = field(default_factory=dict)
+	pending_event: trio.Event = field(default_factory=trio.Event)
+	
+	@classmethod
+	def from_dict(cls, data: Dict[str, Any]) -> Self:
+		"""
+		Creates a BiDiTaskContainer instance from a dictionary.
+
+		Args:
+			data (Dict[str, Any]): The dictionary containing container data.
+
+		Returns:
+			Self: A new BiDiTaskContainer instance.
+		"""
+		
+		return cls(
+				task=BiDiTask.from_dict(data["task"]),
+				response=data["response"],
+				pending_event=data["pending_event"],
+		)
+	
+	def to_dict(self) -> Dict[str, Any]:
+		"""
+		Converts the container to a dictionary.
+
+		Returns:
+			Dict[str, Any]: The container as a dictionary.
+		"""
+		
+		return {
+			"task": self.task.to_dict(),
+			"response": self.response,
+			"pending_event": self.pending_event,
+		}

osn_selenium/trio_bidi/_typehints.py

@@ -0,0 +1,20 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+
+
+__all__ = [
+	"CURRENT_BROWSING_CONTEXT_TYPEHINT",
+	"MAP_REQUEST_FUNCTION_TYPEHINT",
+	"MAP_RESPONSE_FUNCTION_TYPEHINT",
+	"REQUEST_PARAMS_TYPEHINT"
+]
+
+CURRENT_BROWSING_CONTEXT_TYPEHINT = Optional[str]
+REQUEST_PARAMS_TYPEHINT = Optional[Dict[str, Any]]
+
+MAP_REQUEST_FUNCTION_TYPEHINT = Callable[[REQUEST_PARAMS_TYPEHINT, str], Dict[str, Any]]
+MAP_RESPONSE_FUNCTION_TYPEHINT = Callable[[Dict[str, Any], REQUEST_PARAMS_TYPEHINT], Dict[str, Any]]