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

osn_selenium/executors/unified/cdp/memory.py

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

@@ -0,0 +1,323 @@
+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}
+		)

osn_selenium/executors/unified/cdp/overlay.py

@@ -0,0 +1,209 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+
+
+__all__ = ["UnifiedOverlayCDPExecutor"]
+
+
+class UnifiedOverlayCDPExecutor:
+	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("Overlay.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("Overlay.enable", {})
+	
+	def _get_grid_highlight_objects_for_test_impl(self, node_ids: List[int]) -> Any:
+		return self._execute_function("Overlay.getGridHighlightObjectsForTest", {"node_ids": node_ids})
+	
+	def _get_highlight_object_for_test_impl(
+			self,
+			node_id: int,
+			include_distance: Optional[bool] = None,
+			include_style: Optional[bool] = None,
+			color_format: Optional[str] = None,
+			show_accessibility_info: Optional[bool] = None
+	) -> Any:
+		return self._execute_function(
+				"Overlay.getHighlightObjectForTest",
+				{
+					"node_id": node_id,
+					"include_distance": include_distance,
+					"include_style": include_style,
+					"color_format": color_format,
+					"show_accessibility_info": show_accessibility_info
+				}
+		)
+	
+	def _get_source_order_highlight_object_for_test_impl(self, node_id: int) -> Any:
+		return self._execute_function("Overlay.getSourceOrderHighlightObjectForTest", {"node_id": node_id})
+	
+	def _hide_highlight_impl(self) -> None:
+		return self._execute_function("Overlay.hideHighlight", {})
+	
+	def _highlight_frame_impl(
+			self,
+			frame_id: str,
+			content_color: Optional[Dict[str, Any]] = None,
+			content_outline_color: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._execute_function(
+				"Overlay.highlightFrame",
+				{
+					"frame_id": frame_id,
+					"content_color": content_color,
+					"content_outline_color": content_outline_color
+				}
+		)
+	
+	def _highlight_node_impl(
+			self,
+			highlight_config: Dict[str, Any],
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			selector: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Overlay.highlightNode",
+				{
+					"highlight_config": highlight_config,
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id,
+					"selector": selector
+				}
+		)
+	
+	def _highlight_quad_impl(
+			self,
+			quad: List[float],
+			color: Optional[Dict[str, Any]] = None,
+			outline_color: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._execute_function(
+				"Overlay.highlightQuad",
+				{"quad": quad, "color": color, "outline_color": outline_color}
+		)
+	
+	def _highlight_rect_impl(
+			self,
+			x: int,
+			y: int,
+			width: int,
+			height: int,
+			color: Optional[Dict[str, Any]] = None,
+			outline_color: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._execute_function(
+				"Overlay.highlightRect",
+				{
+					"x": x,
+					"y": y,
+					"width": width,
+					"height": height,
+					"color": color,
+					"outline_color": outline_color
+				}
+		)
+	
+	def _highlight_source_order_impl(
+			self,
+			source_order_config: Dict[str, Any],
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"Overlay.highlightSourceOrder",
+				{
+					"source_order_config": source_order_config,
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id
+				}
+		)
+	
+	def _set_inspect_mode_impl(self, mode: str, highlight_config: Optional[Dict[str, Any]] = None) -> None:
+		return self._execute_function(
+				"Overlay.setInspectMode",
+				{"mode": mode, "highlight_config": highlight_config}
+		)
+	
+	def _set_paused_in_debugger_message_impl(self, message: Optional[str] = None) -> None:
+		return self._execute_function("Overlay.setPausedInDebuggerMessage", {"message": message})
+	
+	def _set_show_ad_highlights_impl(self, show: bool) -> None:
+		return self._execute_function("Overlay.setShowAdHighlights", {"show": show})
+	
+	def _set_show_container_query_overlays_impl(self, container_query_highlight_configs: List[Dict[str, Any]]) -> None:
+		return self._execute_function(
+				"Overlay.setShowContainerQueryOverlays",
+				{"container_query_highlight_configs": container_query_highlight_configs}
+		)
+	
+	def _set_show_debug_borders_impl(self, show: bool) -> None:
+		return self._execute_function("Overlay.setShowDebugBorders", {"show": show})
+	
+	def _set_show_flex_overlays_impl(self, flex_node_highlight_configs: List[Dict[str, Any]]) -> None:
+		return self._execute_function(
+				"Overlay.setShowFlexOverlays",
+				{"flex_node_highlight_configs": flex_node_highlight_configs}
+		)
+	
+	def _set_show_fps_counter_impl(self, show: bool) -> None:
+		return self._execute_function("Overlay.setShowFPSCounter", {"show": show})
+	
+	def _set_show_grid_overlays_impl(self, grid_node_highlight_configs: List[Dict[str, Any]]) -> None:
+		return self._execute_function(
+				"Overlay.setShowGridOverlays",
+				{"grid_node_highlight_configs": grid_node_highlight_configs}
+		)
+	
+	def _set_show_hinge_impl(self, hinge_config: Optional[Dict[str, Any]] = None) -> None:
+		return self._execute_function("Overlay.setShowHinge", {"hinge_config": hinge_config})
+	
+	def _set_show_hit_test_borders_impl(self, show: bool) -> None:
+		return self._execute_function("Overlay.setShowHitTestBorders", {"show": show})
+	
+	def _set_show_isolated_elements_impl(self, isolated_element_highlight_configs: List[Dict[str, Any]]) -> None:
+		return self._execute_function(
+				"Overlay.setShowIsolatedElements",
+				{
+					"isolated_element_highlight_configs": isolated_element_highlight_configs
+				}
+		)
+	
+	def _set_show_layout_shift_regions_impl(self, result: bool) -> None:
+		return self._execute_function("Overlay.setShowLayoutShiftRegions", {"result": result})
+	
+	def _set_show_paint_rects_impl(self, result: bool) -> None:
+		return self._execute_function("Overlay.setShowPaintRects", {"result": result})
+	
+	def _set_show_scroll_bottleneck_rects_impl(self, show: bool) -> None:
+		return self._execute_function("Overlay.setShowScrollBottleneckRects", {"show": show})
+	
+	def _set_show_scroll_snap_overlays_impl(self, scroll_snap_highlight_configs: List[Dict[str, Any]]) -> None:
+		return self._execute_function(
+				"Overlay.setShowScrollSnapOverlays",
+				{"scroll_snap_highlight_configs": scroll_snap_highlight_configs}
+		)
+	
+	def _set_show_viewport_size_on_resize_impl(self, show: bool) -> None:
+		return self._execute_function("Overlay.setShowViewportSizeOnResize", {"show": show})
+	
+	def _set_show_web_vitals_impl(self, show: bool) -> None:
+		return self._execute_function("Overlay.setShowWebVitals", {"show": show})
+	
+	def _set_show_window_controls_overlay_impl(self, window_controls_overlay_config: Optional[Dict[str, Any]] = None) -> None:
+		return self._execute_function(
+				"Overlay.setShowWindowControlsOverlay",
+				{"window_controls_overlay_config": window_controls_overlay_config}
+		)