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

osn_selenium/executors/trio_threads/cdp/target.py

@@ -0,0 +1,156 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.target import (
+	UnifiedTargetCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.target import (
+	AbstractTargetCDPExecutor
+)
+
+
+__all__ = ["TargetCDPExecutor"]
+
+
+class TargetCDPExecutor(UnifiedTargetCDPExecutor, TrioThreadMixin, AbstractTargetCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedTargetCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def activate_target(self, target_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._activate_target_impl)(target_id=target_id)
+	
+	async def attach_to_browser_target(self) -> str:
+		return await self.sync_to_trio(sync_function=self._attach_to_browser_target_impl)()
+	
+	async def attach_to_target(self, target_id: str, flatten: Optional[bool] = None) -> str:
+		return await self.sync_to_trio(sync_function=self._attach_to_target_impl)(target_id=target_id, flatten=flatten)
+	
+	async def auto_attach_related(
+			self,
+			target_id: str,
+			wait_for_debugger_on_start: bool,
+			filter_: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._auto_attach_related_impl)(
+				target_id=target_id,
+				wait_for_debugger_on_start=wait_for_debugger_on_start,
+				filter_=filter_
+		)
+	
+	async def close_target(self, target_id: str) -> bool:
+		return await self.sync_to_trio(sync_function=self._close_target_impl)(target_id=target_id)
+	
+	async def create_browser_context(
+			self,
+			dispose_on_detach: Optional[bool] = None,
+			proxy_server: Optional[str] = None,
+			proxy_bypass_list: Optional[str] = None,
+			origins_with_universal_network_access: Optional[List[str]] = None
+	) -> str:
+		return await self.sync_to_trio(sync_function=self._create_browser_context_impl)(
+				dispose_on_detach=dispose_on_detach,
+				proxy_server=proxy_server,
+				proxy_bypass_list=proxy_bypass_list,
+				origins_with_universal_network_access=origins_with_universal_network_access
+		)
+	
+	async def create_target(
+			self,
+			url: str,
+			left: Optional[int] = None,
+			top: Optional[int] = None,
+			width: Optional[int] = None,
+			height: Optional[int] = None,
+			window_state: Optional[str] = None,
+			browser_context_id: Optional[str] = None,
+			enable_begin_frame_control: Optional[bool] = None,
+			new_window: Optional[bool] = None,
+			background: Optional[bool] = None,
+			for_tab: Optional[bool] = None,
+			hidden: Optional[bool] = None
+	) -> str:
+		return await self.sync_to_trio(sync_function=self._create_target_impl)(
+				url=url,
+				left=left,
+				top=top,
+				width=width,
+				height=height,
+				window_state=window_state,
+				browser_context_id=browser_context_id,
+				enable_begin_frame_control=enable_begin_frame_control,
+				new_window=new_window,
+				background=background,
+				for_tab=for_tab,
+				hidden=hidden
+		)
+	
+	async def detach_from_target(self, session_id: Optional[str] = None, target_id: Optional[str] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._detach_from_target_impl)(session_id=session_id, target_id=target_id)
+	
+	async def dispose_browser_context(self, browser_context_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._dispose_browser_context_impl)(browser_context_id=browser_context_id)
+	
+	async def expose_dev_tools_protocol(
+			self,
+			target_id: str,
+			binding_name: Optional[str] = None,
+			inherit_permissions: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._expose_dev_tools_protocol_impl)(
+				target_id=target_id,
+				binding_name=binding_name,
+				inherit_permissions=inherit_permissions
+		)
+	
+	async def get_browser_contexts(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._get_browser_contexts_impl)()
+	
+	async def get_target_info(self, target_id: Optional[str] = None) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_target_info_impl)(target_id=target_id)
+	
+	async def get_targets(self, filter_: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_targets_impl)(filter_=filter_)
+	
+	async def open_dev_tools(self, target_id: str) -> str:
+		return await self.sync_to_trio(sync_function=self._open_dev_tools_impl)(target_id=target_id)
+	
+	async def send_message_to_target(
+			self,
+			message: str,
+			session_id: Optional[str] = None,
+			target_id: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._send_message_to_target_impl)(message=message, session_id=session_id, target_id=target_id)
+	
+	async def set_auto_attach(
+			self,
+			auto_attach: bool,
+			wait_for_debugger_on_start: bool,
+			flatten: Optional[bool] = None,
+			filter_: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_auto_attach_impl)(
+				auto_attach=auto_attach,
+				wait_for_debugger_on_start=wait_for_debugger_on_start,
+				flatten=flatten,
+				filter_=filter_
+		)
+	
+	async def set_discover_targets(self, discover: bool, filter_: Optional[List[Dict[str, Any]]] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_discover_targets_impl)(discover=discover, filter_=filter_)
+	
+	async def set_remote_locations(self, locations: List[Dict[str, Any]]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_remote_locations_impl)(locations=locations)

osn_selenium/executors/trio_threads/cdp/tethering.py

@@ -0,0 +1,34 @@
+import trio
+from typing import Any, Callable, Dict
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.executors.unified.cdp.tethering import (
+	UnifiedTetheringCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.tethering import (
+	AbstractTetheringCDPExecutor
+)
+
+
+__all__ = ["TetheringCDPExecutor"]
+
+
+class TetheringCDPExecutor(
+		UnifiedTetheringCDPExecutor,
+		TrioThreadMixin,
+		AbstractTetheringCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedTetheringCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def bind(self, port: int) -> None:
+		return await self.sync_to_trio(sync_function=self._bind_impl)(port=port)
+	
+	async def unbind(self, port: int) -> None:
+		return await self.sync_to_trio(sync_function=self._unbind_impl)(port=port)

osn_selenium/executors/trio_threads/cdp/tracing.py

@@ -0,0 +1,71 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.tracing import (
+	UnifiedTracingCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.tracing import (
+	AbstractTracingCDPExecutor
+)
+
+
+__all__ = ["TracingCDPExecutor"]
+
+
+class TracingCDPExecutor(UnifiedTracingCDPExecutor, TrioThreadMixin, AbstractTracingCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedTracingCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def end(self) -> None:
+		return await self.sync_to_trio(sync_function=self._end_impl)()
+	
+	async def get_categories(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._get_categories_impl)()
+	
+	async def record_clock_sync_marker(self, sync_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._record_clock_sync_marker_impl)(sync_id=sync_id)
+	
+	async def request_memory_dump(
+			self,
+			deterministic: Optional[bool] = None,
+			level_of_detail: Optional[str] = None
+	) -> Tuple[str, bool]:
+		return await self.sync_to_trio(sync_function=self._request_memory_dump_impl)(deterministic=deterministic, level_of_detail=level_of_detail)
+	
+	async def start(
+			self,
+			categories: Optional[str] = None,
+			options: Optional[str] = None,
+			buffer_usage_reporting_interval: Optional[float] = None,
+			transfer_mode: Optional[str] = None,
+			stream_format: Optional[str] = None,
+			stream_compression: Optional[str] = None,
+			trace_config: Optional[Dict[str, Any]] = None,
+			perfetto_config: Optional[str] = None,
+			tracing_backend: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._start_impl)(
+				categories=categories,
+				options=options,
+				buffer_usage_reporting_interval=buffer_usage_reporting_interval,
+				transfer_mode=transfer_mode,
+				stream_format=stream_format,
+				stream_compression=stream_compression,
+				trace_config=trace_config,
+				perfetto_config=perfetto_config,
+				tracing_backend=tracing_backend
+		)

osn_selenium/executors/trio_threads/cdp/web_audio.py

@@ -0,0 +1,37 @@
+import trio
+from typing import Any, Callable, Dict
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.executors.unified.cdp.web_audio import (
+	UnifiedWebAudioCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.web_audio import (
+	AbstractWebAudioCDPExecutor
+)
+
+
+__all__ = ["WebAudioCDPExecutor"]
+
+
+class WebAudioCDPExecutor(
+		UnifiedWebAudioCDPExecutor,
+		TrioThreadMixin,
+		AbstractWebAudioCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedWebAudioCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def disable(self) -> None:
+		return await self.sync_to_trio(sync_function=self._disable_impl)()
+	
+	async def enable(self) -> None:
+		return await self.sync_to_trio(sync_function=self._enable_impl)()
+	
+	async def get_realtime_data(self, context_id: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_realtime_data_impl)(context_id=context_id)

osn_selenium/executors/trio_threads/cdp/web_authn.py

@@ -0,0 +1,95 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.web_authn import (
+	UnifiedWebAuthnCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.web_authn import (
+	AbstractWebAuthnCDPExecutor
+)
+
+
+__all__ = ["WebAuthnCDPExecutor"]
+
+
+class WebAuthnCDPExecutor(
+		UnifiedWebAuthnCDPExecutor,
+		TrioThreadMixin,
+		AbstractWebAuthnCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedWebAuthnCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def add_credential(self, authenticator_id: str, credential: Dict[str, Any]) -> None:
+		return await self.sync_to_trio(sync_function=self._add_credential_impl)(authenticator_id=authenticator_id, credential=credential)
+	
+	async def add_virtual_authenticator(self, options: Dict[str, Any]) -> str:
+		return await self.sync_to_trio(sync_function=self._add_virtual_authenticator_impl)(options=options)
+	
+	async def clear_credentials(self, authenticator_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_credentials_impl)(authenticator_id=authenticator_id)
+	
+	async def disable(self) -> None:
+		return await self.sync_to_trio(sync_function=self._disable_impl)()
+	
+	async def enable(self, enable_ui: Optional[bool] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._enable_impl)(enable_ui=enable_ui)
+	
+	async def get_credential(self, authenticator_id: str, credential_id: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_credential_impl)(authenticator_id=authenticator_id, credential_id=credential_id)
+	
+	async def get_credentials(self, authenticator_id: str) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_credentials_impl)(authenticator_id=authenticator_id)
+	
+	async def remove_credential(self, authenticator_id: str, credential_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_credential_impl)(authenticator_id=authenticator_id, credential_id=credential_id)
+	
+	async def remove_virtual_authenticator(self, authenticator_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_virtual_authenticator_impl)(authenticator_id=authenticator_id)
+	
+	async def set_automatic_presence_simulation(self, authenticator_id: str, enabled: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_automatic_presence_simulation_impl)(authenticator_id=authenticator_id, enabled=enabled)
+	
+	async def set_credential_properties(
+			self,
+			authenticator_id: str,
+			credential_id: str,
+			backup_eligibility: Optional[bool] = None,
+			backup_state: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_credential_properties_impl)(
+				authenticator_id=authenticator_id,
+				credential_id=credential_id,
+				backup_eligibility=backup_eligibility,
+				backup_state=backup_state
+		)
+	
+	async def set_response_override_bits(
+			self,
+			authenticator_id: str,
+			is_bogus_signature: Optional[bool] = None,
+			is_bad_uv: Optional[bool] = None,
+			is_bad_up: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_response_override_bits_impl)(
+				authenticator_id=authenticator_id,
+				is_bogus_signature=is_bogus_signature,
+				is_bad_uv=is_bad_uv,
+				is_bad_up=is_bad_up
+		)
+	
+	async def set_user_verified(self, authenticator_id: str, is_user_verified: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_user_verified_impl)(authenticator_id=authenticator_id, is_user_verified=is_user_verified)

osn_selenium/executors/trio_threads/javascript.py

@@ -0,0 +1,90 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.javascript.models import JS_Scripts
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+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, TrioThreadMixin, AbstractJSExecutor):
+	"""
+	An asynchronous JavaScript executor that integrates Trio's threading mixin for thread-safe operations.
+	"""
+	
+	def __init__(
+			self,
+			execute_function: Callable[[str, Any], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		"""
+		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.
+		"""
+		
+		UnifiedJSExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	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/unified/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/executors/unified/cdp/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/executors/unified/cdp/accessibility.py

@@ -0,0 +1,81 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["UnifiedAccessibilityCDPExecutor"]
+
+
+class UnifiedAccessibilityCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Accessibility.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Accessibility.enable", {})
+	
+	def _get_ax_node_and_ancestors_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> List[Dict[str, Any]]:
+		return self._execute_function(
+				"Accessibility.getAXNodeAndAncestors",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id
+				}
+		)
+	
+	def _get_child_ax_nodes_impl(self, id_: str, frame_id: Optional[str] = None) -> List[Dict[str, Any]]:
+		return self._execute_function("Accessibility.getChildAXNodes", {"id_": id_, "frame_id": frame_id})
+	
+	def _get_full_ax_tree_impl(self, depth: Optional[int] = None, frame_id: Optional[str] = None) -> List[Dict[str, Any]]:
+		return self._execute_function("Accessibility.getFullAXTree", {"depth": depth, "frame_id": frame_id})
+	
+	def _get_partial_ax_tree_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			fetch_relatives: Optional[bool] = None
+	) -> List[Dict[str, Any]]:
+		return self._execute_function(
+				"Accessibility.getPartialAXTree",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id,
+					"fetch_relatives": fetch_relatives
+				}
+		)
+	
+	def _get_root_ax_node_impl(self, frame_id: Optional[str] = None) -> Dict[str, Any]:
+		return self._execute_function("Accessibility.getRootAXNode", {"frame_id": frame_id})
+	
+	def _query_ax_tree_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			accessible_name: Optional[str] = None,
+			role: Optional[str] = None
+	) -> List[Dict[str, Any]]:
+		return self._execute_function(
+				"Accessibility.queryAXTree",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id,
+					"accessible_name": accessible_name,
+					"role": role
+				}
+		)

osn_selenium/executors/unified/cdp/animation.py

@@ -0,0 +1,50 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List
+)
+
+
+__all__ = ["UnifiedAnimationCDPExecutor"]
+
+
+class UnifiedAnimationCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Animation.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Animation.enable", {})
+	
+	def _get_current_time_impl(self, id_: str) -> float:
+		return self._execute_function("Animation.getCurrentTime", {"id_": id_})
+	
+	def _get_playback_rate_impl(self) -> float:
+		return self._execute_function("Animation.getPlaybackRate", {})
+	
+	def _release_animations_impl(self, animations: List[str]) -> None:
+		return self._execute_function("Animation.releaseAnimations", {"animations": animations})
+	
+	def _resolve_animation_impl(self, animation_id: str) -> Dict[str, Any]:
+		return self._execute_function("Animation.resolveAnimation", {"animation_id": animation_id})
+	
+	def _seek_animations_impl(self, animations: List[str], current_time: float) -> None:
+		return self._execute_function(
+				"Animation.seekAnimations",
+				{"animations": animations, "current_time": current_time}
+		)
+	
+	def _set_paused_impl(self, animations: List[str], paused: bool) -> None:
+		return self._execute_function("Animation.setPaused", {"animations": animations, "paused": paused})
+	
+	def _set_playback_rate_impl(self, playback_rate: float) -> None:
+		return self._execute_function("Animation.setPlaybackRate", {"playback_rate": playback_rate})
+	
+	def _set_timing_impl(self, animation_id: str, duration: float, delay: float) -> None:
+		return self._execute_function(
+				"Animation.setTiming",
+				{"animation_id": animation_id, "duration": duration, "delay": delay}
+		)

osn_selenium/executors/unified/cdp/audits.py

@@ -0,0 +1,45 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedAuditsCDPExecutor"]
+
+
+class UnifiedAuditsCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _check_contrast_impl(self, report_aaa: Optional[bool] = None) -> None:
+		return self._execute_function("Audits.checkContrast", {"report_aaa": report_aaa})
+	
+	def _check_forms_issues_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("Audits.checkFormsIssues", {})
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Audits.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Audits.enable", {})
+	
+	def _get_encoded_response_impl(
+			self,
+			request_id: str,
+			encoding: str,
+			quality: Optional[float] = None,
+			size_only: Optional[bool] = None
+	) -> Tuple[Optional[str], int, int]:
+		return self._execute_function(
+				"Audits.getEncodedResponse",
+				{
+					"request_id": request_id,
+					"encoding": encoding,
+					"quality": quality,
+					"size_only": size_only
+				}
+		)