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

osn_selenium/executors/sync/cdp/debugger.py

@@ -0,0 +1,206 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.debugger import (
+	UnifiedDebuggerCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.debugger import (
+	AbstractDebuggerCDPExecutor
+)
+
+
+__all__ = ["DebuggerCDPExecutor"]
+
+
+class DebuggerCDPExecutor(UnifiedDebuggerCDPExecutor, AbstractDebuggerCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedDebuggerCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def continue_to_location(self, location: Dict[str, Any], target_call_frames: Optional[str] = None) -> None:
+		return self._continue_to_location_impl(location=location, target_call_frames=target_call_frames)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def disassemble_wasm_module(self, script_id: str) -> Tuple[Optional[str], int, List[int], Dict[str, Any]]:
+		return self._disassemble_wasm_module_impl(script_id=script_id)
+	
+	def enable(self, max_scripts_cache_size: Optional[float] = None) -> str:
+		return self._enable_impl(max_scripts_cache_size=max_scripts_cache_size)
+	
+	def evaluate_on_call_frame(
+			self,
+			call_frame_id: str,
+			expression: str,
+			object_group: Optional[str] = None,
+			include_command_line_api: Optional[bool] = None,
+			silent: Optional[bool] = None,
+			return_by_value: Optional[bool] = None,
+			generate_preview: Optional[bool] = None,
+			throw_on_side_effect: Optional[bool] = None,
+			timeout: Optional[float] = None
+	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+		return self._evaluate_on_call_frame_impl(
+				call_frame_id=call_frame_id,
+				expression=expression,
+				object_group=object_group,
+				include_command_line_api=include_command_line_api,
+				silent=silent,
+				return_by_value=return_by_value,
+				generate_preview=generate_preview,
+				throw_on_side_effect=throw_on_side_effect,
+				timeout=timeout
+		)
+	
+	def get_possible_breakpoints(
+			self,
+			start: Dict[str, Any],
+			end: Optional[Dict[str, Any]] = None,
+			restrict_to_function: Optional[bool] = None
+	) -> List[Dict[str, Any]]:
+		return self._get_possible_breakpoints_impl(start=start, end=end, restrict_to_function=restrict_to_function)
+	
+	def get_script_source(self, script_id: str) -> Tuple[str, Optional[str]]:
+		return self._get_script_source_impl(script_id=script_id)
+	
+	def get_stack_trace(self, stack_trace_id: Dict[str, Any]) -> Dict[str, Any]:
+		return self._get_stack_trace_impl(stack_trace_id=stack_trace_id)
+	
+	def get_wasm_bytecode(self, script_id: str) -> str:
+		return self._get_wasm_bytecode_impl(script_id=script_id)
+	
+	def next_wasm_disassembly_chunk(self, stream_id: str) -> Dict[str, Any]:
+		return self._next_wasm_disassembly_chunk_impl(stream_id=stream_id)
+	
+	def pause(self) -> None:
+		return self._pause_impl()
+	
+	def pause_on_async_call(self, parent_stack_trace_id: Dict[str, Any]) -> None:
+		return self._pause_on_async_call_impl(parent_stack_trace_id=parent_stack_trace_id)
+	
+	def remove_breakpoint(self, breakpoint_id: str) -> None:
+		return self._remove_breakpoint_impl(breakpoint_id=breakpoint_id)
+	
+	def restart_frame(self, call_frame_id: str, mode: Optional[str] = None) -> Tuple[List[Dict[str, Any]], Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
+		return self._restart_frame_impl(call_frame_id=call_frame_id, mode=mode)
+	
+	def resume(self, terminate_on_resume: Optional[bool] = None) -> None:
+		return self._resume_impl(terminate_on_resume=terminate_on_resume)
+	
+	def search_in_content(
+			self,
+			script_id: str,
+			query: str,
+			case_sensitive: Optional[bool] = None,
+			is_regex: Optional[bool] = None
+	) -> List[Dict[str, Any]]:
+		return self._search_in_content_impl(
+				script_id=script_id,
+				query=query,
+				case_sensitive=case_sensitive,
+				is_regex=is_regex
+		)
+	
+	def set_async_call_stack_depth(self, max_depth: int) -> None:
+		return self._set_async_call_stack_depth_impl(max_depth=max_depth)
+	
+	def set_blackbox_execution_contexts(self, unique_ids: List[str]) -> None:
+		return self._set_blackbox_execution_contexts_impl(unique_ids=unique_ids)
+	
+	def set_blackbox_patterns(self, patterns: List[str], skip_anonymous: Optional[bool] = None) -> None:
+		return self._set_blackbox_patterns_impl(patterns=patterns, skip_anonymous=skip_anonymous)
+	
+	def set_blackboxed_ranges(self, script_id: str, positions: List[Dict[str, Any]]) -> None:
+		return self._set_blackboxed_ranges_impl(script_id=script_id, positions=positions)
+	
+	def set_breakpoint(self, location: Dict[str, Any], condition: Optional[str] = None) -> Tuple[str, Dict[str, Any]]:
+		return self._set_breakpoint_impl(location=location, condition=condition)
+	
+	def set_breakpoint_by_url(
+			self,
+			line_number: int,
+			url: Optional[str] = None,
+			url_regex: Optional[str] = None,
+			script_hash: Optional[str] = None,
+			column_number: Optional[int] = None,
+			condition: Optional[str] = None
+	) -> Tuple[str, List[Dict[str, Any]]]:
+		return self._set_breakpoint_by_url_impl(
+				line_number=line_number,
+				url=url,
+				url_regex=url_regex,
+				script_hash=script_hash,
+				column_number=column_number,
+				condition=condition
+		)
+	
+	def set_breakpoint_on_function_call(self, object_id: str, condition: Optional[str] = None) -> str:
+		return self._set_breakpoint_on_function_call_impl(object_id=object_id, condition=condition)
+	
+	def set_breakpoints_active(self, active: bool) -> None:
+		return self._set_breakpoints_active_impl(active=active)
+	
+	def set_instrumentation_breakpoint(self, instrumentation: str) -> str:
+		return self._set_instrumentation_breakpoint_impl(instrumentation=instrumentation)
+	
+	def set_pause_on_exceptions(self, state: str) -> None:
+		return self._set_pause_on_exceptions_impl(state=state)
+	
+	def set_return_value(self, new_value: Dict[str, Any]) -> None:
+		return self._set_return_value_impl(new_value=new_value)
+	
+	def set_script_source(
+			self,
+			script_id: str,
+			script_source: str,
+			dry_run: Optional[bool] = None,
+			allow_top_frame_editing: Optional[bool] = None
+	) -> Tuple[
+		Optional[List[Dict[str, Any]]],
+		Optional[bool],
+		Optional[Dict[str, Any]],
+		Optional[Dict[str, Any]],
+		str,
+		Optional[Dict[str, Any]]
+	]:
+		return self._set_script_source_impl(
+				script_id=script_id,
+				script_source=script_source,
+				dry_run=dry_run,
+				allow_top_frame_editing=allow_top_frame_editing
+		)
+	
+	def set_skip_all_pauses(self, skip: bool) -> None:
+		return self._set_skip_all_pauses_impl(skip=skip)
+	
+	def set_variable_value(
+			self,
+			scope_number: int,
+			variable_name: str,
+			new_value: Dict[str, Any],
+			call_frame_id: str
+	) -> None:
+		return self._set_variable_value_impl(
+				scope_number=scope_number,
+				variable_name=variable_name,
+				new_value=new_value,
+				call_frame_id=call_frame_id
+		)
+	
+	def step_into(
+			self,
+			break_on_async_call: Optional[bool] = None,
+			skip_list: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return self._step_into_impl(break_on_async_call=break_on_async_call, skip_list=skip_list)
+	
+	def step_out(self) -> None:
+		return self._step_out_impl()
+	
+	def step_over(self, skip_list: Optional[List[Dict[str, Any]]] = None) -> None:
+		return self._step_over_impl(skip_list=skip_list)

osn_selenium/executors/sync/cdp/device_access.py

@@ -0,0 +1,27 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.device_access import (
+	UnifiedDeviceAccessCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.device_access import (
+	AbstractDeviceAccessCDPExecutor
+)
+
+
+__all__ = ["DeviceAccessCDPExecutor"]
+
+
+class DeviceAccessCDPExecutor(UnifiedDeviceAccessCDPExecutor, AbstractDeviceAccessCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedDeviceAccessCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def cancel_prompt(self, id_: str) -> None:
+		return self._cancel_prompt_impl(id_=id_)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def select_prompt(self, id_: str, device_id: str) -> None:
+		return self._select_prompt_impl(id_=id_, device_id=device_id)

osn_selenium/executors/sync/cdp/device_orientation.py

@@ -0,0 +1,24 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.device_orientation import (
+	UnifiedDeviceOrientationCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.device_orientation import (
+	AbstractDeviceOrientationCDPExecutor
+)
+
+
+__all__ = ["DeviceOrientationCDPExecutor"]
+
+
+class DeviceOrientationCDPExecutor(
+		UnifiedDeviceOrientationCDPExecutor,
+		AbstractDeviceOrientationCDPExecutor
+):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedDeviceOrientationCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def clear_device_orientation_override(self) -> None:
+		return self._clear_device_orientation_override_impl()
+	
+	def set_device_orientation_override(self, alpha: float, beta: float, gamma: float) -> None:
+		return self._set_device_orientation_override_impl(alpha=alpha, beta=beta, gamma=gamma)

osn_selenium/executors/sync/cdp/dom.py

@@ -0,0 +1,310 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.dom import (
+	UnifiedDomCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.dom import (
+	AbstractDomCDPExecutor
+)
+
+
+__all__ = ["DomCDPExecutor"]
+
+
+class DomCDPExecutor(UnifiedDomCDPExecutor, AbstractDomCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedDomCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def collect_class_names_from_subtree(self, node_id: int) -> List[str]:
+		return self._collect_class_names_from_subtree_impl(node_id=node_id)
+	
+	def copy_to(
+			self,
+			node_id: int,
+			target_node_id: int,
+			insert_before_node_id: Optional[int] = None
+	) -> int:
+		return self._copy_to_impl(
+				node_id=node_id,
+				target_node_id=target_node_id,
+				insert_before_node_id=insert_before_node_id
+		)
+	
+	def describe_node(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			depth: Optional[int] = None,
+			pierce: Optional[bool] = None
+	) -> Dict[str, Any]:
+		return self._describe_node_impl(
+				node_id=node_id,
+				backend_node_id=backend_node_id,
+				object_id=object_id,
+				depth=depth,
+				pierce=pierce
+		)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def discard_search_results(self, search_id: str) -> None:
+		return self._discard_search_results_impl(search_id=search_id)
+	
+	def enable(self, include_whitespace: Optional[str] = None) -> None:
+		return self._enable_impl(include_whitespace=include_whitespace)
+	
+	def focus(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> None:
+		return self._focus_impl(node_id=node_id, backend_node_id=backend_node_id, object_id=object_id)
+	
+	def force_show_popover(self, node_id: int, enable: bool) -> List[int]:
+		return self._force_show_popover_impl(node_id=node_id, enable=enable)
+	
+	def get_anchor_element(self, node_id: int, anchor_specifier: Optional[str] = None) -> int:
+		return self._get_anchor_element_impl(node_id=node_id, anchor_specifier=anchor_specifier)
+	
+	def get_attributes(self, node_id: int) -> List[str]:
+		return self._get_attributes_impl(node_id=node_id)
+	
+	def get_box_model(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> Dict[str, Any]:
+		return self._get_box_model_impl(node_id=node_id, backend_node_id=backend_node_id, object_id=object_id)
+	
+	def get_container_for_node(
+			self,
+			node_id: int,
+			container_name: Optional[str] = None,
+			physical_axes: Optional[str] = None,
+			logical_axes: Optional[str] = None,
+			queries_scroll_state: Optional[bool] = None,
+			queries_anchored: Optional[bool] = None
+	) -> Optional[int]:
+		return self._get_container_for_node_impl(
+				node_id=node_id,
+				container_name=container_name,
+				physical_axes=physical_axes,
+				logical_axes=logical_axes,
+				queries_scroll_state=queries_scroll_state,
+				queries_anchored=queries_anchored
+		)
+	
+	def get_content_quads(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> List[List[float]]:
+		return self._get_content_quads_impl(node_id=node_id, backend_node_id=backend_node_id, object_id=object_id)
+	
+	def get_detached_dom_nodes(self) -> List[Dict[str, Any]]:
+		return self._get_detached_dom_nodes_impl()
+	
+	def get_document(self, depth: Optional[int] = None, pierce: Optional[bool] = None) -> Dict[str, Any]:
+		return self._get_document_impl(depth=depth, pierce=pierce)
+	
+	def get_element_by_relation(self, node_id: int, relation: str) -> int:
+		return self._get_element_by_relation_impl(node_id=node_id, relation=relation)
+	
+	def get_file_info(self, object_id: str) -> str:
+		return self._get_file_info_impl(object_id=object_id)
+	
+	def get_flattened_document(self, depth: Optional[int] = None, pierce: Optional[bool] = None) -> List[Dict[str, Any]]:
+		return self._get_flattened_document_impl(depth=depth, pierce=pierce)
+	
+	def get_frame_owner(self, frame_id: str) -> Tuple[int, Optional[int]]:
+		return self._get_frame_owner_impl(frame_id=frame_id)
+	
+	def get_node_for_location(
+			self,
+			x: int,
+			y: int,
+			include_user_agent_shadow_dom: Optional[bool] = None,
+			ignore_pointer_events_none: Optional[bool] = None
+	) -> Tuple[int, str, Optional[int]]:
+		return self._get_node_for_location_impl(
+				x=x,
+				y=y,
+				include_user_agent_shadow_dom=include_user_agent_shadow_dom,
+				ignore_pointer_events_none=ignore_pointer_events_none
+		)
+	
+	def get_node_stack_traces(self, node_id: int) -> Optional[Dict[str, Any]]:
+		return self._get_node_stack_traces_impl(node_id=node_id)
+	
+	def get_nodes_for_subtree_by_style(
+			self,
+			node_id: int,
+			computed_styles: List[Dict[str, Any]],
+			pierce: Optional[bool] = None
+	) -> List[int]:
+		return self._get_nodes_for_subtree_by_style_impl(node_id=node_id, computed_styles=computed_styles, pierce=pierce)
+	
+	def get_outer_html(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			include_shadow_dom: Optional[bool] = None
+	) -> str:
+		return self._get_outer_html_impl(
+				node_id=node_id,
+				backend_node_id=backend_node_id,
+				object_id=object_id,
+				include_shadow_dom=include_shadow_dom
+		)
+	
+	def get_querying_descendants_for_container(self, node_id: int) -> List[int]:
+		return self._get_querying_descendants_for_container_impl(node_id=node_id)
+	
+	def get_relayout_boundary(self, node_id: int) -> int:
+		return self._get_relayout_boundary_impl(node_id=node_id)
+	
+	def get_search_results(self, search_id: str, from_index: int, to_index: int) -> List[int]:
+		return self._get_search_results_impl(search_id=search_id, from_index=from_index, to_index=to_index)
+	
+	def get_top_layer_elements(self) -> List[int]:
+		return self._get_top_layer_elements_impl()
+	
+	def hide_highlight(self) -> None:
+		return self._hide_highlight_impl()
+	
+	def highlight_node(self) -> None:
+		return self._highlight_node_impl()
+	
+	def highlight_rect(self) -> None:
+		return self._highlight_rect_impl()
+	
+	def mark_undoable_state(self) -> None:
+		return self._mark_undoable_state_impl()
+	
+	def move_to(
+			self,
+			node_id: int,
+			target_node_id: int,
+			insert_before_node_id: Optional[int] = None
+	) -> int:
+		return self._move_to_impl(
+				node_id=node_id,
+				target_node_id=target_node_id,
+				insert_before_node_id=insert_before_node_id
+		)
+	
+	def perform_search(self, query: str, include_user_agent_shadow_dom: Optional[bool] = None) -> Tuple[str, int]:
+		return self._perform_search_impl(
+				query=query,
+				include_user_agent_shadow_dom=include_user_agent_shadow_dom
+		)
+	
+	def push_node_by_path_to_frontend(self, path: str) -> int:
+		return self._push_node_by_path_to_frontend_impl(path=path)
+	
+	def push_nodes_by_backend_ids_to_frontend(self, backend_node_ids: List[int]) -> List[int]:
+		return self._push_nodes_by_backend_ids_to_frontend_impl(backend_node_ids=backend_node_ids)
+	
+	def query_selector(self, node_id: int, selector: str) -> int:
+		return self._query_selector_impl(node_id=node_id, selector=selector)
+	
+	def query_selector_all(self, node_id: int, selector: str) -> List[int]:
+		return self._query_selector_all_impl(node_id=node_id, selector=selector)
+	
+	def redo(self) -> None:
+		return self._redo_impl()
+	
+	def remove_attribute(self, node_id: int, name: str) -> None:
+		return self._remove_attribute_impl(node_id=node_id, name=name)
+	
+	def remove_node(self, node_id: int) -> None:
+		return self._remove_node_impl(node_id=node_id)
+	
+	def request_child_nodes(
+			self,
+			node_id: int,
+			depth: Optional[int] = None,
+			pierce: Optional[bool] = None
+	) -> None:
+		return self._request_child_nodes_impl(node_id=node_id, depth=depth, pierce=pierce)
+	
+	def request_node(self, object_id: str) -> int:
+		return self._request_node_impl(object_id=object_id)
+	
+	def resolve_node(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_group: Optional[str] = None,
+			execution_context_id: Optional[int] = None
+	) -> Dict[str, Any]:
+		return self._resolve_node_impl(
+				node_id=node_id,
+				backend_node_id=backend_node_id,
+				object_group=object_group,
+				execution_context_id=execution_context_id
+		)
+	
+	def scroll_into_view_if_needed(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			rect: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._scroll_into_view_if_needed_impl(
+				node_id=node_id,
+				backend_node_id=backend_node_id,
+				object_id=object_id,
+				rect=rect
+		)
+	
+	def set_attribute_value(self, node_id: int, name: str, value: str) -> None:
+		return self._set_attribute_value_impl(node_id=node_id, name=name, value=value)
+	
+	def set_attributes_as_text(self, node_id: int, text: str, name: Optional[str] = None) -> None:
+		return self._set_attributes_as_text_impl(node_id=node_id, text=text, name=name)
+	
+	def set_file_input_files(
+			self,
+			files: List[str],
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> None:
+		return self._set_file_input_files_impl(
+				files=files,
+				node_id=node_id,
+				backend_node_id=backend_node_id,
+				object_id=object_id
+		)
+	
+	def set_inspected_node(self, node_id: int) -> None:
+		return self._set_inspected_node_impl(node_id=node_id)
+	
+	def set_node_name(self, node_id: int, name: str) -> int:
+		return self._set_node_name_impl(node_id=node_id, name=name)
+	
+	def set_node_stack_traces_enabled(self, enable: bool) -> None:
+		return self._set_node_stack_traces_enabled_impl(enable=enable)
+	
+	def set_node_value(self, node_id: int, value: str) -> None:
+		return self._set_node_value_impl(node_id=node_id, value=value)
+	
+	def set_outer_html(self, node_id: int, outer_html: str) -> None:
+		return self._set_outer_html_impl(node_id=node_id, outer_html=outer_html)
+	
+	def undo(self) -> None:
+		return self._undo_impl()

osn_selenium/executors/sync/cdp/dom_debugger.py

@@ -0,0 +1,56 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.dom_debugger import (
+	UnifiedDomDebuggerCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.dom_debugger import (
+	AbstractDomDebuggerCDPExecutor
+)
+
+
+__all__ = ["DomDebuggerCDPExecutor"]
+
+
+class DomDebuggerCDPExecutor(UnifiedDomDebuggerCDPExecutor, AbstractDomDebuggerCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedDomDebuggerCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def get_event_listeners(
+			self,
+			object_id: str,
+			depth: Optional[int] = None,
+			pierce: Optional[bool] = None
+	) -> List[Dict[str, Any]]:
+		return self._get_event_listeners_impl(object_id=object_id, depth=depth, pierce=pierce)
+	
+	def remove_dom_breakpoint(self, node_id: int, type_: str) -> None:
+		return self._remove_dom_breakpoint_impl(node_id=node_id, type_=type_)
+	
+	def remove_event_listener_breakpoint(self, event_name: str, target_name: Optional[str] = None) -> None:
+		return self._remove_event_listener_breakpoint_impl(event_name=event_name, target_name=target_name)
+	
+	def remove_instrumentation_breakpoint(self, event_name: str) -> None:
+		return self._remove_instrumentation_breakpoint_impl(event_name=event_name)
+	
+	def remove_xhr_breakpoint(self, url: str) -> None:
+		return self._remove_xhr_breakpoint_impl(url=url)
+	
+	def set_break_on_csp_violation(self, violation_types: List[str]) -> None:
+		return self._set_break_on_csp_violation_impl(violation_types=violation_types)
+	
+	def set_dom_breakpoint(self, node_id: int, type_: str) -> None:
+		return self._set_dom_breakpoint_impl(node_id=node_id, type_=type_)
+	
+	def set_event_listener_breakpoint(self, event_name: str, target_name: Optional[str] = None) -> None:
+		return self._set_event_listener_breakpoint_impl(event_name=event_name, target_name=target_name)
+	
+	def set_instrumentation_breakpoint(self, event_name: str) -> None:
+		return self._set_instrumentation_breakpoint_impl(event_name=event_name)
+	
+	def set_xhr_breakpoint(self, url: str) -> None:
+		return self._set_xhr_breakpoint_impl(url=url)

osn_selenium/executors/sync/cdp/dom_snapshot.py

@@ -0,0 +1,58 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.dom_snapshot import (
+	UnifiedDomSnapshotCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.dom_snapshot import (
+	AbstractDomSnapshotCDPExecutor
+)
+
+
+__all__ = ["DomSnapshotCDPExecutor"]
+
+
+class DomSnapshotCDPExecutor(UnifiedDomSnapshotCDPExecutor, AbstractDomSnapshotCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedDomSnapshotCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def capture_snapshot(
+			self,
+			computed_styles: List[str],
+			include_paint_order: Optional[bool] = None,
+			include_dom_rects: Optional[bool] = None,
+			include_blended_background_colors: Optional[bool] = None,
+			include_text_color_opacities: Optional[bool] = None
+	) -> Tuple[List[Dict[str, Any]], List[str]]:
+		return self._capture_snapshot_impl(
+				computed_styles=computed_styles,
+				include_paint_order=include_paint_order,
+				include_dom_rects=include_dom_rects,
+				include_blended_background_colors=include_blended_background_colors,
+				include_text_color_opacities=include_text_color_opacities
+		)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def get_snapshot(
+			self,
+			computed_style_whitelist: List[str],
+			include_event_listeners: Optional[bool] = None,
+			include_paint_order: Optional[bool] = None,
+			include_user_agent_shadow_tree: Optional[bool] = None
+	) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[Dict[str, Any]]]:
+		return self._get_snapshot_impl(
+				computed_style_whitelist=computed_style_whitelist,
+				include_event_listeners=include_event_listeners,
+				include_paint_order=include_paint_order,
+				include_user_agent_shadow_tree=include_user_agent_shadow_tree
+		)