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

osn_selenium/executors/trio_threads/cdp/accessibility.py

@@ -0,0 +1,87 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.accessibility import (
+	UnifiedAccessibilityCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.accessibility import (
+	AbstractAccessibilityCDPExecutor
+)
+
+
+__all__ = ["AccessibilityCDPExecutor"]
+
+
+class AccessibilityCDPExecutor(
+		UnifiedAccessibilityCDPExecutor,
+		TrioThreadMixin,
+		AbstractAccessibilityCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedAccessibilityCDPExecutor.__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_ax_node_and_ancestors(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_ax_node_and_ancestors_impl)(node_id=node_id, backend_node_id=backend_node_id, object_id=object_id)
+	
+	async def get_child_ax_nodes(self, id_: str, frame_id: Optional[str] = None) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_child_ax_nodes_impl)(id_=id_, frame_id=frame_id)
+	
+	async def get_full_ax_tree(self, depth: Optional[int] = None, frame_id: Optional[str] = None) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_full_ax_tree_impl)(depth=depth, frame_id=frame_id)
+	
+	async def get_partial_ax_tree(
+			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 await self.sync_to_trio(sync_function=self._get_partial_ax_tree_impl)(
+				node_id=node_id,
+				backend_node_id=backend_node_id,
+				object_id=object_id,
+				fetch_relatives=fetch_relatives
+		)
+	
+	async def get_root_ax_node(self, frame_id: Optional[str] = None) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_root_ax_node_impl)(frame_id=frame_id)
+	
+	async def query_ax_tree(
+			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 await self.sync_to_trio(sync_function=self._query_ax_tree_impl)(
+				node_id=node_id,
+				backend_node_id=backend_node_id,
+				object_id=object_id,
+				accessible_name=accessible_name,
+				role=role
+		)

osn_selenium/executors/trio_threads/cdp/animation.py

@@ -0,0 +1,63 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List
+)
+from osn_selenium.executors.unified.cdp.animation import (
+	UnifiedAnimationCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.animation import (
+	AbstractAnimationCDPExecutor
+)
+
+
+__all__ = ["AnimationCDPExecutor"]
+
+
+class AnimationCDPExecutor(
+		UnifiedAnimationCDPExecutor,
+		TrioThreadMixin,
+		AbstractAnimationCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedAnimationCDPExecutor.__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_current_time(self, id_: str) -> float:
+		return await self.sync_to_trio(sync_function=self._get_current_time_impl)(id_=id_)
+	
+	async def get_playback_rate(self) -> float:
+		return await self.sync_to_trio(sync_function=self._get_playback_rate_impl)()
+	
+	async def release_animations(self, animations: List[str]) -> None:
+		return await self.sync_to_trio(sync_function=self._release_animations_impl)(animations=animations)
+	
+	async def resolve_animation(self, animation_id: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._resolve_animation_impl)(animation_id=animation_id)
+	
+	async def seek_animations(self, animations: List[str], current_time: float) -> None:
+		return await self.sync_to_trio(sync_function=self._seek_animations_impl)(animations=animations, current_time=current_time)
+	
+	async def set_paused(self, animations: List[str], paused: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_paused_impl)(animations=animations, paused=paused)
+	
+	async def set_playback_rate(self, playback_rate: float) -> None:
+		return await self.sync_to_trio(sync_function=self._set_playback_rate_impl)(playback_rate=playback_rate)
+	
+	async def set_timing(self, animation_id: str, duration: float, delay: float) -> None:
+		return await self.sync_to_trio(sync_function=self._set_timing_impl)(animation_id=animation_id, duration=duration, delay=delay)

osn_selenium/executors/trio_threads/cdp/audits.py

@@ -0,0 +1,57 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.audits import (
+	UnifiedAuditsCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.audits import (
+	AbstractAuditsCDPExecutor
+)
+
+
+__all__ = ["AuditsCDPExecutor"]
+
+
+class AuditsCDPExecutor(UnifiedAuditsCDPExecutor, TrioThreadMixin, AbstractAuditsCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedAuditsCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def check_contrast(self, report_aaa: Optional[bool] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._check_contrast_impl)(report_aaa=report_aaa)
+	
+	async def check_forms_issues(self) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._check_forms_issues_impl)()
+	
+	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_encoded_response(
+			self,
+			request_id: str,
+			encoding: str,
+			quality: Optional[float] = None,
+			size_only: Optional[bool] = None
+	) -> Tuple[Optional[str], int, int]:
+		return await self.sync_to_trio(sync_function=self._get_encoded_response_impl)(
+				request_id=request_id,
+				encoding=encoding,
+				quality=quality,
+				size_only=size_only
+		)

osn_selenium/executors/trio_threads/cdp/autofill.py

@@ -0,0 +1,52 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.autofill import (
+	UnifiedAutofillCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.autofill import (
+	AbstractAutofillCDPExecutor
+)
+
+
+__all__ = ["AutofillCDPExecutor"]
+
+
+class AutofillCDPExecutor(
+		UnifiedAutofillCDPExecutor,
+		TrioThreadMixin,
+		AbstractAutofillCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedAutofillCDPExecutor.__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 set_addresses(self, addresses: List[Dict[str, Any]]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_addresses_impl)(addresses=addresses)
+	
+	async def trigger(
+			self,
+			field_id: int,
+			frame_id: Optional[str] = None,
+			card: Optional[Dict[str, Any]] = None,
+			address: Optional[Dict[str, Any]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._trigger_impl)(field_id=field_id, frame_id=frame_id, card=card, address=address)

osn_selenium/executors/trio_threads/cdp/background_service.py

@@ -0,0 +1,40 @@
+import trio
+from typing import Any, Callable, Dict
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.executors.unified.cdp.background_service import (
+	UnifiedBackgroundServiceCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.background_service import (
+	AbstractBackgroundServiceCDPExecutor
+)
+
+
+__all__ = ["BackgroundServiceCDPExecutor"]
+
+
+class BackgroundServiceCDPExecutor(
+		UnifiedBackgroundServiceCDPExecutor,
+		TrioThreadMixin,
+		AbstractBackgroundServiceCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedBackgroundServiceCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def clear_events(self, service: str) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_events_impl)(service=service)
+	
+	async def set_recording(self, should_record: bool, service: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_recording_impl)(should_record=should_record, service=service)
+	
+	async def start_observing(self, service: str) -> None:
+		return await self.sync_to_trio(sync_function=self._start_observing_impl)(service=service)
+	
+	async def stop_observing(self, service: str) -> None:
+		return await self.sync_to_trio(sync_function=self._stop_observing_impl)(service=service)

osn_selenium/executors/trio_threads/cdp/bluetooth_emulation.py

@@ -0,0 +1,111 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.bluetooth_emulation import (
+	UnifiedBluetoothEmulationCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.bluetooth_emulation import (
+	AbstractBluetoothEmulationCDPExecutor
+)
+
+
+__all__ = ["BluetoothEmulationCDPExecutor"]
+
+
+class BluetoothEmulationCDPExecutor(
+		UnifiedBluetoothEmulationCDPExecutor,
+		TrioThreadMixin,
+		AbstractBluetoothEmulationCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedBluetoothEmulationCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def add_characteristic(
+			self,
+			service_id: str,
+			characteristic_uuid: str,
+			properties: Dict[str, Any]
+	) -> str:
+		return await self.sync_to_trio(sync_function=self._add_characteristic_impl)(
+				service_id=service_id,
+				characteristic_uuid=characteristic_uuid,
+				properties=properties
+		)
+	
+	async def add_descriptor(self, characteristic_id: str, descriptor_uuid: str) -> str:
+		return await self.sync_to_trio(sync_function=self._add_descriptor_impl)(characteristic_id=characteristic_id, descriptor_uuid=descriptor_uuid)
+	
+	async def add_service(self, address: str, service_uuid: str) -> str:
+		return await self.sync_to_trio(sync_function=self._add_service_impl)(address=address, service_uuid=service_uuid)
+	
+	async def disable(self) -> None:
+		return await self.sync_to_trio(sync_function=self._disable_impl)()
+	
+	async def enable(self, state: str, le_supported: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._enable_impl)(state=state, le_supported=le_supported)
+	
+	async def remove_characteristic(self, characteristic_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_characteristic_impl)(characteristic_id=characteristic_id)
+	
+	async def remove_descriptor(self, descriptor_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_descriptor_impl)(descriptor_id=descriptor_id)
+	
+	async def remove_service(self, service_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_service_impl)(service_id=service_id)
+	
+	async def set_simulated_central_state(self, state: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_simulated_central_state_impl)(state=state)
+	
+	async def simulate_advertisement(self, entry: Dict[str, Any]) -> None:
+		return await self.sync_to_trio(sync_function=self._simulate_advertisement_impl)(entry=entry)
+	
+	async def simulate_characteristic_operation_response(
+			self,
+			characteristic_id: str,
+			type_: str,
+			code: int,
+			data: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._simulate_characteristic_operation_response_impl)(characteristic_id=characteristic_id, type_=type_, code=code, data=data)
+	
+	async def simulate_descriptor_operation_response(
+			self,
+			descriptor_id: str,
+			type_: str,
+			code: int,
+			data: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._simulate_descriptor_operation_response_impl)(descriptor_id=descriptor_id, type_=type_, code=code, data=data)
+	
+	async def simulate_gatt_disconnection(self, address: str) -> None:
+		return await self.sync_to_trio(sync_function=self._simulate_gatt_disconnection_impl)(address=address)
+	
+	async def simulate_gatt_operation_response(self, address: str, type_: str, code: int) -> None:
+		return await self.sync_to_trio(sync_function=self._simulate_gatt_operation_response_impl)(address=address, type_=type_, code=code)
+	
+	async def simulate_preconnected_peripheral(
+			self,
+			address: str,
+			name: str,
+			manufacturer_data: List[Dict[str, Any]],
+			known_service_uuids: List[str]
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._simulate_preconnected_peripheral_impl)(
+				address=address,
+				name=name,
+				manufacturer_data=manufacturer_data,
+				known_service_uuids=known_service_uuids
+		)

osn_selenium/executors/trio_threads/cdp/browser.py

@@ -0,0 +1,140 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.browser import (
+	UnifiedBrowserCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.browser import (
+	AbstractBrowserCDPExecutor
+)
+
+
+__all__ = ["BrowserCDPExecutor"]
+
+
+class BrowserCDPExecutor(UnifiedBrowserCDPExecutor, TrioThreadMixin, AbstractBrowserCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedBrowserCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def add_privacy_sandbox_coordinator_key_config(
+			self,
+			api: str,
+			coordinator_origin: str,
+			key_config: str,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._add_privacy_sandbox_coordinator_key_config_impl)(
+				api=api,
+				coordinator_origin=coordinator_origin,
+				key_config=key_config,
+				browser_context_id=browser_context_id
+		)
+	
+	async def add_privacy_sandbox_enrollment_override(self, url: str) -> None:
+		return await self.sync_to_trio(sync_function=self._add_privacy_sandbox_enrollment_override_impl)(url=url)
+	
+	async def cancel_download(self, guid: str, browser_context_id: Optional[str] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._cancel_download_impl)(guid=guid, browser_context_id=browser_context_id)
+	
+	async def close(self) -> None:
+		return await self.sync_to_trio(sync_function=self._close_impl)()
+	
+	async def crash(self) -> None:
+		return await self.sync_to_trio(sync_function=self._crash_impl)()
+	
+	async def crash_gpu_process(self) -> None:
+		return await self.sync_to_trio(sync_function=self._crash_gpu_process_impl)()
+	
+	async def execute_browser_command(self, command_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._execute_browser_command_impl)(command_id=command_id)
+	
+	async def get_browser_command_line(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._get_browser_command_line_impl)()
+	
+	async def get_histogram(self, name: str, delta: Optional[bool] = None) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_histogram_impl)(name=name, delta=delta)
+	
+	async def get_histograms(self, query: Optional[str] = None, delta: Optional[bool] = None) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_histograms_impl)(query=query, delta=delta)
+	
+	async def get_version(self) -> Tuple[str, str, str, str, str]:
+		return await self.sync_to_trio(sync_function=self._get_version_impl)()
+	
+	async def get_window_bounds(self, window_id: int) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_window_bounds_impl)(window_id=window_id)
+	
+	async def get_window_for_target(self, target_id: Optional[str] = None) -> Tuple[int, Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_window_for_target_impl)(target_id=target_id)
+	
+	async def grant_permissions(
+			self,
+			permissions: List[str],
+			origin: Optional[str] = None,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._grant_permissions_impl)(
+				permissions=permissions,
+				origin=origin,
+				browser_context_id=browser_context_id
+		)
+	
+	async def reset_permissions(self, browser_context_id: Optional[str] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._reset_permissions_impl)(browser_context_id=browser_context_id)
+	
+	async def set_contents_size(
+			self,
+			window_id: int,
+			width: Optional[int] = None,
+			height: Optional[int] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_contents_size_impl)(window_id=window_id, width=width, height=height)
+	
+	async def set_dock_tile(self, badge_label: Optional[str] = None, image: Optional[str] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_dock_tile_impl)(badge_label=badge_label, image=image)
+	
+	async def set_download_behavior(
+			self,
+			behavior: str,
+			browser_context_id: Optional[str] = None,
+			download_path: Optional[str] = None,
+			events_enabled: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_download_behavior_impl)(
+				behavior=behavior,
+				browser_context_id=browser_context_id,
+				download_path=download_path,
+				events_enabled=events_enabled
+		)
+	
+	async def set_permission(
+			self,
+			permission: Dict[str, Any],
+			setting: str,
+			origin: Optional[str] = None,
+			embedded_origin: Optional[str] = None,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_permission_impl)(
+				permission=permission,
+				setting=setting,
+				origin=origin,
+				embedded_origin=embedded_origin,
+				browser_context_id=browser_context_id
+		)
+	
+	async def set_window_bounds(self, window_id: int, bounds: Dict[str, Any]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_window_bounds_impl)(window_id=window_id, bounds=bounds)

osn_selenium/executors/trio_threads/cdp/cache_storage.py

@@ -0,0 +1,79 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.cache_storage import (
+	UnifiedCacheStorageCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.cache_storage import (
+	AbstractCacheStorageCDPExecutor
+)
+
+
+__all__ = ["CacheStorageCDPExecutor"]
+
+
+class CacheStorageCDPExecutor(
+		UnifiedCacheStorageCDPExecutor,
+		TrioThreadMixin,
+		AbstractCacheStorageCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedCacheStorageCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def delete_cache(self, cache_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._delete_cache_impl)(cache_id=cache_id)
+	
+	async def delete_entry(self, cache_id: str, request: str) -> None:
+		return await self.sync_to_trio(sync_function=self._delete_entry_impl)(cache_id=cache_id, request=request)
+	
+	async def request_cache_names(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None
+	) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._request_cache_names_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket
+		)
+	
+	async def request_cached_response(
+			self,
+			cache_id: str,
+			request_url: str,
+			request_headers: List[Dict[str, Any]]
+	) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._request_cached_response_impl)(
+				cache_id=cache_id,
+				request_url=request_url,
+				request_headers=request_headers
+		)
+	
+	async def request_entries(
+			self,
+			cache_id: str,
+			skip_count: Optional[int] = None,
+			page_size: Optional[int] = None,
+			path_filter: Optional[str] = None
+	) -> Tuple[List[Dict[str, Any]], float]:
+		return await self.sync_to_trio(sync_function=self._request_entries_impl)(
+				cache_id=cache_id,
+				skip_count=skip_count,
+				page_size=page_size,
+				path_filter=path_filter
+		)

osn_selenium/executors/trio_threads/cdp/cast.py

@@ -0,0 +1,47 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.cast import (
+	UnifiedCastCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.cast import (
+	AbstractCastCDPExecutor
+)
+
+
+__all__ = ["CastCDPExecutor"]
+
+
+class CastCDPExecutor(UnifiedCastCDPExecutor, TrioThreadMixin, AbstractCastCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedCastCDPExecutor.__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, presentation_url: Optional[str] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._enable_impl)(presentation_url=presentation_url)
+	
+	async def set_sink_to_use(self, sink_name: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_sink_to_use_impl)(sink_name=sink_name)
+	
+	async def start_desktop_mirroring(self, sink_name: str) -> None:
+		return await self.sync_to_trio(sync_function=self._start_desktop_mirroring_impl)(sink_name=sink_name)
+	
+	async def start_tab_mirroring(self, sink_name: str) -> None:
+		return await self.sync_to_trio(sync_function=self._start_tab_mirroring_impl)(sink_name=sink_name)
+	
+	async def stop_casting(self, sink_name: str) -> None:
+		return await self.sync_to_trio(sync_function=self._stop_casting_impl)(sink_name=sink_name)