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

osn_selenium/executors/trio_threads/cdp/runtime.py

@@ -1,230 +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.runtime import (
-	UnifiedRuntimeCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.runtime import (
-	AbstractRuntimeCDPExecutor
-)
-
-
-__all__ = ["RuntimeCDPExecutor"]
-
-
-class RuntimeCDPExecutor(UnifiedRuntimeCDPExecutor, TrioThreadMixin, AbstractRuntimeCDPExecutor):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedRuntimeCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def add_binding(
-			self,
-			name: str,
-			execution_context_id: Optional[int] = None,
-			execution_context_name: Optional[str] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._add_binding_impl)(
-				name=name,
-				execution_context_id=execution_context_id,
-				execution_context_name=execution_context_name
-		)
-	
-	async def await_promise(
-			self,
-			promise_object_id: str,
-			return_by_value: Optional[bool] = None,
-			generate_preview: Optional[bool] = None
-	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._await_promise_impl)(
-				promise_object_id=promise_object_id,
-				return_by_value=return_by_value,
-				generate_preview=generate_preview
-		)
-	
-	async def call_function_on(
-			self,
-			function_declaration: str,
-			object_id: Optional[str] = None,
-			arguments: Optional[List[Dict[str, Any]]] = None,
-			silent: Optional[bool] = None,
-			return_by_value: Optional[bool] = None,
-			generate_preview: Optional[bool] = None,
-			user_gesture: Optional[bool] = None,
-			await_promise: Optional[bool] = None,
-			execution_context_id: Optional[int] = None,
-			object_group: Optional[str] = None,
-			throw_on_side_effect: Optional[bool] = None,
-			unique_context_id: Optional[str] = None,
-			serialization_options: Optional[Dict[str, Any]] = None
-	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._call_function_on_impl)(
-				function_declaration=function_declaration,
-				object_id=object_id,
-				arguments=arguments,
-				silent=silent,
-				return_by_value=return_by_value,
-				generate_preview=generate_preview,
-				user_gesture=user_gesture,
-				await_promise=await_promise,
-				execution_context_id=execution_context_id,
-				object_group=object_group,
-				throw_on_side_effect=throw_on_side_effect,
-				unique_context_id=unique_context_id,
-				serialization_options=serialization_options
-		)
-	
-	async def compile_script(
-			self,
-			expression: str,
-			source_url: str,
-			persist_script: bool,
-			execution_context_id: Optional[int] = None
-	) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._compile_script_impl)(
-				expression=expression,
-				source_url=source_url,
-				persist_script=persist_script,
-				execution_context_id=execution_context_id
-		)
-	
-	async def disable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._disable_impl)()
-	
-	async def discard_console_entries(self) -> None:
-		return await self.sync_to_trio(sync_function=self._discard_console_entries_impl)()
-	
-	async def enable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._enable_impl)()
-	
-	async def evaluate(
-			self,
-			expression: str,
-			object_group: Optional[str] = None,
-			include_command_line_api: Optional[bool] = None,
-			silent: Optional[bool] = None,
-			context_id: Optional[int] = None,
-			return_by_value: Optional[bool] = None,
-			generate_preview: Optional[bool] = None,
-			user_gesture: Optional[bool] = None,
-			await_promise: Optional[bool] = None,
-			throw_on_side_effect: Optional[bool] = None,
-			timeout: Optional[float] = None,
-			disable_breaks: Optional[bool] = None,
-			repl_mode: Optional[bool] = None,
-			allow_unsafe_eval_blocked_by_csp: Optional[bool] = None,
-			unique_context_id: Optional[str] = None,
-			serialization_options: Optional[Dict[str, Any]] = None
-	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._evaluate_impl)(
-				expression=expression,
-				object_group=object_group,
-				include_command_line_api=include_command_line_api,
-				silent=silent,
-				context_id=context_id,
-				return_by_value=return_by_value,
-				generate_preview=generate_preview,
-				user_gesture=user_gesture,
-				await_promise=await_promise,
-				throw_on_side_effect=throw_on_side_effect,
-				timeout=timeout,
-				disable_breaks=disable_breaks,
-				repl_mode=repl_mode,
-				allow_unsafe_eval_blocked_by_csp=allow_unsafe_eval_blocked_by_csp,
-				unique_context_id=unique_context_id,
-				serialization_options=serialization_options
-		)
-	
-	async def get_exception_details(self, error_object_id: str) -> Optional[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_exception_details_impl)(error_object_id=error_object_id)
-	
-	async def get_heap_usage(self) -> Tuple[float, float, float, float]:
-		return await self.sync_to_trio(sync_function=self._get_heap_usage_impl)()
-	
-	async def get_isolate_id(self) -> str:
-		return await self.sync_to_trio(sync_function=self._get_isolate_id_impl)()
-	
-	async def get_properties(
-			self,
-			object_id: str,
-			own_properties: Optional[bool] = None,
-			accessor_properties_only: Optional[bool] = None,
-			generate_preview: Optional[bool] = None,
-			non_indexed_properties_only: Optional[bool] = None
-	) -> Tuple[
-		List[Dict[str, Any]],
-		Optional[List[Dict[str, Any]]],
-		Optional[List[Dict[str, Any]]],
-		Optional[Dict[str, Any]]
-	]:
-		return await self.sync_to_trio(sync_function=self._get_properties_impl)(
-				object_id=object_id,
-				own_properties=own_properties,
-				accessor_properties_only=accessor_properties_only,
-				generate_preview=generate_preview,
-				non_indexed_properties_only=non_indexed_properties_only
-		)
-	
-	async def global_lexical_scope_names(self, execution_context_id: Optional[int] = None) -> List[str]:
-		return await self.sync_to_trio(sync_function=self._global_lexical_scope_names_impl)(execution_context_id=execution_context_id)
-	
-	async def query_objects(self, prototype_object_id: str, object_group: Optional[str] = None) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._query_objects_impl)(prototype_object_id=prototype_object_id, object_group=object_group)
-	
-	async def release_object(self, object_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._release_object_impl)(object_id=object_id)
-	
-	async def release_object_group(self, object_group: str) -> None:
-		return await self.sync_to_trio(sync_function=self._release_object_group_impl)(object_group=object_group)
-	
-	async def remove_binding(self, name: str) -> None:
-		return await self.sync_to_trio(sync_function=self._remove_binding_impl)(name=name)
-	
-	async def run_if_waiting_for_debugger(self) -> None:
-		return await self.sync_to_trio(sync_function=self._run_if_waiting_for_debugger_impl)()
-	
-	async def run_script(
-			self,
-			script_id: str,
-			execution_context_id: Optional[int] = None,
-			object_group: Optional[str] = None,
-			silent: Optional[bool] = None,
-			include_command_line_api: Optional[bool] = None,
-			return_by_value: Optional[bool] = None,
-			generate_preview: Optional[bool] = None,
-			await_promise: Optional[bool] = None
-	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._run_script_impl)(
-				script_id=script_id,
-				execution_context_id=execution_context_id,
-				object_group=object_group,
-				silent=silent,
-				include_command_line_api=include_command_line_api,
-				return_by_value=return_by_value,
-				generate_preview=generate_preview,
-				await_promise=await_promise
-		)
-	
-	async def set_async_call_stack_depth(self, max_depth: int) -> None:
-		return await self.sync_to_trio(sync_function=self._set_async_call_stack_depth_impl)(max_depth=max_depth)
-	
-	async def set_custom_object_formatter_enabled(self, enabled: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_custom_object_formatter_enabled_impl)(enabled=enabled)
-	
-	async def set_max_call_stack_size_to_capture(self, size: int) -> None:
-		return await self.sync_to_trio(sync_function=self._set_max_call_stack_size_to_capture_impl)(size=size)
-	
-	async def terminate_execution(self) -> None:
-		return await self.sync_to_trio(sync_function=self._terminate_execution_impl)()

osn_selenium/executors/trio_threads/cdp/schema.py

@@ -1,32 +0,0 @@
-import trio
-from osn_selenium.base_mixin import TrioThreadMixin
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List
-)
-from osn_selenium.executors.unified.cdp.schema import (
-	UnifiedSchemaCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.schema import (
-	AbstractSchemaCDPExecutor
-)
-
-
-__all__ = ["SchemaCDPExecutor"]
-
-
-class SchemaCDPExecutor(UnifiedSchemaCDPExecutor, TrioThreadMixin, AbstractSchemaCDPExecutor):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedSchemaCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def get_domains(self) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_domains_impl)()

osn_selenium/executors/trio_threads/cdp/security.py

@@ -1,43 +0,0 @@
-import trio
-from typing import Any, Callable, Dict
-from osn_selenium.base_mixin import TrioThreadMixin
-from osn_selenium.executors.unified.cdp.security import (
-	UnifiedSecurityCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.security import (
-	AbstractSecurityCDPExecutor
-)
-
-
-__all__ = ["SecurityCDPExecutor"]
-
-
-class SecurityCDPExecutor(
-		UnifiedSecurityCDPExecutor,
-		TrioThreadMixin,
-		AbstractSecurityCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedSecurityCDPExecutor.__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 handle_certificate_error(self, event_id: int, action: str) -> None:
-		return await self.sync_to_trio(sync_function=self._handle_certificate_error_impl)(event_id=event_id, action=action)
-	
-	async def set_ignore_certificate_errors(self, ignore: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_ignore_certificate_errors_impl)(ignore=ignore)
-	
-	async def set_override_certificate_errors(self, override: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_override_certificate_errors_impl)(override=override)

osn_selenium/executors/trio_threads/cdp/service_worker.py

@@ -1,69 +0,0 @@
-import trio
-from typing import Any, Callable, Dict
-from osn_selenium.base_mixin import TrioThreadMixin
-from osn_selenium.executors.unified.cdp.service_worker import (
-	UnifiedServiceWorkerCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.service_worker import (
-	AbstractServiceWorkerCDPExecutor
-)
-
-
-__all__ = ["ServiceWorkerCDPExecutor"]
-
-
-class ServiceWorkerCDPExecutor(
-		UnifiedServiceWorkerCDPExecutor,
-		TrioThreadMixin,
-		AbstractServiceWorkerCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedServiceWorkerCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def deliver_push_message(self, origin: str, registration_id: str, data: str) -> None:
-		return await self.sync_to_trio(sync_function=self._deliver_push_message_impl)(origin=origin, registration_id=registration_id, data=data)
-	
-	async def disable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._disable_impl)()
-	
-	async def dispatch_periodic_sync_event(self, origin: str, registration_id: str, tag: str) -> None:
-		return await self.sync_to_trio(sync_function=self._dispatch_periodic_sync_event_impl)(origin=origin, registration_id=registration_id, tag=tag)
-	
-	async def dispatch_sync_event(self, origin: str, registration_id: str, tag: str, last_chance: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._dispatch_sync_event_impl)(
-				origin=origin,
-				registration_id=registration_id,
-				tag=tag,
-				last_chance=last_chance
-		)
-	
-	async def enable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._enable_impl)()
-	
-	async def set_force_update_on_page_load(self, force_update_on_page_load: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_force_update_on_page_load_impl)(force_update_on_page_load=force_update_on_page_load)
-	
-	async def skip_waiting(self, scope_url: str) -> None:
-		return await self.sync_to_trio(sync_function=self._skip_waiting_impl)(scope_url=scope_url)
-	
-	async def start_worker(self, scope_url: str) -> None:
-		return await self.sync_to_trio(sync_function=self._start_worker_impl)(scope_url=scope_url)
-	
-	async def stop_all_workers(self) -> None:
-		return await self.sync_to_trio(sync_function=self._stop_all_workers_impl)()
-	
-	async def stop_worker(self, version_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._stop_worker_impl)(version_id=version_id)
-	
-	async def unregister(self, scope_url: str) -> None:
-		return await self.sync_to_trio(sync_function=self._unregister_impl)(scope_url=scope_url)
-	
-	async def update_registration(self, scope_url: str) -> None:
-		return await self.sync_to_trio(sync_function=self._update_registration_impl)(scope_url=scope_url)

osn_selenium/executors/trio_threads/cdp/storage.py

@@ -1,162 +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.storage import (
-	UnifiedStorageCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.storage import (
-	AbstractStorageCDPExecutor
-)
-
-
-__all__ = ["StorageCDPExecutor"]
-
-
-class StorageCDPExecutor(UnifiedStorageCDPExecutor, TrioThreadMixin, AbstractStorageCDPExecutor):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedStorageCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def clear_cookies(self, browser_context_id: Optional[str] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._clear_cookies_impl)(browser_context_id=browser_context_id)
-	
-	async def clear_data_for_origin(self, origin: str, storage_types: str) -> None:
-		return await self.sync_to_trio(sync_function=self._clear_data_for_origin_impl)(origin=origin, storage_types=storage_types)
-	
-	async def clear_data_for_storage_key(self, storage_key: str, storage_types: str) -> None:
-		return await self.sync_to_trio(sync_function=self._clear_data_for_storage_key_impl)(storage_key=storage_key, storage_types=storage_types)
-	
-	async def clear_shared_storage_entries(self, owner_origin: str) -> None:
-		return await self.sync_to_trio(sync_function=self._clear_shared_storage_entries_impl)(owner_origin=owner_origin)
-	
-	async def clear_trust_tokens(self, issuer_origin: str) -> bool:
-		return await self.sync_to_trio(sync_function=self._clear_trust_tokens_impl)(issuer_origin=issuer_origin)
-	
-	async def delete_shared_storage_entry(self, owner_origin: str, key: str) -> None:
-		return await self.sync_to_trio(sync_function=self._delete_shared_storage_entry_impl)(owner_origin=owner_origin, key=key)
-	
-	async def delete_storage_bucket(self, bucket: Dict[str, Any]) -> None:
-		return await self.sync_to_trio(sync_function=self._delete_storage_bucket_impl)(bucket=bucket)
-	
-	async def get_affected_urls_for_third_party_cookie_metadata(self, first_party_url: str, third_party_urls: List[str]) -> List[str]:
-		return await self.sync_to_trio(
-				sync_function=self._get_affected_urls_for_third_party_cookie_metadata_impl
-		)(first_party_url=first_party_url, third_party_urls=third_party_urls)
-	
-	async def get_cookies(self, browser_context_id: Optional[str] = None) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_cookies_impl)(browser_context_id=browser_context_id)
-	
-	async def get_interest_group_details(self, owner_origin: str, name: str) -> Any:
-		return await self.sync_to_trio(sync_function=self._get_interest_group_details_impl)(owner_origin=owner_origin, name=name)
-	
-	async def get_related_website_sets(self) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_related_website_sets_impl)()
-	
-	async def get_shared_storage_entries(self, owner_origin: str) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_shared_storage_entries_impl)(owner_origin=owner_origin)
-	
-	async def get_shared_storage_metadata(self, owner_origin: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._get_shared_storage_metadata_impl)(owner_origin=owner_origin)
-	
-	async def get_storage_key(self, frame_id: Optional[str] = None) -> str:
-		return await self.sync_to_trio(sync_function=self._get_storage_key_impl)(frame_id=frame_id)
-	
-	async def get_storage_key_for_frame(self, frame_id: str) -> str:
-		return await self.sync_to_trio(sync_function=self._get_storage_key_for_frame_impl)(frame_id=frame_id)
-	
-	async def get_trust_tokens(self) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_trust_tokens_impl)()
-	
-	async def get_usage_and_quota(self, origin: str) -> Tuple[float, float, bool, List[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._get_usage_and_quota_impl)(origin=origin)
-	
-	async def override_quota_for_origin(self, origin: str, quota_size: Optional[float] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._override_quota_for_origin_impl)(origin=origin, quota_size=quota_size)
-	
-	async def reset_shared_storage_budget(self, owner_origin: str) -> None:
-		return await self.sync_to_trio(sync_function=self._reset_shared_storage_budget_impl)(owner_origin=owner_origin)
-	
-	async def run_bounce_tracking_mitigations(self) -> List[str]:
-		return await self.sync_to_trio(sync_function=self._run_bounce_tracking_mitigations_impl)()
-	
-	async def send_pending_attribution_reports(self) -> int:
-		return await self.sync_to_trio(sync_function=self._send_pending_attribution_reports_impl)()
-	
-	async def set_attribution_reporting_local_testing_mode(self, enabled: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_attribution_reporting_local_testing_mode_impl)(enabled=enabled)
-	
-	async def set_attribution_reporting_tracking(self, enable: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_attribution_reporting_tracking_impl)(enable=enable)
-	
-	async def set_cookies(
-			self,
-			cookies: List[Dict[str, Any]],
-			browser_context_id: Optional[str] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._set_cookies_impl)(cookies=cookies, browser_context_id=browser_context_id)
-	
-	async def set_interest_group_auction_tracking(self, enable: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_interest_group_auction_tracking_impl)(enable=enable)
-	
-	async def set_interest_group_tracking(self, enable: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_interest_group_tracking_impl)(enable=enable)
-	
-	async def set_protected_audience_k_anonymity(self, owner: str, name: str, hashes: List[str]) -> None:
-		return await self.sync_to_trio(sync_function=self._set_protected_audience_k_anonymity_impl)(owner=owner, name=name, hashes=hashes)
-	
-	async def set_shared_storage_entry(
-			self,
-			owner_origin: str,
-			key: str,
-			value: str,
-			ignore_if_present: Optional[bool] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._set_shared_storage_entry_impl)(
-				owner_origin=owner_origin,
-				key=key,
-				value=value,
-				ignore_if_present=ignore_if_present
-		)
-	
-	async def set_shared_storage_tracking(self, enable: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_shared_storage_tracking_impl)(enable=enable)
-	
-	async def set_storage_bucket_tracking(self, storage_key: str, enable: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_storage_bucket_tracking_impl)(storage_key=storage_key, enable=enable)
-	
-	async def track_cache_storage_for_origin(self, origin: str) -> None:
-		return await self.sync_to_trio(sync_function=self._track_cache_storage_for_origin_impl)(origin=origin)
-	
-	async def track_cache_storage_for_storage_key(self, storage_key: str) -> None:
-		return await self.sync_to_trio(sync_function=self._track_cache_storage_for_storage_key_impl)(storage_key=storage_key)
-	
-	async def track_indexed_db_for_origin(self, origin: str) -> None:
-		return await self.sync_to_trio(sync_function=self._track_indexed_db_for_origin_impl)(origin=origin)
-	
-	async def track_indexed_db_for_storage_key(self, storage_key: str) -> None:
-		return await self.sync_to_trio(sync_function=self._track_indexed_db_for_storage_key_impl)(storage_key=storage_key)
-	
-	async def untrack_cache_storage_for_origin(self, origin: str) -> None:
-		return await self.sync_to_trio(sync_function=self._untrack_cache_storage_for_origin_impl)(origin=origin)
-	
-	async def untrack_cache_storage_for_storage_key(self, storage_key: str) -> None:
-		return await self.sync_to_trio(sync_function=self._untrack_cache_storage_for_storage_key_impl)(storage_key=storage_key)
-	
-	async def untrack_indexed_db_for_origin(self, origin: str) -> None:
-		return await self.sync_to_trio(sync_function=self._untrack_indexed_db_for_origin_impl)(origin=origin)
-	
-	async def untrack_indexed_db_for_storage_key(self, storage_key: str) -> None:
-		return await self.sync_to_trio(sync_function=self._untrack_indexed_db_for_storage_key_impl)(storage_key=storage_key)

osn_selenium/executors/trio_threads/cdp/system_info.py

@@ -1,43 +0,0 @@
-import trio
-from osn_selenium.base_mixin import TrioThreadMixin
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Tuple
-)
-from osn_selenium.executors.unified.cdp.system_info import (
-	UnifiedSystemInfoCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.system_info import (
-	AbstractSystemInfoCDPExecutor
-)
-
-
-__all__ = ["SystemInfoCDPExecutor"]
-
-
-class SystemInfoCDPExecutor(
-		UnifiedSystemInfoCDPExecutor,
-		TrioThreadMixin,
-		AbstractSystemInfoCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedSystemInfoCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def get_feature_state(self, feature_state: str) -> bool:
-		return await self.sync_to_trio(sync_function=self._get_feature_state_impl)(feature_state=feature_state)
-	
-	async def get_info(self) -> Tuple[Dict[str, Any], str, str, str]:
-		return await self.sync_to_trio(sync_function=self._get_info_impl)()
-	
-	async def get_process_info(self) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_process_info_impl)()