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

osn_selenium/executors/unified/cdp/fetch.py

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

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

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

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

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

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

@@ -1,15 +0,0 @@
-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", {})