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

osn_selenium/executors/trio_threads/cdp/emulation.py

@@ -0,0 +1,283 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.emulation import (
+	UnifiedEmulationCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.emulation import (
+	AbstractEmulationCDPExecutor
+)
+
+
+__all__ = ["EmulationCDPExecutor"]
+
+
+class EmulationCDPExecutor(
+		UnifiedEmulationCDPExecutor,
+		TrioThreadMixin,
+		AbstractEmulationCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedEmulationCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def add_screen(
+			self,
+			left: int,
+			top: int,
+			width: int,
+			height: int,
+			work_area_insets: Optional[Dict[str, Any]] = None,
+			device_pixel_ratio: Optional[float] = None,
+			rotation: Optional[int] = None,
+			color_depth: Optional[int] = None,
+			label: Optional[str] = None,
+			is_internal: Optional[bool] = None
+	) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._add_screen_impl)(
+				left=left,
+				top=top,
+				width=width,
+				height=height,
+				work_area_insets=work_area_insets,
+				device_pixel_ratio=device_pixel_ratio,
+				rotation=rotation,
+				color_depth=color_depth,
+				label=label,
+				is_internal=is_internal
+		)
+	
+	async def can_emulate(self) -> bool:
+		return await self.sync_to_trio(sync_function=self._can_emulate_impl)()
+	
+	async def clear_device_metrics_override(self) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_device_metrics_override_impl)()
+	
+	async def clear_device_posture_override(self) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_device_posture_override_impl)()
+	
+	async def clear_display_features_override(self) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_display_features_override_impl)()
+	
+	async def clear_geolocation_override(self) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_geolocation_override_impl)()
+	
+	async def clear_idle_override(self) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_idle_override_impl)()
+	
+	async def get_overridden_sensor_information(self, type_: str) -> float:
+		return await self.sync_to_trio(sync_function=self._get_overridden_sensor_information_impl)(type_=type_)
+	
+	async def get_screen_infos(self) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_screen_infos_impl)()
+	
+	async def remove_screen(self, screen_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_screen_impl)(screen_id=screen_id)
+	
+	async def reset_page_scale_factor(self) -> None:
+		return await self.sync_to_trio(sync_function=self._reset_page_scale_factor_impl)()
+	
+	async def set_auto_dark_mode_override(self, enabled: Optional[bool] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_auto_dark_mode_override_impl)(enabled=enabled)
+	
+	async def set_automation_override(self, enabled: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_automation_override_impl)(enabled=enabled)
+	
+	async def set_cpu_throttling_rate(self, rate: float) -> None:
+		return await self.sync_to_trio(sync_function=self._set_cpu_throttling_rate_impl)(rate=rate)
+	
+	async def set_data_saver_override(self, data_saver_enabled: Optional[bool] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_data_saver_override_impl)(data_saver_enabled=data_saver_enabled)
+	
+	async def set_default_background_color_override(self, color: Optional[Dict[str, Any]] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_default_background_color_override_impl)(color=color)
+	
+	async def set_device_metrics_override(
+			self,
+			width: int,
+			height: int,
+			device_scale_factor: float,
+			mobile: bool,
+			scale: Optional[float] = None,
+			screen_width: Optional[int] = None,
+			screen_height: Optional[int] = None,
+			position_x: Optional[int] = None,
+			position_y: Optional[int] = None,
+			dont_set_visible_size: Optional[bool] = None,
+			screen_orientation: Optional[Dict[str, Any]] = None,
+			viewport: Optional[Dict[str, Any]] = None,
+			display_feature: Optional[Dict[str, Any]] = None,
+			device_posture: Optional[Dict[str, Any]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_device_metrics_override_impl)(
+				width=width,
+				height=height,
+				device_scale_factor=device_scale_factor,
+				mobile=mobile,
+				scale=scale,
+				screen_width=screen_width,
+				screen_height=screen_height,
+				position_x=position_x,
+				position_y=position_y,
+				dont_set_visible_size=dont_set_visible_size,
+				screen_orientation=screen_orientation,
+				viewport=viewport,
+				display_feature=display_feature,
+				device_posture=device_posture
+		)
+	
+	async def set_device_posture_override(self, posture: Dict[str, Any]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_device_posture_override_impl)(posture=posture)
+	
+	async def set_disabled_image_types(self, image_types: List[str]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_disabled_image_types_impl)(image_types=image_types)
+	
+	async def set_display_features_override(self, features: List[Dict[str, Any]]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_display_features_override_impl)(features=features)
+	
+	async def set_document_cookie_disabled(self, disabled: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_document_cookie_disabled_impl)(disabled=disabled)
+	
+	async def set_emit_touch_events_for_mouse(self, enabled: bool, configuration: Optional[str] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_emit_touch_events_for_mouse_impl)(enabled=enabled, configuration=configuration)
+	
+	async def set_emulated_media(
+			self,
+			media: Optional[str] = None,
+			features: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_emulated_media_impl)(media=media, features=features)
+	
+	async def set_emulated_os_text_scale(self, scale: Optional[float] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_emulated_os_text_scale_impl)(scale=scale)
+	
+	async def set_emulated_vision_deficiency(self, type_: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_emulated_vision_deficiency_impl)(type_=type_)
+	
+	async def set_focus_emulation_enabled(self, enabled: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_focus_emulation_enabled_impl)(enabled=enabled)
+	
+	async def set_geolocation_override(
+			self,
+			latitude: Optional[float] = None,
+			longitude: Optional[float] = None,
+			accuracy: Optional[float] = None,
+			altitude: Optional[float] = None,
+			altitude_accuracy: Optional[float] = None,
+			heading: Optional[float] = None,
+			speed: Optional[float] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_geolocation_override_impl)(
+				latitude=latitude,
+				longitude=longitude,
+				accuracy=accuracy,
+				altitude=altitude,
+				altitude_accuracy=altitude_accuracy,
+				heading=heading,
+				speed=speed
+		)
+	
+	async def set_hardware_concurrency_override(self, hardware_concurrency: int) -> None:
+		return await self.sync_to_trio(sync_function=self._set_hardware_concurrency_override_impl)(hardware_concurrency=hardware_concurrency)
+	
+	async def set_idle_override(self, is_user_active: bool, is_screen_unlocked: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_idle_override_impl)(is_user_active=is_user_active, is_screen_unlocked=is_screen_unlocked)
+	
+	async def set_locale_override(self, locale: Optional[str] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_locale_override_impl)(locale=locale)
+	
+	async def set_navigator_overrides(self, platform: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_navigator_overrides_impl)(platform=platform)
+	
+	async def set_page_scale_factor(self, page_scale_factor: float) -> None:
+		return await self.sync_to_trio(sync_function=self._set_page_scale_factor_impl)(page_scale_factor=page_scale_factor)
+	
+	async def set_pressure_data_override(
+			self,
+			source: str,
+			state: str,
+			own_contribution_estimate: Optional[float] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_pressure_data_override_impl)(
+				source=source,
+				state=state,
+				own_contribution_estimate=own_contribution_estimate
+		)
+	
+	async def set_pressure_source_override_enabled(
+			self,
+			enabled: bool,
+			source: str,
+			metadata: Optional[Dict[str, Any]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_pressure_source_override_enabled_impl)(enabled=enabled, source=source, metadata=metadata)
+	
+	async def set_pressure_state_override(self, source: str, state: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_pressure_state_override_impl)(source=source, state=state)
+	
+	async def set_safe_area_insets_override(self, insets: Dict[str, Any]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_safe_area_insets_override_impl)(insets=insets)
+	
+	async def set_script_execution_disabled(self, value: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_script_execution_disabled_impl)(value=value)
+	
+	async def set_scrollbars_hidden(self, hidden: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_scrollbars_hidden_impl)(hidden=hidden)
+	
+	async def set_sensor_override_enabled(self, enabled: bool, type_: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_sensor_override_enabled_impl)(enabled=enabled, type_=type_, metadata=metadata)
+	
+	async def set_sensor_override_readings(self, type_: str, reading: Dict[str, Any]) -> None:
+		return await self.sync_to_trio(sync_function=self._set_sensor_override_readings_impl)(type_=type_, reading=reading)
+	
+	async def set_small_viewport_height_difference_override(self, difference: int) -> None:
+		return await self.sync_to_trio(sync_function=self._set_small_viewport_height_difference_override_impl)(difference=difference)
+	
+	async def set_timezone_override(self, timezone_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_timezone_override_impl)(timezone_id=timezone_id)
+	
+	async def set_touch_emulation_enabled(self, enabled: bool, max_touch_points: Optional[int] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._set_touch_emulation_enabled_impl)(enabled=enabled, max_touch_points=max_touch_points)
+	
+	async def set_user_agent_override(
+			self,
+			user_agent: str,
+			accept_language: Optional[str] = None,
+			platform: Optional[str] = None,
+			user_agent_metadata: Optional[Dict[str, Any]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._set_user_agent_override_impl)(
+				user_agent=user_agent,
+				accept_language=accept_language,
+				platform=platform,
+				user_agent_metadata=user_agent_metadata
+		)
+	
+	async def set_virtual_time_policy(
+			self,
+			policy: str,
+			budget: Optional[float] = None,
+			max_virtual_time_task_starvation_count: Optional[int] = None,
+			initial_virtual_time: Optional[float] = None
+	) -> float:
+		return await self.sync_to_trio(sync_function=self._set_virtual_time_policy_impl)(
+				policy=policy,
+				budget=budget,
+				max_virtual_time_task_starvation_count=max_virtual_time_task_starvation_count,
+				initial_virtual_time=initial_virtual_time
+		)
+	
+	async def set_visible_size(self, width: int, height: int) -> None:
+		return await self.sync_to_trio(sync_function=self._set_visible_size_impl)(width=width, height=height)

osn_selenium/executors/trio_threads/cdp/event_breakpoints.py

@@ -0,0 +1,37 @@
+import trio
+from typing import Any, Callable, Dict
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.executors.unified.cdp.event_breakpoints import (
+	UnifiedEventBreakpointsCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.event_breakpoints import (
+	AbstractEventBreakpointsCDPExecutor
+)
+
+
+__all__ = ["EventBreakpointsCDPExecutor"]
+
+
+class EventBreakpointsCDPExecutor(
+		UnifiedEventBreakpointsCDPExecutor,
+		TrioThreadMixin,
+		AbstractEventBreakpointsCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedEventBreakpointsCDPExecutor.__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 remove_instrumentation_breakpoint(self, event_name: str) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_instrumentation_breakpoint_impl)(event_name=event_name)
+	
+	async def set_instrumentation_breakpoint(self, event_name: str) -> None:
+		return await self.sync_to_trio(sync_function=self._set_instrumentation_breakpoint_impl)(event_name=event_name)

osn_selenium/executors/trio_threads/cdp/extensions.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.extensions import (
+	UnifiedExtensionsCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.extensions import (
+	AbstractExtensionsCDPExecutor
+)
+
+
+__all__ = ["ExtensionsCDPExecutor"]
+
+
+class ExtensionsCDPExecutor(
+		UnifiedExtensionsCDPExecutor,
+		TrioThreadMixin,
+		AbstractExtensionsCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedExtensionsCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def clear_storage_items(self, id_: str, storage_area: str) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_storage_items_impl)(id_=id_, storage_area=storage_area)
+	
+	async def get_storage_items(self, id_: str, storage_area: str, keys: Optional[List[str]] = None) -> Any:
+		return await self.sync_to_trio(sync_function=self._get_storage_items_impl)(id_=id_, storage_area=storage_area, keys=keys)
+	
+	async def load_unpacked(self, path: str) -> str:
+		return await self.sync_to_trio(sync_function=self._load_unpacked_impl)(path=path)
+	
+	async def remove_storage_items(self, id_: str, storage_area: str, keys: List[str]) -> None:
+		return await self.sync_to_trio(sync_function=self._remove_storage_items_impl)(id_=id_, storage_area=storage_area, keys=keys)
+	
+	async def set_storage_items(self, id_: str, storage_area: str, values: Any) -> None:
+		return await self.sync_to_trio(sync_function=self._set_storage_items_impl)(id_=id_, storage_area=storage_area, values=values)
+	
+	async def uninstall(self, id_: str) -> None:
+		return await self.sync_to_trio(sync_function=self._uninstall_impl)(id_=id_)

osn_selenium/executors/trio_threads/cdp/fed_cm.py

@@ -0,0 +1,54 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.fed_cm import (
+	UnifiedFedCmCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.fed_cm import (
+	AbstractFedCmCDPExecutor
+)
+
+
+__all__ = ["FedCmCDPExecutor"]
+
+
+class FedCmCDPExecutor(UnifiedFedCmCDPExecutor, TrioThreadMixin, AbstractFedCmCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedFedCmCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def click_dialog_button(self, dialog_id: str, dialog_button: str) -> None:
+		return await self.sync_to_trio(sync_function=self._click_dialog_button_impl)(dialog_id=dialog_id, dialog_button=dialog_button)
+	
+	async def disable(self) -> None:
+		return await self.sync_to_trio(sync_function=self._disable_impl)()
+	
+	async def dismiss_dialog(self, dialog_id: str, trigger_cooldown: Optional[bool] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._dismiss_dialog_impl)(dialog_id=dialog_id, trigger_cooldown=trigger_cooldown)
+	
+	async def enable(self, disable_rejection_delay: Optional[bool] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._enable_impl)(disable_rejection_delay=disable_rejection_delay)
+	
+	async def open_url(self, dialog_id: str, account_index: int, account_url_type: str) -> None:
+		return await self.sync_to_trio(sync_function=self._open_url_impl)(
+				dialog_id=dialog_id,
+				account_index=account_index,
+				account_url_type=account_url_type
+		)
+	
+	async def reset_cooldown(self) -> None:
+		return await self.sync_to_trio(sync_function=self._reset_cooldown_impl)()
+	
+	async def select_account(self, dialog_id: str, account_index: int) -> None:
+		return await self.sync_to_trio(sync_function=self._select_account_impl)(dialog_id=dialog_id, account_index=account_index)

osn_selenium/executors/trio_threads/cdp/fetch.py

@@ -0,0 +1,105 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.fetch import (
+	UnifiedFetchCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.fetch import (
+	AbstractFetchCDPExecutor
+)
+
+
+__all__ = ["FetchCDPExecutor"]
+
+
+class FetchCDPExecutor(UnifiedFetchCDPExecutor, TrioThreadMixin, AbstractFetchCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedFetchCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def continue_request(
+			self,
+			request_id: str,
+			url: Optional[str] = None,
+			method: Optional[str] = None,
+			post_data: Optional[str] = None,
+			headers: Optional[List[Dict[str, Any]]] = None,
+			intercept_response: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._continue_request_impl)(
+				request_id=request_id,
+				url=url,
+				method=method,
+				post_data=post_data,
+				headers=headers,
+				intercept_response=intercept_response
+		)
+	
+	async def continue_response(
+			self,
+			request_id: str,
+			response_code: Optional[int] = None,
+			response_phrase: Optional[str] = None,
+			response_headers: Optional[List[Dict[str, Any]]] = None,
+			binary_response_headers: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._continue_response_impl)(
+				request_id=request_id,
+				response_code=response_code,
+				response_phrase=response_phrase,
+				response_headers=response_headers,
+				binary_response_headers=binary_response_headers
+		)
+	
+	async def continue_with_auth(self, request_id: str, auth_challenge_response: Dict[str, Any]) -> None:
+		return await self.sync_to_trio(sync_function=self._continue_with_auth_impl)(request_id=request_id, auth_challenge_response=auth_challenge_response)
+	
+	async def disable(self) -> None:
+		return await self.sync_to_trio(sync_function=self._disable_impl)()
+	
+	async def enable(
+			self,
+			patterns: Optional[List[Dict[str, Any]]] = None,
+			handle_auth_requests: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._enable_impl)(patterns=patterns, handle_auth_requests=handle_auth_requests)
+	
+	async def fail_request(self, request_id: str, error_reason: str) -> None:
+		return await self.sync_to_trio(sync_function=self._fail_request_impl)(request_id=request_id, error_reason=error_reason)
+	
+	async def fulfill_request(
+			self,
+			request_id: str,
+			response_code: int,
+			response_headers: Optional[List[Dict[str, Any]]] = None,
+			binary_response_headers: Optional[str] = None,
+			body: Optional[str] = None,
+			response_phrase: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._fulfill_request_impl)(
+				request_id=request_id,
+				response_code=response_code,
+				response_headers=response_headers,
+				binary_response_headers=binary_response_headers,
+				body=body,
+				response_phrase=response_phrase
+		)
+	
+	async def get_response_body(self, request_id: str) -> Tuple[str, bool]:
+		return await self.sync_to_trio(sync_function=self._get_response_body_impl)(request_id=request_id)
+	
+	async def take_response_body_as_stream(self, request_id: str) -> str:
+		return await self.sync_to_trio(sync_function=self._take_response_body_as_stream_impl)(request_id=request_id)

osn_selenium/executors/trio_threads/cdp/file_system.py

@@ -0,0 +1,31 @@
+import trio
+from typing import Any, Callable, Dict
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.executors.unified.cdp.file_system import (
+	UnifiedFileSystemCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.file_system import (
+	AbstractFileSystemCDPExecutor
+)
+
+
+__all__ = ["FileSystemCDPExecutor"]
+
+
+class FileSystemCDPExecutor(
+		UnifiedFileSystemCDPExecutor,
+		TrioThreadMixin,
+		AbstractFileSystemCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedFileSystemCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def get_directory(self, bucket_file_system_locator: Dict[str, Any]) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_directory_impl)(bucket_file_system_locator=bucket_file_system_locator)

osn_selenium/executors/trio_threads/cdp/headless_experimental.py

@@ -0,0 +1,54 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.headless_experimental import (
+	UnifiedHeadlessExperimentalCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.headless_experimental import (
+	AbstractHeadlessExperimentalCDPExecutor
+)
+
+
+__all__ = ["HeadlessExperimentalCDPExecutor"]
+
+
+class HeadlessExperimentalCDPExecutor(
+		UnifiedHeadlessExperimentalCDPExecutor,
+		TrioThreadMixin,
+		AbstractHeadlessExperimentalCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedHeadlessExperimentalCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def begin_frame(
+			self,
+			frame_time_ticks: Optional[float] = None,
+			interval: Optional[float] = None,
+			no_display_updates: Optional[bool] = None,
+			screenshot: Optional[Dict[str, Any]] = None
+	) -> Tuple[bool, Optional[str]]:
+		return await self.sync_to_trio(sync_function=self._begin_frame_impl)(
+				frame_time_ticks=frame_time_ticks,
+				interval=interval,
+				no_display_updates=no_display_updates,
+				screenshot=screenshot
+		)
+	
+	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)()