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

osn_selenium/executors/sync/cdp/runtime.py

@@ -0,0 +1,221 @@
+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, AbstractRuntimeCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedRuntimeCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def add_binding(
+			self,
+			name: str,
+			execution_context_id: Optional[int] = None,
+			execution_context_name: Optional[str] = None
+	) -> None:
+		return self._add_binding_impl(
+				name=name,
+				execution_context_id=execution_context_id,
+				execution_context_name=execution_context_name
+		)
+	
+	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 self._await_promise_impl(
+				promise_object_id=promise_object_id,
+				return_by_value=return_by_value,
+				generate_preview=generate_preview
+		)
+	
+	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 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
+		)
+	
+	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 self._compile_script_impl(
+				expression=expression,
+				source_url=source_url,
+				persist_script=persist_script,
+				execution_context_id=execution_context_id
+		)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def discard_console_entries(self) -> None:
+		return self._discard_console_entries_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	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 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
+		)
+	
+	def get_exception_details(self, error_object_id: str) -> Optional[Dict[str, Any]]:
+		return self._get_exception_details_impl(error_object_id=error_object_id)
+	
+	def get_heap_usage(self) -> Tuple[float, float, float, float]:
+		return self._get_heap_usage_impl()
+	
+	def get_isolate_id(self) -> str:
+		return self._get_isolate_id_impl()
+	
+	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 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
+		)
+	
+	def global_lexical_scope_names(self, execution_context_id: Optional[int] = None) -> List[str]:
+		return self._global_lexical_scope_names_impl(execution_context_id=execution_context_id)
+	
+	def query_objects(self, prototype_object_id: str, object_group: Optional[str] = None) -> Dict[str, Any]:
+		return self._query_objects_impl(prototype_object_id=prototype_object_id, object_group=object_group)
+	
+	def release_object(self, object_id: str) -> None:
+		return self._release_object_impl(object_id=object_id)
+	
+	def release_object_group(self, object_group: str) -> None:
+		return self._release_object_group_impl(object_group=object_group)
+	
+	def remove_binding(self, name: str) -> None:
+		return self._remove_binding_impl(name=name)
+	
+	def run_if_waiting_for_debugger(self) -> None:
+		return self._run_if_waiting_for_debugger_impl()
+	
+	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 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
+		)
+	
+	def set_async_call_stack_depth(self, max_depth: int) -> None:
+		return self._set_async_call_stack_depth_impl(max_depth=max_depth)
+	
+	def set_custom_object_formatter_enabled(self, enabled: bool) -> None:
+		return self._set_custom_object_formatter_enabled_impl(enabled=enabled)
+	
+	def set_max_call_stack_size_to_capture(self, size: int) -> None:
+		return self._set_max_call_stack_size_to_capture_impl(size=size)
+	
+	def terminate_execution(self) -> None:
+		return self._terminate_execution_impl()

osn_selenium/executors/sync/cdp/schema.py

@@ -0,0 +1,23 @@
+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, AbstractSchemaCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedSchemaCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def get_domains(self) -> List[Dict[str, Any]]:
+		return self._get_domains_impl()

osn_selenium/executors/sync/cdp/security.py

@@ -0,0 +1,30 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.security import (
+	UnifiedSecurityCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.security import (
+	AbstractSecurityCDPExecutor
+)
+
+
+__all__ = ["SecurityCDPExecutor"]
+
+
+class SecurityCDPExecutor(UnifiedSecurityCDPExecutor, AbstractSecurityCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedSecurityCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def handle_certificate_error(self, event_id: int, action: str) -> None:
+		return self._handle_certificate_error_impl(event_id=event_id, action=action)
+	
+	def set_ignore_certificate_errors(self, ignore: bool) -> None:
+		return self._set_ignore_certificate_errors_impl(ignore=ignore)
+	
+	def set_override_certificate_errors(self, override: bool) -> None:
+		return self._set_override_certificate_errors_impl(override=override)

osn_selenium/executors/sync/cdp/service_worker.py

@@ -0,0 +1,56 @@
+from typing import Any, Callable, Dict
+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, AbstractServiceWorkerCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedServiceWorkerCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def deliver_push_message(self, origin: str, registration_id: str, data: str) -> None:
+		return self._deliver_push_message_impl(origin=origin, registration_id=registration_id, data=data)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def dispatch_periodic_sync_event(self, origin: str, registration_id: str, tag: str) -> None:
+		return self._dispatch_periodic_sync_event_impl(origin=origin, registration_id=registration_id, tag=tag)
+	
+	def dispatch_sync_event(self, origin: str, registration_id: str, tag: str, last_chance: bool) -> None:
+		return self._dispatch_sync_event_impl(
+				origin=origin,
+				registration_id=registration_id,
+				tag=tag,
+				last_chance=last_chance
+		)
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def set_force_update_on_page_load(self, force_update_on_page_load: bool) -> None:
+		return self._set_force_update_on_page_load_impl(force_update_on_page_load=force_update_on_page_load)
+	
+	def skip_waiting(self, scope_url: str) -> None:
+		return self._skip_waiting_impl(scope_url=scope_url)
+	
+	def start_worker(self, scope_url: str) -> None:
+		return self._start_worker_impl(scope_url=scope_url)
+	
+	def stop_all_workers(self) -> None:
+		return self._stop_all_workers_impl()
+	
+	def stop_worker(self, version_id: str) -> None:
+		return self._stop_worker_impl(version_id=version_id)
+	
+	def unregister(self, scope_url: str) -> None:
+		return self._unregister_impl(scope_url=scope_url)
+	
+	def update_registration(self, scope_url: str) -> None:
+		return self._update_registration_impl(scope_url=scope_url)

osn_selenium/executors/sync/cdp/storage.py

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

osn_selenium/executors/sync/cdp/system_info.py

@@ -0,0 +1,30 @@
+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, AbstractSystemInfoCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedSystemInfoCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def get_feature_state(self, feature_state: str) -> bool:
+		return self._get_feature_state_impl(feature_state=feature_state)
+	
+	def get_info(self) -> Tuple[Dict[str, Any], str, str, str]:
+		return self._get_info_impl()
+	
+	def get_process_info(self) -> List[Dict[str, Any]]:
+		return self._get_process_info_impl()

osn_selenium/executors/sync/cdp/target.py

@@ -0,0 +1,147 @@
+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, AbstractTargetCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedTargetCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def activate_target(self, target_id: str) -> None:
+		return self._activate_target_impl(target_id=target_id)
+	
+	def attach_to_browser_target(self) -> str:
+		return self._attach_to_browser_target_impl()
+	
+	def attach_to_target(self, target_id: str, flatten: Optional[bool] = None) -> str:
+		return self._attach_to_target_impl(target_id=target_id, flatten=flatten)
+	
+	def auto_attach_related(
+			self,
+			target_id: str,
+			wait_for_debugger_on_start: bool,
+			filter_: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return self._auto_attach_related_impl(
+				target_id=target_id,
+				wait_for_debugger_on_start=wait_for_debugger_on_start,
+				filter_=filter_
+		)
+	
+	def close_target(self, target_id: str) -> bool:
+		return self._close_target_impl(target_id=target_id)
+	
+	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 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
+		)
+	
+	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 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
+		)
+	
+	def detach_from_target(self, session_id: Optional[str] = None, target_id: Optional[str] = None) -> None:
+		return self._detach_from_target_impl(session_id=session_id, target_id=target_id)
+	
+	def dispose_browser_context(self, browser_context_id: str) -> None:
+		return self._dispose_browser_context_impl(browser_context_id=browser_context_id)
+	
+	def expose_dev_tools_protocol(
+			self,
+			target_id: str,
+			binding_name: Optional[str] = None,
+			inherit_permissions: Optional[bool] = None
+	) -> None:
+		return self._expose_dev_tools_protocol_impl(
+				target_id=target_id,
+				binding_name=binding_name,
+				inherit_permissions=inherit_permissions
+		)
+	
+	def get_browser_contexts(self) -> List[str]:
+		return self._get_browser_contexts_impl()
+	
+	def get_target_info(self, target_id: Optional[str] = None) -> Dict[str, Any]:
+		return self._get_target_info_impl(target_id=target_id)
+	
+	def get_targets(self, filter_: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]:
+		return self._get_targets_impl(filter_=filter_)
+	
+	def open_dev_tools(self, target_id: str) -> str:
+		return self._open_dev_tools_impl(target_id=target_id)
+	
+	def send_message_to_target(
+			self,
+			message: str,
+			session_id: Optional[str] = None,
+			target_id: Optional[str] = None
+	) -> None:
+		return self._send_message_to_target_impl(message=message, session_id=session_id, target_id=target_id)
+	
+	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 self._set_auto_attach_impl(
+				auto_attach=auto_attach,
+				wait_for_debugger_on_start=wait_for_debugger_on_start,
+				flatten=flatten,
+				filter_=filter_
+		)
+	
+	def set_discover_targets(self, discover: bool, filter_: Optional[List[Dict[str, Any]]] = None) -> None:
+		return self._set_discover_targets_impl(discover=discover, filter_=filter_)
+	
+	def set_remote_locations(self, locations: List[Dict[str, Any]]) -> None:
+		return self._set_remote_locations_impl(locations=locations)

osn_selenium/executors/sync/cdp/tethering.py

@@ -0,0 +1,21 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.tethering import (
+	UnifiedTetheringCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.tethering import (
+	AbstractTetheringCDPExecutor
+)
+
+
+__all__ = ["TetheringCDPExecutor"]
+
+
+class TetheringCDPExecutor(UnifiedTetheringCDPExecutor, AbstractTetheringCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedTetheringCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def bind(self, port: int) -> None:
+		return self._bind_impl(port=port)
+	
+	def unbind(self, port: int) -> None:
+		return self._unbind_impl(port=port)