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

osn_selenium/executors/trio_threads/cdp/console.py

@@ -1,33 +0,0 @@
-import trio
-from typing import Any, Callable, Dict
-from osn_selenium.base_mixin import TrioThreadMixin
-from osn_selenium.executors.unified.cdp.console import (
-	UnifiedConsoleCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.console import (
-	AbstractConsoleCDPExecutor
-)
-
-
-__all__ = ["ConsoleCDPExecutor"]
-
-
-class ConsoleCDPExecutor(UnifiedConsoleCDPExecutor, TrioThreadMixin, AbstractConsoleCDPExecutor):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedConsoleCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def clear_messages(self) -> None:
-		return await self.sync_to_trio(sync_function=self._clear_messages_impl)()
-	
-	async def disable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._disable_impl)()
-	
-	async def enable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._enable_impl)()

osn_selenium/executors/trio_threads/cdp/css.py

@@ -1,196 +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.css import (
-	UnifiedCssCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.css import (
-	AbstractCssCDPExecutor
-)
-
-
-__all__ = ["CssCDPExecutor"]
-
-
-class CssCDPExecutor(UnifiedCssCDPExecutor, TrioThreadMixin, AbstractCssCDPExecutor):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedCssCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def add_rule(
-			self,
-			style_sheet_id: str,
-			rule_text: str,
-			location: Dict[str, Any],
-			node_for_property_syntax_validation: Optional[int] = None
-	) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._add_rule_impl)(
-				style_sheet_id=style_sheet_id,
-				rule_text=rule_text,
-				location=location,
-				node_for_property_syntax_validation=node_for_property_syntax_validation
-		)
-	
-	async def collect_class_names(self, style_sheet_id: str) -> List[str]:
-		return await self.sync_to_trio(sync_function=self._collect_class_names_impl)(style_sheet_id=style_sheet_id)
-	
-	async def create_style_sheet(self, frame_id: str, force: Optional[bool] = None) -> str:
-		return await self.sync_to_trio(sync_function=self._create_style_sheet_impl)(frame_id=frame_id, force=force)
-	
-	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 force_pseudo_state(self, node_id: int, forced_pseudo_classes: List[str]) -> None:
-		return await self.sync_to_trio(sync_function=self._force_pseudo_state_impl)(node_id=node_id, forced_pseudo_classes=forced_pseudo_classes)
-	
-	async def force_starting_style(self, node_id: int, forced: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._force_starting_style_impl)(node_id=node_id, forced=forced)
-	
-	async def get_animated_styles_for_node(self, node_id: int) -> Tuple[
-		Optional[List[Dict[str, Any]]],
-		Optional[Dict[str, Any]],
-		Optional[List[Dict[str, Any]]]
-	]:
-		return await self.sync_to_trio(sync_function=self._get_animated_styles_for_node_impl)(node_id=node_id)
-	
-	async def get_background_colors(self, node_id: int) -> Tuple[Optional[List[str]], Optional[str], Optional[str]]:
-		return await self.sync_to_trio(sync_function=self._get_background_colors_impl)(node_id=node_id)
-	
-	async def get_computed_style_for_node(self, node_id: int) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_computed_style_for_node_impl)(node_id=node_id)
-	
-	async def get_environment_variables(self) -> Any:
-		return await self.sync_to_trio(sync_function=self._get_environment_variables_impl)()
-	
-	async def get_inline_styles_for_node(self, node_id: int) -> Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._get_inline_styles_for_node_impl)(node_id=node_id)
-	
-	async def get_layers_for_node(self, node_id: int) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._get_layers_for_node_impl)(node_id=node_id)
-	
-	async def get_location_for_selector(self, style_sheet_id: str, selector_text: str) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_location_for_selector_impl)(style_sheet_id=style_sheet_id, selector_text=selector_text)
-	
-	async def get_longhand_properties(self, shorthand_name: str, value: str) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_longhand_properties_impl)(shorthand_name=shorthand_name, value=value)
-	
-	async def get_matched_styles_for_node(self, node_id: int) -> Tuple[
-		Optional[Dict[str, Any]],
-		Optional[Dict[str, Any]],
-		Optional[List[Dict[str, Any]]],
-		Optional[List[Dict[str, Any]]],
-		Optional[List[Dict[str, Any]]],
-		Optional[List[Dict[str, Any]]],
-		Optional[List[Dict[str, Any]]],
-		Optional[List[Dict[str, Any]]],
-		Optional[int],
-		Optional[List[Dict[str, Any]]],
-		Optional[List[Dict[str, Any]]],
-		Optional[Dict[str, Any]],
-		Optional[int],
-		Optional[List[Dict[str, Any]]]
-	]:
-		return await self.sync_to_trio(sync_function=self._get_matched_styles_for_node_impl)(node_id=node_id)
-	
-	async def get_media_queries(self) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_media_queries_impl)()
-	
-	async def get_platform_fonts_for_node(self, node_id: int) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_platform_fonts_for_node_impl)(node_id=node_id)
-	
-	async def get_style_sheet_text(self, style_sheet_id: str) -> str:
-		return await self.sync_to_trio(sync_function=self._get_style_sheet_text_impl)(style_sheet_id=style_sheet_id)
-	
-	async def resolve_values(
-			self,
-			values: List[str],
-			node_id: int,
-			property_name: Optional[str] = None,
-			pseudo_type: Optional[str] = None,
-			pseudo_identifier: Optional[str] = None
-	) -> List[str]:
-		return await self.sync_to_trio(sync_function=self._resolve_values_impl)(
-				values=values,
-				node_id=node_id,
-				property_name=property_name,
-				pseudo_type=pseudo_type,
-				pseudo_identifier=pseudo_identifier
-		)
-	
-	async def set_container_query_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._set_container_query_text_impl)(style_sheet_id=style_sheet_id, range_=range_, text=text)
-	
-	async def set_effective_property_value_for_node(self, node_id: int, property_name: str, value: str) -> None:
-		return await self.sync_to_trio(sync_function=self._set_effective_property_value_for_node_impl)(node_id=node_id, property_name=property_name, value=value)
-	
-	async def set_keyframe_key(self, style_sheet_id: str, range_: Dict[str, Any], key_text: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._set_keyframe_key_impl)(style_sheet_id=style_sheet_id, range_=range_, key_text=key_text)
-	
-	async def set_local_fonts_enabled(self, enabled: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_local_fonts_enabled_impl)(enabled=enabled)
-	
-	async def set_media_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._set_media_text_impl)(style_sheet_id=style_sheet_id, range_=range_, text=text)
-	
-	async def set_property_rule_property_name(self, style_sheet_id: str, range_: Dict[str, Any], property_name: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._set_property_rule_property_name_impl)(
-				style_sheet_id=style_sheet_id,
-				range_=range_,
-				property_name=property_name
-		)
-	
-	async def set_rule_selector(self, style_sheet_id: str, range_: Dict[str, Any], selector: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._set_rule_selector_impl)(style_sheet_id=style_sheet_id, range_=range_, selector=selector)
-	
-	async def set_scope_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._set_scope_text_impl)(style_sheet_id=style_sheet_id, range_=range_, text=text)
-	
-	async def set_style_sheet_text(self, style_sheet_id: str, text: str) -> Optional[str]:
-		return await self.sync_to_trio(sync_function=self._set_style_sheet_text_impl)(style_sheet_id=style_sheet_id, text=text)
-	
-	async def set_style_texts(
-			self,
-			edits: List[Dict[str, Any]],
-			node_for_property_syntax_validation: Optional[int] = None
-	) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._set_style_texts_impl)(
-				edits=edits,
-				node_for_property_syntax_validation=node_for_property_syntax_validation
-		)
-	
-	async def set_supports_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._set_supports_text_impl)(style_sheet_id=style_sheet_id, range_=range_, text=text)
-	
-	async def start_rule_usage_tracking(self) -> None:
-		return await self.sync_to_trio(sync_function=self._start_rule_usage_tracking_impl)()
-	
-	async def stop_rule_usage_tracking(self) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._stop_rule_usage_tracking_impl)()
-	
-	async def take_computed_style_updates(self) -> List[int]:
-		return await self.sync_to_trio(sync_function=self._take_computed_style_updates_impl)()
-	
-	async def take_coverage_delta(self) -> Tuple[List[Dict[str, Any]], float]:
-		return await self.sync_to_trio(sync_function=self._take_coverage_delta_impl)()
-	
-	async def track_computed_style_updates(self, properties_to_track: List[Dict[str, Any]]) -> None:
-		return await self.sync_to_trio(sync_function=self._track_computed_style_updates_impl)(properties_to_track=properties_to_track)
-	
-	async def track_computed_style_updates_for_node(self, node_id: Optional[int] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._track_computed_style_updates_for_node_impl)(node_id=node_id)

osn_selenium/executors/trio_threads/cdp/debugger.py

@@ -1,219 +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.debugger import (
-	UnifiedDebuggerCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.debugger import (
-	AbstractDebuggerCDPExecutor
-)
-
-
-__all__ = ["DebuggerCDPExecutor"]
-
-
-class DebuggerCDPExecutor(
-		UnifiedDebuggerCDPExecutor,
-		TrioThreadMixin,
-		AbstractDebuggerCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedDebuggerCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def continue_to_location(self, location: Dict[str, Any], target_call_frames: Optional[str] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._continue_to_location_impl)(location=location, target_call_frames=target_call_frames)
-	
-	async def disable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._disable_impl)()
-	
-	async def disassemble_wasm_module(self, script_id: str) -> Tuple[Optional[str], int, List[int], Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._disassemble_wasm_module_impl)(script_id=script_id)
-	
-	async def enable(self, max_scripts_cache_size: Optional[float] = None) -> str:
-		return await self.sync_to_trio(sync_function=self._enable_impl)(max_scripts_cache_size=max_scripts_cache_size)
-	
-	async def evaluate_on_call_frame(
-			self,
-			call_frame_id: str,
-			expression: str,
-			object_group: Optional[str] = None,
-			include_command_line_api: Optional[bool] = None,
-			silent: Optional[bool] = None,
-			return_by_value: Optional[bool] = None,
-			generate_preview: Optional[bool] = None,
-			throw_on_side_effect: Optional[bool] = None,
-			timeout: Optional[float] = None
-	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._evaluate_on_call_frame_impl)(
-				call_frame_id=call_frame_id,
-				expression=expression,
-				object_group=object_group,
-				include_command_line_api=include_command_line_api,
-				silent=silent,
-				return_by_value=return_by_value,
-				generate_preview=generate_preview,
-				throw_on_side_effect=throw_on_side_effect,
-				timeout=timeout
-		)
-	
-	async def get_possible_breakpoints(
-			self,
-			start: Dict[str, Any],
-			end: Optional[Dict[str, Any]] = None,
-			restrict_to_function: Optional[bool] = None
-	) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_possible_breakpoints_impl)(start=start, end=end, restrict_to_function=restrict_to_function)
-	
-	async def get_script_source(self, script_id: str) -> Tuple[str, Optional[str]]:
-		return await self.sync_to_trio(sync_function=self._get_script_source_impl)(script_id=script_id)
-	
-	async def get_stack_trace(self, stack_trace_id: Dict[str, Any]) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._get_stack_trace_impl)(stack_trace_id=stack_trace_id)
-	
-	async def get_wasm_bytecode(self, script_id: str) -> str:
-		return await self.sync_to_trio(sync_function=self._get_wasm_bytecode_impl)(script_id=script_id)
-	
-	async def next_wasm_disassembly_chunk(self, stream_id: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._next_wasm_disassembly_chunk_impl)(stream_id=stream_id)
-	
-	async def pause(self) -> None:
-		return await self.sync_to_trio(sync_function=self._pause_impl)()
-	
-	async def pause_on_async_call(self, parent_stack_trace_id: Dict[str, Any]) -> None:
-		return await self.sync_to_trio(sync_function=self._pause_on_async_call_impl)(parent_stack_trace_id=parent_stack_trace_id)
-	
-	async def remove_breakpoint(self, breakpoint_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._remove_breakpoint_impl)(breakpoint_id=breakpoint_id)
-	
-	async def restart_frame(self, call_frame_id: str, mode: Optional[str] = None) -> Tuple[List[Dict[str, Any]], Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._restart_frame_impl)(call_frame_id=call_frame_id, mode=mode)
-	
-	async def resume(self, terminate_on_resume: Optional[bool] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._resume_impl)(terminate_on_resume=terminate_on_resume)
-	
-	async def search_in_content(
-			self,
-			script_id: str,
-			query: str,
-			case_sensitive: Optional[bool] = None,
-			is_regex: Optional[bool] = None
-	) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._search_in_content_impl)(
-				script_id=script_id,
-				query=query,
-				case_sensitive=case_sensitive,
-				is_regex=is_regex
-		)
-	
-	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_blackbox_execution_contexts(self, unique_ids: List[str]) -> None:
-		return await self.sync_to_trio(sync_function=self._set_blackbox_execution_contexts_impl)(unique_ids=unique_ids)
-	
-	async def set_blackbox_patterns(self, patterns: List[str], skip_anonymous: Optional[bool] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._set_blackbox_patterns_impl)(patterns=patterns, skip_anonymous=skip_anonymous)
-	
-	async def set_blackboxed_ranges(self, script_id: str, positions: List[Dict[str, Any]]) -> None:
-		return await self.sync_to_trio(sync_function=self._set_blackboxed_ranges_impl)(script_id=script_id, positions=positions)
-	
-	async def set_breakpoint(self, location: Dict[str, Any], condition: Optional[str] = None) -> Tuple[str, Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._set_breakpoint_impl)(location=location, condition=condition)
-	
-	async def set_breakpoint_by_url(
-			self,
-			line_number: int,
-			url: Optional[str] = None,
-			url_regex: Optional[str] = None,
-			script_hash: Optional[str] = None,
-			column_number: Optional[int] = None,
-			condition: Optional[str] = None
-	) -> Tuple[str, List[Dict[str, Any]]]:
-		return await self.sync_to_trio(sync_function=self._set_breakpoint_by_url_impl)(
-				line_number=line_number,
-				url=url,
-				url_regex=url_regex,
-				script_hash=script_hash,
-				column_number=column_number,
-				condition=condition
-		)
-	
-	async def set_breakpoint_on_function_call(self, object_id: str, condition: Optional[str] = None) -> str:
-		return await self.sync_to_trio(sync_function=self._set_breakpoint_on_function_call_impl)(object_id=object_id, condition=condition)
-	
-	async def set_breakpoints_active(self, active: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_breakpoints_active_impl)(active=active)
-	
-	async def set_instrumentation_breakpoint(self, instrumentation: str) -> str:
-		return await self.sync_to_trio(sync_function=self._set_instrumentation_breakpoint_impl)(instrumentation=instrumentation)
-	
-	async def set_pause_on_exceptions(self, state: str) -> None:
-		return await self.sync_to_trio(sync_function=self._set_pause_on_exceptions_impl)(state=state)
-	
-	async def set_return_value(self, new_value: Dict[str, Any]) -> None:
-		return await self.sync_to_trio(sync_function=self._set_return_value_impl)(new_value=new_value)
-	
-	async def set_script_source(
-			self,
-			script_id: str,
-			script_source: str,
-			dry_run: Optional[bool] = None,
-			allow_top_frame_editing: Optional[bool] = None
-	) -> Tuple[
-		Optional[List[Dict[str, Any]]],
-		Optional[bool],
-		Optional[Dict[str, Any]],
-		Optional[Dict[str, Any]],
-		str,
-		Optional[Dict[str, Any]]
-	]:
-		return await self.sync_to_trio(sync_function=self._set_script_source_impl)(
-				script_id=script_id,
-				script_source=script_source,
-				dry_run=dry_run,
-				allow_top_frame_editing=allow_top_frame_editing
-		)
-	
-	async def set_skip_all_pauses(self, skip: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_skip_all_pauses_impl)(skip=skip)
-	
-	async def set_variable_value(
-			self,
-			scope_number: int,
-			variable_name: str,
-			new_value: Dict[str, Any],
-			call_frame_id: str
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._set_variable_value_impl)(
-				scope_number=scope_number,
-				variable_name=variable_name,
-				new_value=new_value,
-				call_frame_id=call_frame_id
-		)
-	
-	async def step_into(
-			self,
-			break_on_async_call: Optional[bool] = None,
-			skip_list: Optional[List[Dict[str, Any]]] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._step_into_impl)(break_on_async_call=break_on_async_call, skip_list=skip_list)
-	
-	async def step_out(self) -> None:
-		return await self.sync_to_trio(sync_function=self._step_out_impl)()
-	
-	async def step_over(self, skip_list: Optional[List[Dict[str, Any]]] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._step_over_impl)(skip_list=skip_list)

osn_selenium/executors/trio_threads/cdp/device_access.py

@@ -1,40 +0,0 @@
-import trio
-from typing import Any, Callable, Dict
-from osn_selenium.base_mixin import TrioThreadMixin
-from osn_selenium.executors.unified.cdp.device_access import (
-	UnifiedDeviceAccessCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.device_access import (
-	AbstractDeviceAccessCDPExecutor
-)
-
-
-__all__ = ["DeviceAccessCDPExecutor"]
-
-
-class DeviceAccessCDPExecutor(
-		UnifiedDeviceAccessCDPExecutor,
-		TrioThreadMixin,
-		AbstractDeviceAccessCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedDeviceAccessCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def cancel_prompt(self, id_: str) -> None:
-		return await self.sync_to_trio(sync_function=self._cancel_prompt_impl)(id_=id_)
-	
-	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 select_prompt(self, id_: str, device_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._select_prompt_impl)(id_=id_, device_id=device_id)

osn_selenium/executors/trio_threads/cdp/device_orientation.py

@@ -1,34 +0,0 @@
-import trio
-from typing import Any, Callable, Dict
-from osn_selenium.base_mixin import TrioThreadMixin
-from osn_selenium.executors.unified.cdp.device_orientation import (
-	UnifiedDeviceOrientationCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.device_orientation import (
-	AbstractDeviceOrientationCDPExecutor
-)
-
-
-__all__ = ["DeviceOrientationCDPExecutor"]
-
-
-class DeviceOrientationCDPExecutor(
-		UnifiedDeviceOrientationCDPExecutor,
-		TrioThreadMixin,
-		AbstractDeviceOrientationCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedDeviceOrientationCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def clear_device_orientation_override(self) -> None:
-		return await self.sync_to_trio(sync_function=self._clear_device_orientation_override_impl)()
-	
-	async def set_device_orientation_override(self, alpha: float, beta: float, gamma: float) -> None:
-		return await self.sync_to_trio(sync_function=self._set_device_orientation_override_impl)(alpha=alpha, beta=beta, gamma=gamma)