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

osn_selenium/executors/unified/cdp/fetch.py

@@ -0,0 +1,111 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedFetchCDPExecutor"]
+
+
+class UnifiedFetchCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _continue_request_impl(
+			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 self._execute_function(
+				"Fetch.continueRequest",
+				{
+					"request_id": request_id,
+					"url": url,
+					"method": method,
+					"post_data": post_data,
+					"headers": headers,
+					"intercept_response": intercept_response
+				}
+		)
+	
+	def _continue_response_impl(
+			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 self._execute_function(
+				"Fetch.continueResponse",
+				{
+					"request_id": request_id,
+					"response_code": response_code,
+					"response_phrase": response_phrase,
+					"response_headers": response_headers,
+					"binary_response_headers": binary_response_headers
+				}
+		)
+	
+	def _continue_with_auth_impl(self, request_id: str, auth_challenge_response: Dict[str, Any]) -> None:
+		return self._execute_function(
+				"Fetch.continueWithAuth",
+				{
+					"request_id": request_id,
+					"auth_challenge_response": auth_challenge_response
+				}
+		)
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Fetch.disable", {})
+	
+	def _enable_impl(
+			self,
+			patterns: Optional[List[Dict[str, Any]]] = None,
+			handle_auth_requests: Optional[bool] = None
+	) -> None:
+		return self._execute_function(
+				"Fetch.enable",
+				{"patterns": patterns, "handle_auth_requests": handle_auth_requests}
+		)
+	
+	def _fail_request_impl(self, request_id: str, error_reason: str) -> None:
+		return self._execute_function(
+				"Fetch.failRequest",
+				{"request_id": request_id, "error_reason": error_reason}
+		)
+	
+	def _fulfill_request_impl(
+			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 self._execute_function(
+				"Fetch.fulfillRequest",
+				{
+					"request_id": request_id,
+					"response_code": response_code,
+					"response_headers": response_headers,
+					"binary_response_headers": binary_response_headers,
+					"body": body,
+					"response_phrase": response_phrase
+				}
+		)
+	
+	def _get_response_body_impl(self, request_id: str) -> Tuple[str, bool]:
+		return self._execute_function("Fetch.getResponseBody", {"request_id": request_id})
+	
+	def _take_response_body_as_stream_impl(self, request_id: str) -> str:
+		return self._execute_function("Fetch.takeResponseBodyAsStream", {"request_id": request_id})

osn_selenium/executors/unified/cdp/file_system.py

@@ -0,0 +1,15 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedFileSystemCDPExecutor"]
+
+
+class UnifiedFileSystemCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _get_directory_impl(self, bucket_file_system_locator: Dict[str, Any]) -> Dict[str, Any]:
+		return self._execute_function(
+				"FileSystem.getDirectory",
+				{"bucket_file_system_locator": bucket_file_system_locator}
+		)

osn_selenium/executors/unified/cdp/headless_experimental.py

@@ -0,0 +1,38 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedHeadlessExperimentalCDPExecutor"]
+
+
+class UnifiedHeadlessExperimentalCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _begin_frame_impl(
+			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 self._execute_function(
+				"HeadlessExperimental.beginFrame",
+				{
+					"frame_time_ticks": frame_time_ticks,
+					"interval": interval,
+					"no_display_updates": no_display_updates,
+					"screenshot": screenshot
+				}
+		)
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("HeadlessExperimental.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("HeadlessExperimental.enable", {})

osn_selenium/executors/unified/cdp/heap_profiler.py

@@ -0,0 +1,101 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+
+
+__all__ = ["UnifiedHeapProfilerCDPExecutor"]
+
+
+class UnifiedHeapProfilerCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _add_inspected_heap_object_impl(self, heap_object_id: str) -> None:
+		return self._execute_function(
+				"HeapProfiler.addInspectedHeapObject",
+				{"heap_object_id": heap_object_id}
+		)
+	
+	def _collect_garbage_impl(self) -> None:
+		return self._execute_function("HeapProfiler.collectGarbage", {})
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("HeapProfiler.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("HeapProfiler.enable", {})
+	
+	def _get_heap_object_id_impl(self, object_id: str) -> str:
+		return self._execute_function("HeapProfiler.getHeapObjectId", {"object_id": object_id})
+	
+	def _get_object_by_heap_object_id_impl(self, object_id: str, object_group: Optional[str] = None) -> Dict[str, Any]:
+		return self._execute_function(
+				"HeapProfiler.getObjectByHeapObjectId",
+				{"object_id": object_id, "object_group": object_group}
+		)
+	
+	def _get_sampling_profile_impl(self) -> Dict[str, Any]:
+		return self._execute_function("HeapProfiler.getSamplingProfile", {})
+	
+	def _start_sampling_impl(
+			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 self._execute_function(
+				"HeapProfiler.startSampling",
+				{
+					"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
+				}
+		)
+	
+	def _start_tracking_heap_objects_impl(self, track_allocations: Optional[bool] = None) -> None:
+		return self._execute_function(
+				"HeapProfiler.startTrackingHeapObjects",
+				{"track_allocations": track_allocations}
+		)
+	
+	def _stop_sampling_impl(self) -> Dict[str, Any]:
+		return self._execute_function("HeapProfiler.stopSampling", {})
+	
+	def _stop_tracking_heap_objects_impl(
+			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 self._execute_function(
+				"HeapProfiler.stopTrackingHeapObjects",
+				{
+					"report_progress": report_progress,
+					"treat_global_objects_as_roots": treat_global_objects_as_roots,
+					"capture_numeric_value": capture_numeric_value,
+					"expose_internals": expose_internals
+				}
+		)
+	
+	def _take_heap_snapshot_impl(
+			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 self._execute_function(
+				"HeapProfiler.takeHeapSnapshot",
+				{
+					"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/unified/cdp/indexed_db.py

@@ -0,0 +1,157 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedIndexedDbCDPExecutor"]
+
+
+class UnifiedIndexedDbCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _clear_object_store_impl(
+			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._execute_function(
+				"IndexedDB.clearObjectStore",
+				{
+					"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_impl(
+			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._execute_function(
+				"IndexedDB.deleteDatabase",
+				{
+					"security_origin": security_origin,
+					"storage_key": storage_key,
+					"storage_bucket": storage_bucket,
+					"database_name": database_name
+				}
+		)
+	
+	def _delete_object_store_entries_impl(
+			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._execute_function(
+				"IndexedDB.deleteObjectStoreEntries",
+				{
+					"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_impl(self) -> None:
+		return self._execute_function("IndexedDB.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("IndexedDB.enable", {})
+	
+	def _get_metadata_impl(
+			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._execute_function(
+				"IndexedDB.getMetadata",
+				{
+					"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_impl(
+			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._execute_function(
+				"IndexedDB.requestData",
+				{
+					"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_impl(
+			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._execute_function(
+				"IndexedDB.requestDatabase",
+				{
+					"security_origin": security_origin,
+					"storage_key": storage_key,
+					"storage_bucket": storage_bucket,
+					"database_name": database_name
+				}
+		)
+	
+	def _request_database_names_impl(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None
+	) -> List[str]:
+		return self._execute_function(
+				"IndexedDB.requestDatabaseNames",
+				{
+					"security_origin": security_origin,
+					"storage_key": storage_key,
+					"storage_bucket": storage_bucket
+				}
+		)

osn_selenium/executors/unified/cdp/input.py

@@ -0,0 +1,254 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["UnifiedInputCDPExecutor"]
+
+
+class UnifiedInputCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _cancel_dragging_impl(self) -> None:
+		return self._execute_function("Input.cancelDragging", {})
+	
+	def _dispatch_drag_event_impl(
+			self,
+			type_: str,
+			x: float,
+			y: float,
+			data: Dict[str, Any],
+			modifiers: Optional[int] = None
+	) -> None:
+		return self._execute_function(
+				"Input.dispatchDragEvent",
+				{"type_": type_, "x": x, "y": y, "data": data, "modifiers": modifiers}
+		)
+	
+	def _dispatch_key_event_impl(
+			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._execute_function(
+				"Input.dispatchKeyEvent",
+				{
+					"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_impl(
+			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._execute_function(
+				"Input.dispatchMouseEvent",
+				{
+					"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_impl(
+			self,
+			type_: str,
+			touch_points: List[Dict[str, Any]],
+			modifiers: Optional[int] = None,
+			timestamp: Optional[float] = None
+	) -> None:
+		return self._execute_function(
+				"Input.dispatchTouchEvent",
+				{
+					"type_": type_,
+					"touch_points": touch_points,
+					"modifiers": modifiers,
+					"timestamp": timestamp
+				}
+		)
+	
+	def _emulate_touch_from_mouse_event_impl(
+			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._execute_function(
+				"Input.emulateTouchFromMouseEvent",
+				{
+					"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_impl(
+			self,
+			text: str,
+			selection_start: int,
+			selection_end: int,
+			replacement_start: Optional[int] = None,
+			replacement_end: Optional[int] = None
+	) -> None:
+		return self._execute_function(
+				"Input.imeSetComposition",
+				{
+					"text": text,
+					"selection_start": selection_start,
+					"selection_end": selection_end,
+					"replacement_start": replacement_start,
+					"replacement_end": replacement_end
+				}
+		)
+	
+	def _insert_text_impl(self, text: str) -> None:
+		return self._execute_function("Input.insertText", {"text": text})
+	
+	def _set_ignore_input_events_impl(self, ignore: bool) -> None:
+		return self._execute_function("Input.setIgnoreInputEvents", {"ignore": ignore})
+	
+	def _set_intercept_drags_impl(self, enabled: bool) -> None:
+		return self._execute_function("Input.setInterceptDrags", {"enabled": enabled})
+	
+	def _synthesize_pinch_gesture_impl(
+			self,
+			x: float,
+			y: float,
+			scale_factor: float,
+			relative_speed: Optional[int] = None,
+			gesture_source_type: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Input.synthesizePinchGesture",
+				{
+					"x": x,
+					"y": y,
+					"scale_factor": scale_factor,
+					"relative_speed": relative_speed,
+					"gesture_source_type": gesture_source_type
+				}
+		)
+	
+	def _synthesize_scroll_gesture_impl(
+			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._execute_function(
+				"Input.synthesizeScrollGesture",
+				{
+					"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_impl(
+			self,
+			x: float,
+			y: float,
+			duration: Optional[int] = None,
+			tap_count: Optional[int] = None,
+			gesture_source_type: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Input.synthesizeTapGesture",
+				{
+					"x": x,
+					"y": y,
+					"duration": duration,
+					"tap_count": tap_count,
+					"gesture_source_type": gesture_source_type
+				}
+		)

osn_selenium/executors/unified/cdp/inspector.py

@@ -0,0 +1,15 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedInspectorCDPExecutor"]
+
+
+class UnifiedInspectorCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Inspector.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Inspector.enable", {})