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

osn_selenium/executors/trio_threads/cdp/emulation.py

@@ -1,283 +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.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

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

@@ -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.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

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

@@ -1,105 +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.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

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

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