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

osn_selenium/executors/unified/cdp/io.py

@@ -1,29 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	Optional,
-	Tuple
-)
-
-
-__all__ = ["UnifiedIoCDPExecutor"]
-
-
-class UnifiedIoCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _close_impl(self, handle: str) -> None:
-		return self._execute_function("IO.close", {"handle": handle})
-	
-	def _read_impl(
-			self,
-			handle: str,
-			offset: Optional[int] = None,
-			size: Optional[int] = None
-	) -> Tuple[Optional[bool], str, bool]:
-		return self._execute_function("IO.read", {"handle": handle, "offset": offset, "size": size})
-	
-	def _resolve_blob_impl(self, object_id: str) -> str:
-		return self._execute_function("IO.resolveBlob", {"object_id": object_id})

osn_selenium/executors/unified/cdp/layer_tree.py

@@ -1,71 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional,
-	Tuple
-)
-
-
-__all__ = ["UnifiedLayerTreeCDPExecutor"]
-
-
-class UnifiedLayerTreeCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _compositing_reasons_impl(self, layer_id: str) -> Tuple[List[str], List[str]]:
-		return self._execute_function("LayerTree.compositingReasons", {"layer_id": layer_id})
-	
-	def _disable_impl(self) -> None:
-		return self._execute_function("LayerTree.disable", {})
-	
-	def _enable_impl(self) -> None:
-		return self._execute_function("LayerTree.enable", {})
-	
-	def _load_snapshot_impl(self, tiles: List[Dict[str, Any]]) -> str:
-		return self._execute_function("LayerTree.loadSnapshot", {"tiles": tiles})
-	
-	def _make_snapshot_impl(self, layer_id: str) -> str:
-		return self._execute_function("LayerTree.makeSnapshot", {"layer_id": layer_id})
-	
-	def _profile_snapshot_impl(
-			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._execute_function(
-				"LayerTree.profileSnapshot",
-				{
-					"snapshot_id": snapshot_id,
-					"min_repeat_count": min_repeat_count,
-					"min_duration": min_duration,
-					"clip_rect": clip_rect
-				}
-		)
-	
-	def _release_snapshot_impl(self, snapshot_id: str) -> None:
-		return self._execute_function("LayerTree.releaseSnapshot", {"snapshot_id": snapshot_id})
-	
-	def _replay_snapshot_impl(
-			self,
-			snapshot_id: str,
-			from_step: Optional[int] = None,
-			to_step: Optional[int] = None,
-			scale: Optional[float] = None
-	) -> str:
-		return self._execute_function(
-				"LayerTree.replaySnapshot",
-				{
-					"snapshot_id": snapshot_id,
-					"from_step": from_step,
-					"to_step": to_step,
-					"scale": scale
-				}
-		)
-	
-	def _snapshot_command_log_impl(self, snapshot_id: str) -> List[Any]:
-		return self._execute_function("LayerTree.snapshotCommandLog", {"snapshot_id": snapshot_id})

osn_selenium/executors/unified/cdp/log.py

@@ -1,29 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List
-)
-
-
-__all__ = ["UnifiedLogCDPExecutor"]
-
-
-class UnifiedLogCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _clear_impl(self) -> None:
-		return self._execute_function("Log.clear", {})
-	
-	def _disable_impl(self) -> None:
-		return self._execute_function("Log.disable", {})
-	
-	def _enable_impl(self) -> None:
-		return self._execute_function("Log.enable", {})
-	
-	def _start_violations_report_impl(self, config: List[Dict[str, Any]]) -> None:
-		return self._execute_function("Log.startViolationsReport", {"config": config})
-	
-	def _stop_violations_report_impl(self) -> None:
-		return self._execute_function("Log.stopViolationsReport", {})

osn_selenium/executors/unified/cdp/media.py

@@ -1,15 +0,0 @@
-from typing import Any, Callable, Dict
-
-
-__all__ = ["UnifiedMediaCDPExecutor"]
-
-
-class UnifiedMediaCDPExecutor:
-	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("Media.disable", {})
-	
-	def _enable_impl(self) -> None:
-		return self._execute_function("Media.enable", {})

osn_selenium/executors/unified/cdp/memory.py

@@ -1,59 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional,
-	Tuple
-)
-
-
-__all__ = ["UnifiedMemoryCDPExecutor"]
-
-
-class UnifiedMemoryCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _forcibly_purge_java_script_memory_impl(self) -> None:
-		return self._execute_function("Memory.forciblyPurgeJavaScriptMemory", {})
-	
-	def _get_all_time_sampling_profile_impl(self) -> Dict[str, Any]:
-		return self._execute_function("Memory.getAllTimeSamplingProfile", {})
-	
-	def _get_browser_sampling_profile_impl(self) -> Dict[str, Any]:
-		return self._execute_function("Memory.getBrowserSamplingProfile", {})
-	
-	def _get_dom_counters_for_leak_detection_impl(self) -> List[Dict[str, Any]]:
-		return self._execute_function("Memory.getDOMCountersForLeakDetection", {})
-	
-	def _get_dom_counters_impl(self) -> Tuple[int, int, int]:
-		return self._execute_function("Memory.getDOMCounters", {})
-	
-	def _get_sampling_profile_impl(self) -> Dict[str, Any]:
-		return self._execute_function("Memory.getSamplingProfile", {})
-	
-	def _prepare_for_leak_detection_impl(self) -> None:
-		return self._execute_function("Memory.prepareForLeakDetection", {})
-	
-	def _set_pressure_notifications_suppressed_impl(self, suppressed: bool) -> None:
-		return self._execute_function("Memory.setPressureNotificationsSuppressed", {"suppressed": suppressed})
-	
-	def _simulate_pressure_notification_impl(self, level: str) -> None:
-		return self._execute_function("Memory.simulatePressureNotification", {"level": level})
-	
-	def _start_sampling_impl(
-			self,
-			sampling_interval: Optional[int] = None,
-			suppress_randomness: Optional[bool] = None
-	) -> None:
-		return self._execute_function(
-				"Memory.startSampling",
-				{
-					"sampling_interval": sampling_interval,
-					"suppress_randomness": suppress_randomness
-				}
-		)
-	
-	def _stop_sampling_impl(self) -> None:
-		return self._execute_function("Memory.stopSampling", {})

osn_selenium/executors/unified/cdp/network.py

@@ -1,323 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional,
-	Tuple
-)
-
-
-__all__ = ["UnifiedNetworkCDPExecutor"]
-
-
-class UnifiedNetworkCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _can_clear_browser_cache_impl(self) -> bool:
-		return self._execute_function("Network.canClearBrowserCache", {})
-	
-	def _can_clear_browser_cookies_impl(self) -> bool:
-		return self._execute_function("Network.canClearBrowserCookies", {})
-	
-	def _can_emulate_network_conditions_impl(self) -> bool:
-		return self._execute_function("Network.canEmulateNetworkConditions", {})
-	
-	def _clear_accepted_encodings_override_impl(self) -> None:
-		return self._execute_function("Network.clearAcceptedEncodingsOverride", {})
-	
-	def _clear_browser_cache_impl(self) -> None:
-		return self._execute_function("Network.clearBrowserCache", {})
-	
-	def _clear_browser_cookies_impl(self) -> None:
-		return self._execute_function("Network.clearBrowserCookies", {})
-	
-	def _continue_intercepted_request_impl(
-			self,
-			interception_id: str,
-			error_reason: Optional[str] = None,
-			raw_response: Optional[str] = None,
-			url: Optional[str] = None,
-			method: Optional[str] = None,
-			post_data: Optional[str] = None,
-			headers: Optional[Dict[Any, Any]] = None,
-			auth_challenge_response: Optional[Dict[str, Any]] = None
-	) -> None:
-		return self._execute_function(
-				"Network.continueInterceptedRequest",
-				{
-					"interception_id": interception_id,
-					"error_reason": error_reason,
-					"raw_response": raw_response,
-					"url": url,
-					"method": method,
-					"post_data": post_data,
-					"headers": headers,
-					"auth_challenge_response": auth_challenge_response
-				}
-		)
-	
-	def _delete_cookies_impl(
-			self,
-			name: str,
-			url: Optional[str] = None,
-			domain: Optional[str] = None,
-			path: Optional[str] = None,
-			partition_key: Optional[Dict[str, Any]] = None
-	) -> None:
-		return self._execute_function(
-				"Network.deleteCookies",
-				{
-					"name": name,
-					"url": url,
-					"domain": domain,
-					"path": path,
-					"partition_key": partition_key
-				}
-		)
-	
-	def _disable_impl(self) -> None:
-		return self._execute_function("Network.disable", {})
-	
-	def _emulate_network_conditions_by_rule_impl(self, offline: bool, matched_network_conditions: List[Dict[str, Any]]) -> List[str]:
-		return self._execute_function(
-				"Network.emulateNetworkConditionsByRule",
-				{
-					"offline": offline,
-					"matched_network_conditions": matched_network_conditions
-				}
-		)
-	
-	def _emulate_network_conditions_impl(
-			self,
-			offline: bool,
-			latency: float,
-			download_throughput: float,
-			upload_throughput: float,
-			connection_type: Optional[str] = None,
-			packet_loss: Optional[float] = None,
-			packet_queue_length: Optional[int] = None,
-			packet_reordering: Optional[bool] = None
-	) -> None:
-		return self._execute_function(
-				"Network.emulateNetworkConditions",
-				{
-					"offline": offline,
-					"latency": latency,
-					"download_throughput": download_throughput,
-					"upload_throughput": upload_throughput,
-					"connection_type": connection_type,
-					"packet_loss": packet_loss,
-					"packet_queue_length": packet_queue_length,
-					"packet_reordering": packet_reordering
-				}
-		)
-	
-	def _enable_impl(
-			self,
-			max_total_buffer_size: Optional[int] = None,
-			max_resource_buffer_size: Optional[int] = None,
-			max_post_data_size: Optional[int] = None,
-			report_direct_socket_traffic: Optional[bool] = None,
-			enable_durable_messages: Optional[bool] = None
-	) -> None:
-		return self._execute_function(
-				"Network.enable",
-				{
-					"max_total_buffer_size": max_total_buffer_size,
-					"max_resource_buffer_size": max_resource_buffer_size,
-					"max_post_data_size": max_post_data_size,
-					"report_direct_socket_traffic": report_direct_socket_traffic,
-					"enable_durable_messages": enable_durable_messages
-				}
-		)
-	
-	def _enable_reporting_api_impl(self, enable: bool) -> None:
-		return self._execute_function("Network.enableReportingApi", {"enable": enable})
-	
-	def _get_all_cookies_impl(self) -> List[Dict[str, Any]]:
-		return self._execute_function("Network.getAllCookies", {})
-	
-	def _get_certificate_impl(self, origin: str) -> List[str]:
-		return self._execute_function("Network.getCertificate", {"origin": origin})
-	
-	def _get_cookies_impl(self, urls: Optional[List[str]] = None) -> List[Dict[str, Any]]:
-		return self._execute_function("Network.getCookies", {"urls": urls})
-	
-	def _get_ip_protection_proxy_status_impl(self) -> str:
-		return self._execute_function("Network.getIPProtectionProxyStatus", {})
-	
-	def _get_request_post_data_impl(self, request_id: str) -> str:
-		return self._execute_function("Network.getRequestPostData", {"request_id": request_id})
-	
-	def _get_response_body_for_interception_impl(self, interception_id: str) -> Tuple[str, bool]:
-		return self._execute_function(
-				"Network.getResponseBodyForInterception",
-				{"interception_id": interception_id}
-		)
-	
-	def _get_response_body_impl(self, request_id: str) -> Tuple[str, bool]:
-		return self._execute_function("Network.getResponseBody", {"request_id": request_id})
-	
-	def _get_security_isolation_status_impl(self, frame_id: Optional[str] = None) -> Dict[str, Any]:
-		return self._execute_function("Network.getSecurityIsolationStatus", {"frame_id": frame_id})
-	
-	def _load_network_resource_impl(
-			self,
-			frame_id: Optional[str] = None,
-			url: str = None,
-			options: Dict[str, Any] = None
-	) -> Dict[str, Any]:
-		return self._execute_function(
-				"Network.loadNetworkResource",
-				{"frame_id": frame_id, "url": url, "options": options}
-		)
-	
-	def _override_network_state_impl(
-			self,
-			offline: bool,
-			latency: float,
-			download_throughput: float,
-			upload_throughput: float,
-			connection_type: Optional[str] = None
-	) -> None:
-		return self._execute_function(
-				"Network.overrideNetworkState",
-				{
-					"offline": offline,
-					"latency": latency,
-					"download_throughput": download_throughput,
-					"upload_throughput": upload_throughput,
-					"connection_type": connection_type
-				}
-		)
-	
-	def _replay_xhr_impl(self, request_id: str) -> None:
-		return self._execute_function("Network.replayXHR", {"request_id": request_id})
-	
-	def _search_in_response_body_impl(
-			self,
-			request_id: str,
-			query: str,
-			case_sensitive: Optional[bool] = None,
-			is_regex: Optional[bool] = None
-	) -> List[Dict[str, Any]]:
-		return self._execute_function(
-				"Network.searchInResponseBody",
-				{
-					"request_id": request_id,
-					"query": query,
-					"case_sensitive": case_sensitive,
-					"is_regex": is_regex
-				}
-		)
-	
-	def _set_accepted_encodings_impl(self, encodings: List[str]) -> None:
-		return self._execute_function("Network.setAcceptedEncodings", {"encodings": encodings})
-	
-	def _set_attach_debug_stack_impl(self, enabled: bool) -> None:
-		return self._execute_function("Network.setAttachDebugStack", {"enabled": enabled})
-	
-	def _set_blocked_ur_ls_impl(
-			self,
-			url_patterns: Optional[List[Dict[str, Any]]] = None,
-			urls: Optional[List[str]] = None
-	) -> None:
-		return self._execute_function("Network.setBlockedURLs", {"url_patterns": url_patterns, "urls": urls})
-	
-	def _set_bypass_service_worker_impl(self, bypass: bool) -> None:
-		return self._execute_function("Network.setBypassServiceWorker", {"bypass": bypass})
-	
-	def _set_cache_disabled_impl(self, cache_disabled: bool) -> None:
-		return self._execute_function("Network.setCacheDisabled", {"cache_disabled": cache_disabled})
-	
-	def _set_cookie_controls_impl(
-			self,
-			enable_third_party_cookie_restriction: bool,
-			disable_third_party_cookie_metadata: bool,
-			disable_third_party_cookie_heuristics: bool
-	) -> None:
-		return self._execute_function(
-				"Network.setCookieControls",
-				{
-					"enable_third_party_cookie_restriction": enable_third_party_cookie_restriction,
-					"disable_third_party_cookie_metadata": disable_third_party_cookie_metadata,
-					"disable_third_party_cookie_heuristics": disable_third_party_cookie_heuristics
-				}
-		)
-	
-	def _set_cookie_impl(
-			self,
-			name: str,
-			value: str,
-			url: Optional[str] = None,
-			domain: Optional[str] = None,
-			path: Optional[str] = None,
-			secure: Optional[bool] = None,
-			http_only: Optional[bool] = None,
-			same_site: Optional[str] = None,
-			expires: Optional[float] = None,
-			priority: Optional[str] = None,
-			same_party: Optional[bool] = None,
-			source_scheme: Optional[str] = None,
-			source_port: Optional[int] = None,
-			partition_key: Optional[Dict[str, Any]] = None
-	) -> bool:
-		return self._execute_function(
-				"Network.setCookie",
-				{
-					"name": name,
-					"value": value,
-					"url": url,
-					"domain": domain,
-					"path": path,
-					"secure": secure,
-					"http_only": http_only,
-					"same_site": same_site,
-					"expires": expires,
-					"priority": priority,
-					"same_party": same_party,
-					"source_scheme": source_scheme,
-					"source_port": source_port,
-					"partition_key": partition_key
-				}
-		)
-	
-	def _set_cookies_impl(self, cookies: List[Dict[str, Any]]) -> None:
-		return self._execute_function("Network.setCookies", {"cookies": cookies})
-	
-	def _set_extra_http_headers_impl(self, headers: Dict[Any, Any]) -> None:
-		return self._execute_function("Network.setExtraHTTPHeaders", {"headers": headers})
-	
-	def _set_ip_protection_proxy_bypass_enabled_impl(self, enabled: bool) -> None:
-		return self._execute_function("Network.setIPProtectionProxyBypassEnabled", {"enabled": enabled})
-	
-	def _set_request_interception_impl(self, patterns: List[Dict[str, Any]]) -> None:
-		return self._execute_function("Network.setRequestInterception", {"patterns": patterns})
-	
-	def _set_user_agent_override_impl(
-			self,
-			user_agent: str,
-			accept_language: Optional[str] = None,
-			platform: Optional[str] = None,
-			user_agent_metadata: Optional[Dict[str, Any]] = None
-	) -> None:
-		return self._execute_function(
-				"Network.setUserAgentOverride",
-				{
-					"user_agent": user_agent,
-					"accept_language": accept_language,
-					"platform": platform,
-					"user_agent_metadata": user_agent_metadata
-				}
-		)
-	
-	def _stream_resource_content_impl(self, request_id: str) -> str:
-		return self._execute_function("Network.streamResourceContent", {"request_id": request_id})
-	
-	def _take_response_body_for_interception_as_stream_impl(self, interception_id: str) -> str:
-		return self._execute_function(
-				"Network.takeResponseBodyForInterceptionAsStream",
-				{"interception_id": interception_id}
-		)