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

osn_selenium/executors/trio_threads/cdp/heap_profiler.py

@@ -0,0 +1,102 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.heap_profiler import (
+	UnifiedHeapProfilerCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.heap_profiler import (
+	AbstractHeapProfilerCDPExecutor
+)
+
+
+__all__ = ["HeapProfilerCDPExecutor"]
+
+
+class HeapProfilerCDPExecutor(
+		UnifiedHeapProfilerCDPExecutor,
+		TrioThreadMixin,
+		AbstractHeapProfilerCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedHeapProfilerCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def add_inspected_heap_object(self, heap_object_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._add_inspected_heap_object_impl)(heap_object_id=heap_object_id)
+	
+	async def collect_garbage(self) -> None:
+		return await self.sync_to_trio(sync_function=self._collect_garbage_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)()
+	
+	async def get_heap_object_id(self, object_id: str) -> str:
+		return await self.sync_to_trio(sync_function=self._get_heap_object_id_impl)(object_id=object_id)
+	
+	async def get_object_by_heap_object_id(self, object_id: str, object_group: Optional[str] = None) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_object_by_heap_object_id_impl)(object_id=object_id, object_group=object_group)
+	
+	async def get_sampling_profile(self) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_sampling_profile_impl)()
+	
+	async def start_sampling(
+			self,
+			sampling_interval: Optional[float] = None,
+			stack_depth: Optional[float] = None,
+			include_objects_collected_by_major_gc: Optional[bool] = None,
+			include_objects_collected_by_minor_gc: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._start_sampling_impl)(
+				sampling_interval=sampling_interval,
+				stack_depth=stack_depth,
+				include_objects_collected_by_major_gc=include_objects_collected_by_major_gc,
+				include_objects_collected_by_minor_gc=include_objects_collected_by_minor_gc
+		)
+	
+	async def start_tracking_heap_objects(self, track_allocations: Optional[bool] = None) -> None:
+		return await self.sync_to_trio(sync_function=self._start_tracking_heap_objects_impl)(track_allocations=track_allocations)
+	
+	async def stop_sampling(self) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._stop_sampling_impl)()
+	
+	async def stop_tracking_heap_objects(
+			self,
+			report_progress: Optional[bool] = None,
+			treat_global_objects_as_roots: Optional[bool] = None,
+			capture_numeric_value: Optional[bool] = None,
+			expose_internals: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._stop_tracking_heap_objects_impl)(
+				report_progress=report_progress,
+				treat_global_objects_as_roots=treat_global_objects_as_roots,
+				capture_numeric_value=capture_numeric_value,
+				expose_internals=expose_internals
+		)
+	
+	async def take_heap_snapshot(
+			self,
+			report_progress: Optional[bool] = None,
+			treat_global_objects_as_roots: Optional[bool] = None,
+			capture_numeric_value: Optional[bool] = None,
+			expose_internals: Optional[bool] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._take_heap_snapshot_impl)(
+				report_progress=report_progress,
+				treat_global_objects_as_roots=treat_global_objects_as_roots,
+				capture_numeric_value=capture_numeric_value,
+				expose_internals=expose_internals
+		)

osn_selenium/executors/trio_threads/cdp/indexed_db.py

@@ -0,0 +1,155 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.indexed_db import (
+	UnifiedIndexedDbCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.indexed_db import (
+	AbstractIndexedDbCDPExecutor
+)
+
+
+__all__ = ["IndexedDbCDPExecutor"]
+
+
+class IndexedDbCDPExecutor(
+		UnifiedIndexedDbCDPExecutor,
+		TrioThreadMixin,
+		AbstractIndexedDbCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedIndexedDbCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def clear_object_store(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None,
+			database_name: str = None,
+			object_store_name: str = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_object_store_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name,
+				object_store_name=object_store_name
+		)
+	
+	async def delete_database(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None,
+			database_name: str = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._delete_database_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name
+		)
+	
+	async def delete_object_store_entries(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None,
+			database_name: str = None,
+			object_store_name: str = None,
+			key_range: Dict[str, Any] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._delete_object_store_entries_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name,
+				object_store_name=object_store_name,
+				key_range=key_range
+		)
+	
+	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 get_metadata(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None,
+			database_name: str = None,
+			object_store_name: str = None
+	) -> Tuple[float, float]:
+		return await self.sync_to_trio(sync_function=self._get_metadata_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name,
+				object_store_name=object_store_name
+		)
+	
+	async def request_data(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None,
+			database_name: str = None,
+			object_store_name: str = None,
+			index_name: Optional[str] = None,
+			skip_count: int = None,
+			page_size: int = None,
+			key_range: Optional[Dict[str, Any]] = None
+	) -> Tuple[List[Dict[str, Any]], bool]:
+		return await self.sync_to_trio(sync_function=self._request_data_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name,
+				object_store_name=object_store_name,
+				index_name=index_name,
+				skip_count=skip_count,
+				page_size=page_size,
+				key_range=key_range
+		)
+	
+	async def request_database(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None,
+			database_name: str = None
+	) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._request_database_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name
+		)
+	
+	async def request_database_names(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None
+	) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._request_database_names_impl)(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket
+		)

osn_selenium/executors/trio_threads/cdp/input.py

@@ -0,0 +1,242 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.input import (
+	UnifiedInputCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.input import (
+	AbstractInputCDPExecutor
+)
+
+
+__all__ = ["InputCDPExecutor"]
+
+
+class InputCDPExecutor(UnifiedInputCDPExecutor, TrioThreadMixin, AbstractInputCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedInputCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def cancel_dragging(self) -> None:
+		return await self.sync_to_trio(sync_function=self._cancel_dragging_impl)()
+	
+	async def dispatch_drag_event(
+			self,
+			type_: str,
+			x: float,
+			y: float,
+			data: Dict[str, Any],
+			modifiers: Optional[int] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._dispatch_drag_event_impl)(type_=type_, x=x, y=y, data=data, modifiers=modifiers)
+	
+	async def dispatch_key_event(
+			self,
+			type_: str,
+			modifiers: Optional[int] = None,
+			timestamp: Optional[float] = None,
+			text: Optional[str] = None,
+			unmodified_text: Optional[str] = None,
+			key_identifier: Optional[str] = None,
+			code: Optional[str] = None,
+			key: Optional[str] = None,
+			windows_virtual_key_code: Optional[int] = None,
+			native_virtual_key_code: Optional[int] = None,
+			auto_repeat: Optional[bool] = None,
+			is_keypad: Optional[bool] = None,
+			is_system_key: Optional[bool] = None,
+			location: Optional[int] = None,
+			commands: Optional[List[str]] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._dispatch_key_event_impl)(
+				type_=type_,
+				modifiers=modifiers,
+				timestamp=timestamp,
+				text=text,
+				unmodified_text=unmodified_text,
+				key_identifier=key_identifier,
+				code=code,
+				key=key,
+				windows_virtual_key_code=windows_virtual_key_code,
+				native_virtual_key_code=native_virtual_key_code,
+				auto_repeat=auto_repeat,
+				is_keypad=is_keypad,
+				is_system_key=is_system_key,
+				location=location,
+				commands=commands
+		)
+	
+	async def dispatch_mouse_event(
+			self,
+			type_: str,
+			x: float,
+			y: float,
+			modifiers: Optional[int] = None,
+			timestamp: Optional[float] = None,
+			button: Optional[str] = None,
+			buttons: Optional[int] = None,
+			click_count: Optional[int] = None,
+			force: Optional[float] = None,
+			tangential_pressure: Optional[float] = None,
+			tilt_x: Optional[float] = None,
+			tilt_y: Optional[float] = None,
+			twist: Optional[int] = None,
+			delta_x: Optional[float] = None,
+			delta_y: Optional[float] = None,
+			pointer_type: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._dispatch_mouse_event_impl)(
+				type_=type_,
+				x=x,
+				y=y,
+				modifiers=modifiers,
+				timestamp=timestamp,
+				button=button,
+				buttons=buttons,
+				click_count=click_count,
+				force=force,
+				tangential_pressure=tangential_pressure,
+				tilt_x=tilt_x,
+				tilt_y=tilt_y,
+				twist=twist,
+				delta_x=delta_x,
+				delta_y=delta_y,
+				pointer_type=pointer_type
+		)
+	
+	async def dispatch_touch_event(
+			self,
+			type_: str,
+			touch_points: List[Dict[str, Any]],
+			modifiers: Optional[int] = None,
+			timestamp: Optional[float] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._dispatch_touch_event_impl)(
+				type_=type_,
+				touch_points=touch_points,
+				modifiers=modifiers,
+				timestamp=timestamp
+		)
+	
+	async def emulate_touch_from_mouse_event(
+			self,
+			type_: str,
+			x: int,
+			y: int,
+			button: str,
+			timestamp: Optional[float] = None,
+			delta_x: Optional[float] = None,
+			delta_y: Optional[float] = None,
+			modifiers: Optional[int] = None,
+			click_count: Optional[int] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._emulate_touch_from_mouse_event_impl)(
+				type_=type_,
+				x=x,
+				y=y,
+				button=button,
+				timestamp=timestamp,
+				delta_x=delta_x,
+				delta_y=delta_y,
+				modifiers=modifiers,
+				click_count=click_count
+		)
+	
+	async def ime_set_composition(
+			self,
+			text: str,
+			selection_start: int,
+			selection_end: int,
+			replacement_start: Optional[int] = None,
+			replacement_end: Optional[int] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._ime_set_composition_impl)(
+				text=text,
+				selection_start=selection_start,
+				selection_end=selection_end,
+				replacement_start=replacement_start,
+				replacement_end=replacement_end
+		)
+	
+	async def insert_text(self, text: str) -> None:
+		return await self.sync_to_trio(sync_function=self._insert_text_impl)(text=text)
+	
+	async def set_ignore_input_events(self, ignore: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_ignore_input_events_impl)(ignore=ignore)
+	
+	async def set_intercept_drags(self, enabled: bool) -> None:
+		return await self.sync_to_trio(sync_function=self._set_intercept_drags_impl)(enabled=enabled)
+	
+	async def synthesize_pinch_gesture(
+			self,
+			x: float,
+			y: float,
+			scale_factor: float,
+			relative_speed: Optional[int] = None,
+			gesture_source_type: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._synthesize_pinch_gesture_impl)(
+				x=x,
+				y=y,
+				scale_factor=scale_factor,
+				relative_speed=relative_speed,
+				gesture_source_type=gesture_source_type
+		)
+	
+	async def synthesize_scroll_gesture(
+			self,
+			x: float,
+			y: float,
+			x_distance: Optional[float] = None,
+			y_distance: Optional[float] = None,
+			x_overscroll: Optional[float] = None,
+			y_overscroll: Optional[float] = None,
+			prevent_fling: Optional[bool] = None,
+			speed: Optional[int] = None,
+			gesture_source_type: Optional[str] = None,
+			repeat_count: Optional[int] = None,
+			repeat_delay_ms: Optional[int] = None,
+			interaction_marker_name: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._synthesize_scroll_gesture_impl)(
+				x=x,
+				y=y,
+				x_distance=x_distance,
+				y_distance=y_distance,
+				x_overscroll=x_overscroll,
+				y_overscroll=y_overscroll,
+				prevent_fling=prevent_fling,
+				speed=speed,
+				gesture_source_type=gesture_source_type,
+				repeat_count=repeat_count,
+				repeat_delay_ms=repeat_delay_ms,
+				interaction_marker_name=interaction_marker_name
+		)
+	
+	async def synthesize_tap_gesture(
+			self,
+			x: float,
+			y: float,
+			duration: Optional[int] = None,
+			tap_count: Optional[int] = None,
+			gesture_source_type: Optional[str] = None
+	) -> None:
+		return await self.sync_to_trio(sync_function=self._synthesize_tap_gesture_impl)(
+				x=x,
+				y=y,
+				duration=duration,
+				tap_count=tap_count,
+				gesture_source_type=gesture_source_type
+		)

osn_selenium/executors/trio_threads/cdp/inspector.py

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

osn_selenium/executors/trio_threads/cdp/io.py

@@ -0,0 +1,42 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.io import UnifiedIoCDPExecutor
+from osn_selenium.abstract.executors.cdp.io import (
+	AbstractIoCDPExecutor
+)
+
+
+__all__ = ["IoCDPExecutor"]
+
+
+class IoCDPExecutor(UnifiedIoCDPExecutor, TrioThreadMixin, AbstractIoCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedIoCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def close(self, handle: str) -> None:
+		return await self.sync_to_trio(sync_function=self._close_impl)(handle=handle)
+	
+	async def read(
+			self,
+			handle: str,
+			offset: Optional[int] = None,
+			size: Optional[int] = None
+	) -> Tuple[Optional[bool], str, bool]:
+		return await self.sync_to_trio(sync_function=self._read_impl)(handle=handle, offset=offset, size=size)
+	
+	async def resolve_blob(self, object_id: str) -> str:
+		return await self.sync_to_trio(sync_function=self._resolve_blob_impl)(object_id=object_id)

osn_selenium/executors/trio_threads/cdp/layer_tree.py

@@ -0,0 +1,84 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.layer_tree import (
+	UnifiedLayerTreeCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.layer_tree import (
+	AbstractLayerTreeCDPExecutor
+)
+
+
+__all__ = ["LayerTreeCDPExecutor"]
+
+
+class LayerTreeCDPExecutor(
+		UnifiedLayerTreeCDPExecutor,
+		TrioThreadMixin,
+		AbstractLayerTreeCDPExecutor
+):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedLayerTreeCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def compositing_reasons(self, layer_id: str) -> Tuple[List[str], List[str]]:
+		return await self.sync_to_trio(sync_function=self._compositing_reasons_impl)(layer_id=layer_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 load_snapshot(self, tiles: List[Dict[str, Any]]) -> str:
+		return await self.sync_to_trio(sync_function=self._load_snapshot_impl)(tiles=tiles)
+	
+	async def make_snapshot(self, layer_id: str) -> str:
+		return await self.sync_to_trio(sync_function=self._make_snapshot_impl)(layer_id=layer_id)
+	
+	async def profile_snapshot(
+			self,
+			snapshot_id: str,
+			min_repeat_count: Optional[int] = None,
+			min_duration: Optional[float] = None,
+			clip_rect: Optional[Dict[str, Any]] = None
+	) -> List[List[float]]:
+		return await self.sync_to_trio(sync_function=self._profile_snapshot_impl)(
+				snapshot_id=snapshot_id,
+				min_repeat_count=min_repeat_count,
+				min_duration=min_duration,
+				clip_rect=clip_rect
+		)
+	
+	async def release_snapshot(self, snapshot_id: str) -> None:
+		return await self.sync_to_trio(sync_function=self._release_snapshot_impl)(snapshot_id=snapshot_id)
+	
+	async def replay_snapshot(
+			self,
+			snapshot_id: str,
+			from_step: Optional[int] = None,
+			to_step: Optional[int] = None,
+			scale: Optional[float] = None
+	) -> str:
+		return await self.sync_to_trio(sync_function=self._replay_snapshot_impl)(
+				snapshot_id=snapshot_id,
+				from_step=from_step,
+				to_step=to_step,
+				scale=scale
+		)
+	
+	async def snapshot_command_log(self, snapshot_id: str) -> List[Any]:
+		return await self.sync_to_trio(sync_function=self._snapshot_command_log_impl)(snapshot_id=snapshot_id)

osn_selenium/executors/trio_threads/cdp/log.py

@@ -0,0 +1,44 @@
+import trio
+from osn_selenium.base_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List
+)
+from osn_selenium.executors.unified.cdp.log import (
+	UnifiedLogCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.log import (
+	AbstractLogCDPExecutor
+)
+
+
+__all__ = ["LogCDPExecutor"]
+
+
+class LogCDPExecutor(UnifiedLogCDPExecutor, TrioThreadMixin, AbstractLogCDPExecutor):
+	def __init__(
+			self,
+			execute_function: Callable[[str, Dict[str, Any]], Any],
+			lock: trio.Lock,
+			limiter: trio.CapacityLimiter
+	):
+		UnifiedLogCDPExecutor.__init__(self, execute_function=execute_function)
+		
+		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
+	
+	async def clear(self) -> None:
+		return await self.sync_to_trio(sync_function=self._clear_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)()
+	
+	async def start_violations_report(self, config: List[Dict[str, Any]]) -> None:
+		return await self.sync_to_trio(sync_function=self._start_violations_report_impl)(config=config)
+	
+	async def stop_violations_report(self) -> None:
+		return await self.sync_to_trio(sync_function=self._stop_violations_report_impl)()