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

osn_selenium/executors/sync/cdp/indexed_db.py

@@ -0,0 +1,142 @@
+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, AbstractIndexedDbCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedIndexedDbCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	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 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
+		)
+	
+	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 self._delete_database_impl(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name
+		)
+	
+	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 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
+		)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	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 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
+		)
+	
+	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 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
+		)
+	
+	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 self._request_database_impl(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket,
+				database_name=database_name
+		)
+	
+	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 self._request_database_names_impl(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket
+		)

osn_selenium/executors/sync/cdp/input.py

@@ -0,0 +1,233 @@
+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, AbstractInputCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedInputCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def cancel_dragging(self) -> None:
+		return self._cancel_dragging_impl()
+	
+	def dispatch_drag_event(
+			self,
+			type_: str,
+			x: float,
+			y: float,
+			data: Dict[str, Any],
+			modifiers: Optional[int] = None
+	) -> None:
+		return self._dispatch_drag_event_impl(type_=type_, x=x, y=y, data=data, modifiers=modifiers)
+	
+	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 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
+		)
+	
+	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 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
+		)
+	
+	def dispatch_touch_event(
+			self,
+			type_: str,
+			touch_points: List[Dict[str, Any]],
+			modifiers: Optional[int] = None,
+			timestamp: Optional[float] = None
+	) -> None:
+		return self._dispatch_touch_event_impl(
+				type_=type_,
+				touch_points=touch_points,
+				modifiers=modifiers,
+				timestamp=timestamp
+		)
+	
+	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 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
+		)
+	
+	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 self._ime_set_composition_impl(
+				text=text,
+				selection_start=selection_start,
+				selection_end=selection_end,
+				replacement_start=replacement_start,
+				replacement_end=replacement_end
+		)
+	
+	def insert_text(self, text: str) -> None:
+		return self._insert_text_impl(text=text)
+	
+	def set_ignore_input_events(self, ignore: bool) -> None:
+		return self._set_ignore_input_events_impl(ignore=ignore)
+	
+	def set_intercept_drags(self, enabled: bool) -> None:
+		return self._set_intercept_drags_impl(enabled=enabled)
+	
+	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 self._synthesize_pinch_gesture_impl(
+				x=x,
+				y=y,
+				scale_factor=scale_factor,
+				relative_speed=relative_speed,
+				gesture_source_type=gesture_source_type
+		)
+	
+	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 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
+		)
+	
+	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 self._synthesize_tap_gesture_impl(
+				x=x,
+				y=y,
+				duration=duration,
+				tap_count=tap_count,
+				gesture_source_type=gesture_source_type
+		)

osn_selenium/executors/sync/cdp/inspector.py

@@ -0,0 +1,21 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.inspector import (
+	UnifiedInspectorCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.inspector import (
+	AbstractInspectorCDPExecutor
+)
+
+
+__all__ = ["InspectorCDPExecutor"]
+
+
+class InspectorCDPExecutor(UnifiedInspectorCDPExecutor, AbstractInspectorCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedInspectorCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()

osn_selenium/executors/sync/cdp/io.py

@@ -0,0 +1,33 @@
+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, AbstractIoCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedIoCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def close(self, handle: str) -> None:
+		return self._close_impl(handle=handle)
+	
+	def read(
+			self,
+			handle: str,
+			offset: Optional[int] = None,
+			size: Optional[int] = None
+	) -> Tuple[Optional[bool], str, bool]:
+		return self._read_impl(handle=handle, offset=offset, size=size)
+	
+	def resolve_blob(self, object_id: str) -> str:
+		return self._resolve_blob_impl(object_id=object_id)

osn_selenium/executors/sync/cdp/layer_tree.py

@@ -0,0 +1,71 @@
+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, AbstractLayerTreeCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedLayerTreeCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def compositing_reasons(self, layer_id: str) -> Tuple[List[str], List[str]]:
+		return self._compositing_reasons_impl(layer_id=layer_id)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def load_snapshot(self, tiles: List[Dict[str, Any]]) -> str:
+		return self._load_snapshot_impl(tiles=tiles)
+	
+	def make_snapshot(self, layer_id: str) -> str:
+		return self._make_snapshot_impl(layer_id=layer_id)
+	
+	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 self._profile_snapshot_impl(
+				snapshot_id=snapshot_id,
+				min_repeat_count=min_repeat_count,
+				min_duration=min_duration,
+				clip_rect=clip_rect
+		)
+	
+	def release_snapshot(self, snapshot_id: str) -> None:
+		return self._release_snapshot_impl(snapshot_id=snapshot_id)
+	
+	def replay_snapshot(
+			self,
+			snapshot_id: str,
+			from_step: Optional[int] = None,
+			to_step: Optional[int] = None,
+			scale: Optional[float] = None
+	) -> str:
+		return self._replay_snapshot_impl(
+				snapshot_id=snapshot_id,
+				from_step=from_step,
+				to_step=to_step,
+				scale=scale
+		)
+	
+	def snapshot_command_log(self, snapshot_id: str) -> List[Any]:
+		return self._snapshot_command_log_impl(snapshot_id=snapshot_id)

osn_selenium/executors/sync/cdp/log.py

@@ -0,0 +1,35 @@
+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, AbstractLogCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedLogCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def clear(self) -> None:
+		return self._clear_impl()
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def start_violations_report(self, config: List[Dict[str, Any]]) -> None:
+		return self._start_violations_report_impl(config=config)
+	
+	def stop_violations_report(self) -> None:
+		return self._stop_violations_report_impl()

osn_selenium/executors/sync/cdp/media.py

@@ -0,0 +1,21 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.media import (
+	UnifiedMediaCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.media import (
+	AbstractMediaCDPExecutor
+)
+
+
+__all__ = ["MediaCDPExecutor"]
+
+
+class MediaCDPExecutor(UnifiedMediaCDPExecutor, AbstractMediaCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedMediaCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()

osn_selenium/executors/sync/cdp/memory.py

@@ -0,0 +1,62 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.memory import (
+	UnifiedMemoryCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.memory import (
+	AbstractMemoryCDPExecutor
+)
+
+
+__all__ = ["MemoryCDPExecutor"]
+
+
+class MemoryCDPExecutor(UnifiedMemoryCDPExecutor, AbstractMemoryCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedMemoryCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def forcibly_purge_java_script_memory(self) -> None:
+		return self._forcibly_purge_java_script_memory_impl()
+	
+	def get_all_time_sampling_profile(self) -> Dict[str, Any]:
+		return self._get_all_time_sampling_profile_impl()
+	
+	def get_browser_sampling_profile(self) -> Dict[str, Any]:
+		return self._get_browser_sampling_profile_impl()
+	
+	def get_dom_counters(self) -> Tuple[int, int, int]:
+		return self._get_dom_counters_impl()
+	
+	def get_dom_counters_for_leak_detection(self) -> List[Dict[str, Any]]:
+		return self._get_dom_counters_for_leak_detection_impl()
+	
+	def get_sampling_profile(self) -> Dict[str, Any]:
+		return self._get_sampling_profile_impl()
+	
+	def prepare_for_leak_detection(self) -> None:
+		return self._prepare_for_leak_detection_impl()
+	
+	def set_pressure_notifications_suppressed(self, suppressed: bool) -> None:
+		return self._set_pressure_notifications_suppressed_impl(suppressed=suppressed)
+	
+	def simulate_pressure_notification(self, level: str) -> None:
+		return self._simulate_pressure_notification_impl(level=level)
+	
+	def start_sampling(
+			self,
+			sampling_interval: Optional[int] = None,
+			suppress_randomness: Optional[bool] = None
+	) -> None:
+		return self._start_sampling_impl(
+				sampling_interval=sampling_interval,
+				suppress_randomness=suppress_randomness
+		)
+	
+	def stop_sampling(self) -> None:
+		return self._stop_sampling_impl()