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

osn_selenium/executors/unified/cdp/animation.py

@@ -0,0 +1,50 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List
+)
+
+
+__all__ = ["UnifiedAnimationCDPExecutor"]
+
+
+class UnifiedAnimationCDPExecutor:
+	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("Animation.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Animation.enable", {})
+	
+	def _get_current_time_impl(self, id_: str) -> float:
+		return self._execute_function("Animation.getCurrentTime", {"id_": id_})
+	
+	def _get_playback_rate_impl(self) -> float:
+		return self._execute_function("Animation.getPlaybackRate", {})
+	
+	def _release_animations_impl(self, animations: List[str]) -> None:
+		return self._execute_function("Animation.releaseAnimations", {"animations": animations})
+	
+	def _resolve_animation_impl(self, animation_id: str) -> Dict[str, Any]:
+		return self._execute_function("Animation.resolveAnimation", {"animation_id": animation_id})
+	
+	def _seek_animations_impl(self, animations: List[str], current_time: float) -> None:
+		return self._execute_function(
+				"Animation.seekAnimations",
+				{"animations": animations, "current_time": current_time}
+		)
+	
+	def _set_paused_impl(self, animations: List[str], paused: bool) -> None:
+		return self._execute_function("Animation.setPaused", {"animations": animations, "paused": paused})
+	
+	def _set_playback_rate_impl(self, playback_rate: float) -> None:
+		return self._execute_function("Animation.setPlaybackRate", {"playback_rate": playback_rate})
+	
+	def _set_timing_impl(self, animation_id: str, duration: float, delay: float) -> None:
+		return self._execute_function(
+				"Animation.setTiming",
+				{"animation_id": animation_id, "duration": duration, "delay": delay}
+		)

osn_selenium/executors/unified/cdp/audits.py

@@ -0,0 +1,45 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedAuditsCDPExecutor"]
+
+
+class UnifiedAuditsCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _check_contrast_impl(self, report_aaa: Optional[bool] = None) -> None:
+		return self._execute_function("Audits.checkContrast", {"report_aaa": report_aaa})
+	
+	def _check_forms_issues_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("Audits.checkFormsIssues", {})
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Audits.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Audits.enable", {})
+	
+	def _get_encoded_response_impl(
+			self,
+			request_id: str,
+			encoding: str,
+			quality: Optional[float] = None,
+			size_only: Optional[bool] = None
+	) -> Tuple[Optional[str], int, int]:
+		return self._execute_function(
+				"Audits.getEncodedResponse",
+				{
+					"request_id": request_id,
+					"encoding": encoding,
+					"quality": quality,
+					"size_only": size_only
+				}
+		)

osn_selenium/executors/unified/cdp/autofill.py

@@ -0,0 +1,41 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["UnifiedAutofillCDPExecutor"]
+
+
+class UnifiedAutofillCDPExecutor:
+	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("Autofill.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Autofill.enable", {})
+	
+	def _set_addresses_impl(self, addresses: List[Dict[str, Any]]) -> None:
+		return self._execute_function("Autofill.setAddresses", {"addresses": addresses})
+	
+	def _trigger_impl(
+			self,
+			field_id: int,
+			frame_id: Optional[str] = None,
+			card: Optional[Dict[str, Any]] = None,
+			address: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._execute_function(
+				"Autofill.trigger",
+				{
+					"field_id": field_id,
+					"frame_id": frame_id,
+					"card": card,
+					"address": address
+				}
+		)

osn_selenium/executors/unified/cdp/background_service.py

@@ -0,0 +1,24 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedBackgroundServiceCDPExecutor"]
+
+
+class UnifiedBackgroundServiceCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _clear_events_impl(self, service: str) -> None:
+		return self._execute_function("BackgroundService.clearEvents", {"service": service})
+	
+	def _set_recording_impl(self, should_record: bool, service: str) -> None:
+		return self._execute_function(
+				"BackgroundService.setRecording",
+				{"should_record": should_record, "service": service}
+		)
+	
+	def _start_observing_impl(self, service: str) -> None:
+		return self._execute_function("BackgroundService.startObserving", {"service": service})
+	
+	def _stop_observing_impl(self, service: str) -> None:
+		return self._execute_function("BackgroundService.stopObserving", {"service": service})

osn_selenium/executors/unified/cdp/bluetooth_emulation.py

@@ -0,0 +1,132 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["UnifiedBluetoothEmulationCDPExecutor"]
+
+
+class UnifiedBluetoothEmulationCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _add_characteristic_impl(
+			self,
+			service_id: str,
+			characteristic_uuid: str,
+			properties: Dict[str, Any]
+	) -> str:
+		return self._execute_function(
+				"BluetoothEmulation.addCharacteristic",
+				{
+					"service_id": service_id,
+					"characteristic_uuid": characteristic_uuid,
+					"properties": properties
+				}
+		)
+	
+	def _add_descriptor_impl(self, characteristic_id: str, descriptor_uuid: str) -> str:
+		return self._execute_function(
+				"BluetoothEmulation.addDescriptor",
+				{
+					"characteristic_id": characteristic_id,
+					"descriptor_uuid": descriptor_uuid
+				}
+		)
+	
+	def _add_service_impl(self, address: str, service_uuid: str) -> str:
+		return self._execute_function(
+				"BluetoothEmulation.addService",
+				{"address": address, "service_uuid": service_uuid}
+		)
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("BluetoothEmulation.disable", {})
+	
+	def _enable_impl(self, state: str, le_supported: bool) -> None:
+		return self._execute_function(
+				"BluetoothEmulation.enable",
+				{"state": state, "le_supported": le_supported}
+		)
+	
+	def _remove_characteristic_impl(self, characteristic_id: str) -> None:
+		return self._execute_function(
+				"BluetoothEmulation.removeCharacteristic",
+				{"characteristic_id": characteristic_id}
+		)
+	
+	def _remove_descriptor_impl(self, descriptor_id: str) -> None:
+		return self._execute_function("BluetoothEmulation.removeDescriptor", {"descriptor_id": descriptor_id})
+	
+	def _remove_service_impl(self, service_id: str) -> None:
+		return self._execute_function("BluetoothEmulation.removeService", {"service_id": service_id})
+	
+	def _set_simulated_central_state_impl(self, state: str) -> None:
+		return self._execute_function("BluetoothEmulation.setSimulatedCentralState", {"state": state})
+	
+	def _simulate_advertisement_impl(self, entry: Dict[str, Any]) -> None:
+		return self._execute_function("BluetoothEmulation.simulateAdvertisement", {"entry": entry})
+	
+	def _simulate_characteristic_operation_response_impl(
+			self,
+			characteristic_id: str,
+			type_: str,
+			code: int,
+			data: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"BluetoothEmulation.simulateCharacteristicOperationResponse",
+				{
+					"characteristic_id": characteristic_id,
+					"type_": type_,
+					"code": code,
+					"data": data
+				}
+		)
+	
+	def _simulate_descriptor_operation_response_impl(
+			self,
+			descriptor_id: str,
+			type_: str,
+			code: int,
+			data: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"BluetoothEmulation.simulateDescriptorOperationResponse",
+				{
+					"descriptor_id": descriptor_id,
+					"type_": type_,
+					"code": code,
+					"data": data
+				}
+		)
+	
+	def _simulate_gatt_disconnection_impl(self, address: str) -> None:
+		return self._execute_function("BluetoothEmulation.simulateGATTDisconnection", {"address": address})
+	
+	def _simulate_gatt_operation_response_impl(self, address: str, type_: str, code: int) -> None:
+		return self._execute_function(
+				"BluetoothEmulation.simulateGATTOperationResponse",
+				{"address": address, "type_": type_, "code": code}
+		)
+	
+	def _simulate_preconnected_peripheral_impl(
+			self,
+			address: str,
+			name: str,
+			manufacturer_data: List[Dict[str, Any]],
+			known_service_uuids: List[str]
+	) -> None:
+		return self._execute_function(
+				"BluetoothEmulation.simulatePreconnectedPeripheral",
+				{
+					"address": address,
+					"name": name,
+					"manufacturer_data": manufacturer_data,
+					"known_service_uuids": known_service_uuids
+				}
+		)

osn_selenium/executors/unified/cdp/browser.py

@@ -0,0 +1,143 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedBrowserCDPExecutor"]
+
+
+class UnifiedBrowserCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _add_privacy_sandbox_coordinator_key_config_impl(
+			self,
+			api: str,
+			coordinator_origin: str,
+			key_config: str,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Browser.addPrivacySandboxCoordinatorKeyConfig",
+				{
+					"api": api,
+					"coordinator_origin": coordinator_origin,
+					"key_config": key_config,
+					"browser_context_id": browser_context_id
+				}
+		)
+	
+	def _add_privacy_sandbox_enrollment_override_impl(self, url: str) -> None:
+		return self._execute_function("Browser.addPrivacySandboxEnrollmentOverride", {"url": url})
+	
+	def _cancel_download_impl(self, guid: str, browser_context_id: Optional[str] = None) -> None:
+		return self._execute_function(
+				"Browser.cancelDownload",
+				{"guid": guid, "browser_context_id": browser_context_id}
+		)
+	
+	def _close_impl(self) -> None:
+		return self._execute_function("Browser.close", {})
+	
+	def _crash_gpu_process_impl(self) -> None:
+		return self._execute_function("Browser.crashGpuProcess", {})
+	
+	def _crash_impl(self) -> None:
+		return self._execute_function("Browser.crash", {})
+	
+	def _execute_browser_command_impl(self, command_id: str) -> None:
+		return self._execute_function("Browser.executeBrowserCommand", {"command_id": command_id})
+	
+	def _get_browser_command_line_impl(self) -> List[str]:
+		return self._execute_function("Browser.getBrowserCommandLine", {})
+	
+	def _get_histogram_impl(self, name: str, delta: Optional[bool] = None) -> Dict[str, Any]:
+		return self._execute_function("Browser.getHistogram", {"name": name, "delta": delta})
+	
+	def _get_histograms_impl(self, query: Optional[str] = None, delta: Optional[bool] = None) -> List[Dict[str, Any]]:
+		return self._execute_function("Browser.getHistograms", {"query": query, "delta": delta})
+	
+	def _get_version_impl(self) -> Tuple[str, str, str, str, str]:
+		return self._execute_function("Browser.getVersion", {})
+	
+	def _get_window_bounds_impl(self, window_id: int) -> Dict[str, Any]:
+		return self._execute_function("Browser.getWindowBounds", {"window_id": window_id})
+	
+	def _get_window_for_target_impl(self, target_id: Optional[str] = None) -> Tuple[int, Dict[str, Any]]:
+		return self._execute_function("Browser.getWindowForTarget", {"target_id": target_id})
+	
+	def _grant_permissions_impl(
+			self,
+			permissions: List[str],
+			origin: Optional[str] = None,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Browser.grantPermissions",
+				{
+					"permissions": permissions,
+					"origin": origin,
+					"browser_context_id": browser_context_id
+				}
+		)
+	
+	def _reset_permissions_impl(self, browser_context_id: Optional[str] = None) -> None:
+		return self._execute_function("Browser.resetPermissions", {"browser_context_id": browser_context_id})
+	
+	def _set_contents_size_impl(
+			self,
+			window_id: int,
+			width: Optional[int] = None,
+			height: Optional[int] = None
+	) -> None:
+		return self._execute_function(
+				"Browser.setContentsSize",
+				{"window_id": window_id, "width": width, "height": height}
+		)
+	
+	def _set_dock_tile_impl(self, badge_label: Optional[str] = None, image: Optional[str] = None) -> None:
+		return self._execute_function("Browser.setDockTile", {"badge_label": badge_label, "image": image})
+	
+	def _set_download_behavior_impl(
+			self,
+			behavior: str,
+			browser_context_id: Optional[str] = None,
+			download_path: Optional[str] = None,
+			events_enabled: Optional[bool] = None
+	) -> None:
+		return self._execute_function(
+				"Browser.setDownloadBehavior",
+				{
+					"behavior": behavior,
+					"browser_context_id": browser_context_id,
+					"download_path": download_path,
+					"events_enabled": events_enabled
+				}
+		)
+	
+	def _set_permission_impl(
+			self,
+			permission: Dict[str, Any],
+			setting: str,
+			origin: Optional[str] = None,
+			embedded_origin: Optional[str] = None,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Browser.setPermission",
+				{
+					"permission": permission,
+					"setting": setting,
+					"origin": origin,
+					"embedded_origin": embedded_origin,
+					"browser_context_id": browser_context_id
+				}
+		)
+	
+	def _set_window_bounds_impl(self, window_id: int, bounds: Dict[str, Any]) -> None:
+		return self._execute_function("Browser.setWindowBounds", {"window_id": window_id, "bounds": bounds})

osn_selenium/executors/unified/cdp/cache_storage.py

@@ -0,0 +1,69 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedCacheStorageCDPExecutor"]
+
+
+class UnifiedCacheStorageCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _delete_cache_impl(self, cache_id: str) -> None:
+		return self._execute_function("CacheStorage.deleteCache", {"cache_id": cache_id})
+	
+	def _delete_entry_impl(self, cache_id: str, request: str) -> None:
+		return self._execute_function("CacheStorage.deleteEntry", {"cache_id": cache_id, "request": request})
+	
+	def _request_cache_names_impl(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None
+	) -> List[Dict[str, Any]]:
+		return self._execute_function(
+				"CacheStorage.requestCacheNames",
+				{
+					"security_origin": security_origin,
+					"storage_key": storage_key,
+					"storage_bucket": storage_bucket
+				}
+		)
+	
+	def _request_cached_response_impl(
+			self,
+			cache_id: str,
+			request_url: str,
+			request_headers: List[Dict[str, Any]]
+	) -> Dict[str, Any]:
+		return self._execute_function(
+				"CacheStorage.requestCachedResponse",
+				{
+					"cache_id": cache_id,
+					"request_url": request_url,
+					"request_headers": request_headers
+				}
+		)
+	
+	def _request_entries_impl(
+			self,
+			cache_id: str,
+			skip_count: Optional[int] = None,
+			page_size: Optional[int] = None,
+			path_filter: Optional[str] = None
+	) -> Tuple[List[Dict[str, Any]], float]:
+		return self._execute_function(
+				"CacheStorage.requestEntries",
+				{
+					"cache_id": cache_id,
+					"skip_count": skip_count,
+					"page_size": page_size,
+					"path_filter": path_filter
+				}
+		)

osn_selenium/executors/unified/cdp/cast.py

@@ -0,0 +1,32 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+
+
+__all__ = ["UnifiedCastCDPExecutor"]
+
+
+class UnifiedCastCDPExecutor:
+	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("Cast.disable", {})
+	
+	def _enable_impl(self, presentation_url: Optional[str] = None) -> None:
+		return self._execute_function("Cast.enable", {"presentation_url": presentation_url})
+	
+	def _set_sink_to_use_impl(self, sink_name: str) -> None:
+		return self._execute_function("Cast.setSinkToUse", {"sink_name": sink_name})
+	
+	def _start_desktop_mirroring_impl(self, sink_name: str) -> None:
+		return self._execute_function("Cast.startDesktopMirroring", {"sink_name": sink_name})
+	
+	def _start_tab_mirroring_impl(self, sink_name: str) -> None:
+		return self._execute_function("Cast.startTabMirroring", {"sink_name": sink_name})
+	
+	def _stop_casting_impl(self, sink_name: str) -> None:
+		return self._execute_function("Cast.stopCasting", {"sink_name": sink_name})

osn_selenium/executors/unified/cdp/console.py

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