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

osn_selenium/executors/trio_threads/cdp/heap_profiler.py

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

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

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

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

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

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

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