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

osn_selenium/executors/trio_threads/cdp/accessibility.py

@@ -1,87 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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)