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

osn_selenium/executors/unified/cdp/profiler.py

@@ -0,0 +1,55 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedProfilerCDPExecutor"]
+
+
+class UnifiedProfilerCDPExecutor:
+	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("Profiler.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Profiler.enable", {})
+	
+	def _get_best_effort_coverage_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("Profiler.getBestEffortCoverage", {})
+	
+	def _set_sampling_interval_impl(self, interval: int) -> None:
+		return self._execute_function("Profiler.setSamplingInterval", {"interval": interval})
+	
+	def _start_impl(self) -> None:
+		return self._execute_function("Profiler.start", {})
+	
+	def _start_precise_coverage_impl(
+			self,
+			call_count: Optional[bool] = None,
+			detailed: Optional[bool] = None,
+			allow_triggered_updates: Optional[bool] = None
+	) -> float:
+		return self._execute_function(
+				"Profiler.startPreciseCoverage",
+				{
+					"call_count": call_count,
+					"detailed": detailed,
+					"allow_triggered_updates": allow_triggered_updates
+				}
+		)
+	
+	def _stop_impl(self) -> Dict[str, Any]:
+		return self._execute_function("Profiler.stop", {})
+	
+	def _stop_precise_coverage_impl(self) -> None:
+		return self._execute_function("Profiler.stopPreciseCoverage", {})
+	
+	def _take_precise_coverage_impl(self) -> Tuple[List[Dict[str, Any]], float]:
+		return self._execute_function("Profiler.takePreciseCoverage", {})

osn_selenium/executors/unified/cdp/pwa.py

@@ -0,0 +1,55 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedPwaCDPExecutor"]
+
+
+class UnifiedPwaCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _change_app_user_settings_impl(
+			self,
+			manifest_id: str,
+			link_capturing: Optional[bool] = None,
+			display_mode: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"PWA.changeAppUserSettings",
+				{
+					"manifest_id": manifest_id,
+					"link_capturing": link_capturing,
+					"display_mode": display_mode
+				}
+		)
+	
+	def _get_os_app_state_impl(self, manifest_id: str) -> Tuple[int, List[Dict[str, Any]]]:
+		return self._execute_function("PWA.getOsAppState", {"manifest_id": manifest_id})
+	
+	def _install_impl(self, manifest_id: str, install_url_or_bundle_url: Optional[str] = None) -> None:
+		return self._execute_function(
+				"PWA.install",
+				{
+					"manifest_id": manifest_id,
+					"install_url_or_bundle_url": install_url_or_bundle_url
+				}
+		)
+	
+	def _launch_files_in_app_impl(self, manifest_id: str, files: List[str]) -> List[str]:
+		return self._execute_function("PWA.launchFilesInApp", {"manifest_id": manifest_id, "files": files})
+	
+	def _launch_impl(self, manifest_id: str, url: Optional[str] = None) -> str:
+		return self._execute_function("PWA.launch", {"manifest_id": manifest_id, "url": url})
+	
+	def _open_current_page_in_app_impl(self, manifest_id: str) -> None:
+		return self._execute_function("PWA.openCurrentPageInApp", {"manifest_id": manifest_id})
+	
+	def _uninstall_impl(self, manifest_id: str) -> None:
+		return self._execute_function("PWA.uninstall", {"manifest_id": manifest_id})

osn_selenium/executors/unified/cdp/runtime.py

@@ -0,0 +1,245 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedRuntimeCDPExecutor"]
+
+
+class UnifiedRuntimeCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _add_binding_impl(
+			self,
+			name: str,
+			execution_context_id: Optional[int] = None,
+			execution_context_name: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Runtime.addBinding",
+				{
+					"name": name,
+					"execution_context_id": execution_context_id,
+					"execution_context_name": execution_context_name
+				}
+		)
+	
+	def _await_promise_impl(
+			self,
+			promise_object_id: str,
+			return_by_value: Optional[bool] = None,
+			generate_preview: Optional[bool] = None
+	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+		return self._execute_function(
+				"Runtime.awaitPromise",
+				{
+					"promise_object_id": promise_object_id,
+					"return_by_value": return_by_value,
+					"generate_preview": generate_preview
+				}
+		)
+	
+	def _call_function_on_impl(
+			self,
+			function_declaration: str,
+			object_id: Optional[str] = None,
+			arguments: Optional[List[Dict[str, Any]]] = None,
+			silent: Optional[bool] = None,
+			return_by_value: Optional[bool] = None,
+			generate_preview: Optional[bool] = None,
+			user_gesture: Optional[bool] = None,
+			await_promise: Optional[bool] = None,
+			execution_context_id: Optional[int] = None,
+			object_group: Optional[str] = None,
+			throw_on_side_effect: Optional[bool] = None,
+			unique_context_id: Optional[str] = None,
+			serialization_options: Optional[Dict[str, Any]] = None
+	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+		return self._execute_function(
+				"Runtime.callFunctionOn",
+				{
+					"function_declaration": function_declaration,
+					"object_id": object_id,
+					"arguments": arguments,
+					"silent": silent,
+					"return_by_value": return_by_value,
+					"generate_preview": generate_preview,
+					"user_gesture": user_gesture,
+					"await_promise": await_promise,
+					"execution_context_id": execution_context_id,
+					"object_group": object_group,
+					"throw_on_side_effect": throw_on_side_effect,
+					"unique_context_id": unique_context_id,
+					"serialization_options": serialization_options
+				}
+		)
+	
+	def _compile_script_impl(
+			self,
+			expression: str,
+			source_url: str,
+			persist_script: bool,
+			execution_context_id: Optional[int] = None
+	) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
+		return self._execute_function(
+				"Runtime.compileScript",
+				{
+					"expression": expression,
+					"source_url": source_url,
+					"persist_script": persist_script,
+					"execution_context_id": execution_context_id
+				}
+		)
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Runtime.disable", {})
+	
+	def _discard_console_entries_impl(self) -> None:
+		return self._execute_function("Runtime.discardConsoleEntries", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Runtime.enable", {})
+	
+	def _evaluate_impl(
+			self,
+			expression: str,
+			object_group: Optional[str] = None,
+			include_command_line_api: Optional[bool] = None,
+			silent: Optional[bool] = None,
+			context_id: Optional[int] = None,
+			return_by_value: Optional[bool] = None,
+			generate_preview: Optional[bool] = None,
+			user_gesture: Optional[bool] = None,
+			await_promise: Optional[bool] = None,
+			throw_on_side_effect: Optional[bool] = None,
+			timeout: Optional[float] = None,
+			disable_breaks: Optional[bool] = None,
+			repl_mode: Optional[bool] = None,
+			allow_unsafe_eval_blocked_by_csp: Optional[bool] = None,
+			unique_context_id: Optional[str] = None,
+			serialization_options: Optional[Dict[str, Any]] = None
+	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+		return self._execute_function(
+				"Runtime.evaluate",
+				{
+					"expression": expression,
+					"object_group": object_group,
+					"include_command_line_api": include_command_line_api,
+					"silent": silent,
+					"context_id": context_id,
+					"return_by_value": return_by_value,
+					"generate_preview": generate_preview,
+					"user_gesture": user_gesture,
+					"await_promise": await_promise,
+					"throw_on_side_effect": throw_on_side_effect,
+					"timeout": timeout,
+					"disable_breaks": disable_breaks,
+					"repl_mode": repl_mode,
+					"allow_unsafe_eval_blocked_by_csp": allow_unsafe_eval_blocked_by_csp,
+					"unique_context_id": unique_context_id,
+					"serialization_options": serialization_options
+				}
+		)
+	
+	def _get_exception_details_impl(self, error_object_id: str) -> Optional[Dict[str, Any]]:
+		return self._execute_function("Runtime.getExceptionDetails", {"error_object_id": error_object_id})
+	
+	def _get_heap_usage_impl(self) -> Tuple[float, float, float, float]:
+		return self._execute_function("Runtime.getHeapUsage", {})
+	
+	def _get_isolate_id_impl(self) -> str:
+		return self._execute_function("Runtime.getIsolateId", {})
+	
+	def _get_properties_impl(
+			self,
+			object_id: str,
+			own_properties: Optional[bool] = None,
+			accessor_properties_only: Optional[bool] = None,
+			generate_preview: Optional[bool] = None,
+			non_indexed_properties_only: Optional[bool] = None
+	) -> Tuple[
+		List[Dict[str, Any]],
+		Optional[List[Dict[str, Any]]],
+		Optional[List[Dict[str, Any]]],
+		Optional[Dict[str, Any]]
+	]:
+		return self._execute_function(
+				"Runtime.getProperties",
+				{
+					"object_id": object_id,
+					"own_properties": own_properties,
+					"accessor_properties_only": accessor_properties_only,
+					"generate_preview": generate_preview,
+					"non_indexed_properties_only": non_indexed_properties_only
+				}
+		)
+	
+	def _global_lexical_scope_names_impl(self, execution_context_id: Optional[int] = None) -> List[str]:
+		return self._execute_function(
+				"Runtime.globalLexicalScopeNames",
+				{"execution_context_id": execution_context_id}
+		)
+	
+	def _query_objects_impl(self, prototype_object_id: str, object_group: Optional[str] = None) -> Dict[str, Any]:
+		return self._execute_function(
+				"Runtime.queryObjects",
+				{
+					"prototype_object_id": prototype_object_id,
+					"object_group": object_group
+				}
+		)
+	
+	def _release_object_group_impl(self, object_group: str) -> None:
+		return self._execute_function("Runtime.releaseObjectGroup", {"object_group": object_group})
+	
+	def _release_object_impl(self, object_id: str) -> None:
+		return self._execute_function("Runtime.releaseObject", {"object_id": object_id})
+	
+	def _remove_binding_impl(self, name: str) -> None:
+		return self._execute_function("Runtime.removeBinding", {"name": name})
+	
+	def _run_if_waiting_for_debugger_impl(self) -> None:
+		return self._execute_function("Runtime.runIfWaitingForDebugger", {})
+	
+	def _run_script_impl(
+			self,
+			script_id: str,
+			execution_context_id: Optional[int] = None,
+			object_group: Optional[str] = None,
+			silent: Optional[bool] = None,
+			include_command_line_api: Optional[bool] = None,
+			return_by_value: Optional[bool] = None,
+			generate_preview: Optional[bool] = None,
+			await_promise: Optional[bool] = None
+	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+		return self._execute_function(
+				"Runtime.runScript",
+				{
+					"script_id": script_id,
+					"execution_context_id": execution_context_id,
+					"object_group": object_group,
+					"silent": silent,
+					"include_command_line_api": include_command_line_api,
+					"return_by_value": return_by_value,
+					"generate_preview": generate_preview,
+					"await_promise": await_promise
+				}
+		)
+	
+	def _set_async_call_stack_depth_impl(self, max_depth: int) -> None:
+		return self._execute_function("Runtime.setAsyncCallStackDepth", {"max_depth": max_depth})
+	
+	def _set_custom_object_formatter_enabled_impl(self, enabled: bool) -> None:
+		return self._execute_function("Runtime.setCustomObjectFormatterEnabled", {"enabled": enabled})
+	
+	def _set_max_call_stack_size_to_capture_impl(self, size: int) -> None:
+		return self._execute_function("Runtime.setMaxCallStackSizeToCapture", {"size": size})
+	
+	def _terminate_execution_impl(self) -> None:
+		return self._execute_function("Runtime.terminateExecution", {})

osn_selenium/executors/unified/cdp/schema.py

@@ -0,0 +1,17 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List
+)
+
+
+__all__ = ["UnifiedSchemaCDPExecutor"]
+
+
+class UnifiedSchemaCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _get_domains_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("Schema.getDomains", {})

osn_selenium/executors/unified/cdp/security.py

@@ -0,0 +1,27 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedSecurityCDPExecutor"]
+
+
+class UnifiedSecurityCDPExecutor:
+	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("Security.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Security.enable", {})
+	
+	def _handle_certificate_error_impl(self, event_id: int, action: str) -> None:
+		return self._execute_function(
+				"Security.handleCertificateError",
+				{"event_id": event_id, "action": action}
+		)
+	
+	def _set_ignore_certificate_errors_impl(self, ignore: bool) -> None:
+		return self._execute_function("Security.setIgnoreCertificateErrors", {"ignore": ignore})
+	
+	def _set_override_certificate_errors_impl(self, override: bool) -> None:
+		return self._execute_function("Security.setOverrideCertificateErrors", {"override": override})

osn_selenium/executors/unified/cdp/service_worker.py

@@ -0,0 +1,62 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedServiceWorkerCDPExecutor"]
+
+
+class UnifiedServiceWorkerCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _deliver_push_message_impl(self, origin: str, registration_id: str, data: str) -> None:
+		return self._execute_function(
+				"ServiceWorker.deliverPushMessage",
+				{"origin": origin, "registration_id": registration_id, "data": data}
+		)
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("ServiceWorker.disable", {})
+	
+	def _dispatch_periodic_sync_event_impl(self, origin: str, registration_id: str, tag: str) -> None:
+		return self._execute_function(
+				"ServiceWorker.dispatchPeriodicSyncEvent",
+				{"origin": origin, "registration_id": registration_id, "tag": tag}
+		)
+	
+	def _dispatch_sync_event_impl(self, origin: str, registration_id: str, tag: str, last_chance: bool) -> None:
+		return self._execute_function(
+				"ServiceWorker.dispatchSyncEvent",
+				{
+					"origin": origin,
+					"registration_id": registration_id,
+					"tag": tag,
+					"last_chance": last_chance
+				}
+		)
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("ServiceWorker.enable", {})
+	
+	def _set_force_update_on_page_load_impl(self, force_update_on_page_load: bool) -> None:
+		return self._execute_function(
+				"ServiceWorker.setForceUpdateOnPageLoad",
+				{"force_update_on_page_load": force_update_on_page_load}
+		)
+	
+	def _skip_waiting_impl(self, scope_url: str) -> None:
+		return self._execute_function("ServiceWorker.skipWaiting", {"scope_url": scope_url})
+	
+	def _start_worker_impl(self, scope_url: str) -> None:
+		return self._execute_function("ServiceWorker.startWorker", {"scope_url": scope_url})
+	
+	def _stop_all_workers_impl(self) -> None:
+		return self._execute_function("ServiceWorker.stopAllWorkers", {})
+	
+	def _stop_worker_impl(self, version_id: str) -> None:
+		return self._execute_function("ServiceWorker.stopWorker", {"version_id": version_id})
+	
+	def _unregister_impl(self, scope_url: str) -> None:
+		return self._execute_function("ServiceWorker.unregister", {"scope_url": scope_url})
+	
+	def _update_registration_impl(self, scope_url: str) -> None:
+		return self._execute_function("ServiceWorker.updateRegistration", {"scope_url": scope_url})

osn_selenium/executors/unified/cdp/storage.py

@@ -0,0 +1,178 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedStorageCDPExecutor"]
+
+
+class UnifiedStorageCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _clear_cookies_impl(self, browser_context_id: Optional[str] = None) -> None:
+		return self._execute_function("Storage.clearCookies", {"browser_context_id": browser_context_id})
+	
+	def _clear_data_for_origin_impl(self, origin: str, storage_types: str) -> None:
+		return self._execute_function(
+				"Storage.clearDataForOrigin",
+				{"origin": origin, "storage_types": storage_types}
+		)
+	
+	def _clear_data_for_storage_key_impl(self, storage_key: str, storage_types: str) -> None:
+		return self._execute_function(
+				"Storage.clearDataForStorageKey",
+				{"storage_key": storage_key, "storage_types": storage_types}
+		)
+	
+	def _clear_shared_storage_entries_impl(self, owner_origin: str) -> None:
+		return self._execute_function("Storage.clearSharedStorageEntries", {"owner_origin": owner_origin})
+	
+	def _clear_trust_tokens_impl(self, issuer_origin: str) -> bool:
+		return self._execute_function("Storage.clearTrustTokens", {"issuer_origin": issuer_origin})
+	
+	def _delete_shared_storage_entry_impl(self, owner_origin: str, key: str) -> None:
+		return self._execute_function(
+				"Storage.deleteSharedStorageEntry",
+				{"owner_origin": owner_origin, "key": key}
+		)
+	
+	def _delete_storage_bucket_impl(self, bucket: Dict[str, Any]) -> None:
+		return self._execute_function("Storage.deleteStorageBucket", {"bucket": bucket})
+	
+	def _get_affected_urls_for_third_party_cookie_metadata_impl(self, first_party_url: str, third_party_urls: List[str]) -> List[str]:
+		return self._execute_function(
+				"Storage.getAffectedUrlsForThirdPartyCookieMetadata",
+				{
+					"first_party_url": first_party_url,
+					"third_party_urls": third_party_urls
+				}
+		)
+	
+	def _get_cookies_impl(self, browser_context_id: Optional[str] = None) -> List[Dict[str, Any]]:
+		return self._execute_function("Storage.getCookies", {"browser_context_id": browser_context_id})
+	
+	def _get_interest_group_details_impl(self, owner_origin: str, name: str) -> Any:
+		return self._execute_function(
+				"Storage.getInterestGroupDetails",
+				{"owner_origin": owner_origin, "name": name}
+		)
+	
+	def _get_related_website_sets_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("Storage.getRelatedWebsiteSets", {})
+	
+	def _get_shared_storage_entries_impl(self, owner_origin: str) -> List[Dict[str, Any]]:
+		return self._execute_function("Storage.getSharedStorageEntries", {"owner_origin": owner_origin})
+	
+	def _get_shared_storage_metadata_impl(self, owner_origin: str) -> Dict[str, Any]:
+		return self._execute_function("Storage.getSharedStorageMetadata", {"owner_origin": owner_origin})
+	
+	def _get_storage_key_for_frame_impl(self, frame_id: str) -> str:
+		return self._execute_function("Storage.getStorageKeyForFrame", {"frame_id": frame_id})
+	
+	def _get_storage_key_impl(self, frame_id: Optional[str] = None) -> str:
+		return self._execute_function("Storage.getStorageKey", {"frame_id": frame_id})
+	
+	def _get_trust_tokens_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("Storage.getTrustTokens", {})
+	
+	def _get_usage_and_quota_impl(self, origin: str) -> Tuple[float, float, bool, List[Dict[str, Any]]]:
+		return self._execute_function("Storage.getUsageAndQuota", {"origin": origin})
+	
+	def _override_quota_for_origin_impl(self, origin: str, quota_size: Optional[float] = None) -> None:
+		return self._execute_function(
+				"Storage.overrideQuotaForOrigin",
+				{"origin": origin, "quota_size": quota_size}
+		)
+	
+	def _reset_shared_storage_budget_impl(self, owner_origin: str) -> None:
+		return self._execute_function("Storage.resetSharedStorageBudget", {"owner_origin": owner_origin})
+	
+	def _run_bounce_tracking_mitigations_impl(self) -> List[str]:
+		return self._execute_function("Storage.runBounceTrackingMitigations", {})
+	
+	def _send_pending_attribution_reports_impl(self) -> int:
+		return self._execute_function("Storage.sendPendingAttributionReports", {})
+	
+	def _set_attribution_reporting_local_testing_mode_impl(self, enabled: bool) -> None:
+		return self._execute_function("Storage.setAttributionReportingLocalTestingMode", {"enabled": enabled})
+	
+	def _set_attribution_reporting_tracking_impl(self, enable: bool) -> None:
+		return self._execute_function("Storage.setAttributionReportingTracking", {"enable": enable})
+	
+	def _set_cookies_impl(
+			self,
+			cookies: List[Dict[str, Any]],
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Storage.setCookies",
+				{"cookies": cookies, "browser_context_id": browser_context_id}
+		)
+	
+	def _set_interest_group_auction_tracking_impl(self, enable: bool) -> None:
+		return self._execute_function("Storage.setInterestGroupAuctionTracking", {"enable": enable})
+	
+	def _set_interest_group_tracking_impl(self, enable: bool) -> None:
+		return self._execute_function("Storage.setInterestGroupTracking", {"enable": enable})
+	
+	def _set_protected_audience_k_anonymity_impl(self, owner: str, name: str, hashes: List[str]) -> None:
+		return self._execute_function(
+				"Storage.setProtectedAudienceKAnonymity",
+				{"owner": owner, "name": name, "hashes": hashes}
+		)
+	
+	def _set_shared_storage_entry_impl(
+			self,
+			owner_origin: str,
+			key: str,
+			value: str,
+			ignore_if_present: Optional[bool] = None
+	) -> None:
+		return self._execute_function(
+				"Storage.setSharedStorageEntry",
+				{
+					"owner_origin": owner_origin,
+					"key": key,
+					"value": value,
+					"ignore_if_present": ignore_if_present
+				}
+		)
+	
+	def _set_shared_storage_tracking_impl(self, enable: bool) -> None:
+		return self._execute_function("Storage.setSharedStorageTracking", {"enable": enable})
+	
+	def _set_storage_bucket_tracking_impl(self, storage_key: str, enable: bool) -> None:
+		return self._execute_function(
+				"Storage.setStorageBucketTracking",
+				{"storage_key": storage_key, "enable": enable}
+		)
+	
+	def _track_cache_storage_for_origin_impl(self, origin: str) -> None:
+		return self._execute_function("Storage.trackCacheStorageForOrigin", {"origin": origin})
+	
+	def _track_cache_storage_for_storage_key_impl(self, storage_key: str) -> None:
+		return self._execute_function("Storage.trackCacheStorageForStorageKey", {"storage_key": storage_key})
+	
+	def _track_indexed_db_for_origin_impl(self, origin: str) -> None:
+		return self._execute_function("Storage.trackIndexedDBForOrigin", {"origin": origin})
+	
+	def _track_indexed_db_for_storage_key_impl(self, storage_key: str) -> None:
+		return self._execute_function("Storage.trackIndexedDBForStorageKey", {"storage_key": storage_key})
+	
+	def _untrack_cache_storage_for_origin_impl(self, origin: str) -> None:
+		return self._execute_function("Storage.untrackCacheStorageForOrigin", {"origin": origin})
+	
+	def _untrack_cache_storage_for_storage_key_impl(self, storage_key: str) -> None:
+		return self._execute_function("Storage.untrackCacheStorageForStorageKey", {"storage_key": storage_key})
+	
+	def _untrack_indexed_db_for_origin_impl(self, origin: str) -> None:
+		return self._execute_function("Storage.untrackIndexedDBForOrigin", {"origin": origin})
+	
+	def _untrack_indexed_db_for_storage_key_impl(self, storage_key: str) -> None:
+		return self._execute_function("Storage.untrackIndexedDBForStorageKey", {"storage_key": storage_key})

osn_selenium/executors/unified/cdp/system_info.py

@@ -0,0 +1,24 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Tuple
+)
+
+
+__all__ = ["UnifiedSystemInfoCDPExecutor"]
+
+
+class UnifiedSystemInfoCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _get_feature_state_impl(self, feature_state: str) -> bool:
+		return self._execute_function("SystemInfo.getFeatureState", {"feature_state": feature_state})
+	
+	def _get_info_impl(self) -> Tuple[Dict[str, Any], str, str, str]:
+		return self._execute_function("SystemInfo.getInfo", {})
+	
+	def _get_process_info_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("SystemInfo.getProcessInfo", {})