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

osn_selenium/executors/sync/cdp/dom_storage.py

@@ -0,0 +1,38 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List
+)
+from osn_selenium.executors.unified.cdp.dom_storage import (
+	UnifiedDomStorageCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.dom_storage import (
+	AbstractDomStorageCDPExecutor
+)
+
+
+__all__ = ["DomStorageCDPExecutor"]
+
+
+class DomStorageCDPExecutor(UnifiedDomStorageCDPExecutor, AbstractDomStorageCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedDomStorageCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def clear(self, storage_id: Dict[str, Any]) -> None:
+		return self._clear_impl(storage_id=storage_id)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def get_dom_storage_items(self, storage_id: Dict[str, Any]) -> List[List[str]]:
+		return self._get_dom_storage_items_impl(storage_id=storage_id)
+	
+	def remove_dom_storage_item(self, storage_id: Dict[str, Any], key: str) -> None:
+		return self._remove_dom_storage_item_impl(storage_id=storage_id, key=key)
+	
+	def set_dom_storage_item(self, storage_id: Dict[str, Any], key: str, value: str) -> None:
+		return self._set_dom_storage_item_impl(storage_id=storage_id, key=key, value=value)

osn_selenium/executors/sync/cdp/emulation.py

@@ -0,0 +1,270 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.emulation import (
+	UnifiedEmulationCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.emulation import (
+	AbstractEmulationCDPExecutor
+)
+
+
+__all__ = ["EmulationCDPExecutor"]
+
+
+class EmulationCDPExecutor(UnifiedEmulationCDPExecutor, AbstractEmulationCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedEmulationCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def add_screen(
+			self,
+			left: int,
+			top: int,
+			width: int,
+			height: int,
+			work_area_insets: Optional[Dict[str, Any]] = None,
+			device_pixel_ratio: Optional[float] = None,
+			rotation: Optional[int] = None,
+			color_depth: Optional[int] = None,
+			label: Optional[str] = None,
+			is_internal: Optional[bool] = None
+	) -> Dict[str, Any]:
+		return self._add_screen_impl(
+				left=left,
+				top=top,
+				width=width,
+				height=height,
+				work_area_insets=work_area_insets,
+				device_pixel_ratio=device_pixel_ratio,
+				rotation=rotation,
+				color_depth=color_depth,
+				label=label,
+				is_internal=is_internal
+		)
+	
+	def can_emulate(self) -> bool:
+		return self._can_emulate_impl()
+	
+	def clear_device_metrics_override(self) -> None:
+		return self._clear_device_metrics_override_impl()
+	
+	def clear_device_posture_override(self) -> None:
+		return self._clear_device_posture_override_impl()
+	
+	def clear_display_features_override(self) -> None:
+		return self._clear_display_features_override_impl()
+	
+	def clear_geolocation_override(self) -> None:
+		return self._clear_geolocation_override_impl()
+	
+	def clear_idle_override(self) -> None:
+		return self._clear_idle_override_impl()
+	
+	def get_overridden_sensor_information(self, type_: str) -> float:
+		return self._get_overridden_sensor_information_impl(type_=type_)
+	
+	def get_screen_infos(self) -> List[Dict[str, Any]]:
+		return self._get_screen_infos_impl()
+	
+	def remove_screen(self, screen_id: str) -> None:
+		return self._remove_screen_impl(screen_id=screen_id)
+	
+	def reset_page_scale_factor(self) -> None:
+		return self._reset_page_scale_factor_impl()
+	
+	def set_auto_dark_mode_override(self, enabled: Optional[bool] = None) -> None:
+		return self._set_auto_dark_mode_override_impl(enabled=enabled)
+	
+	def set_automation_override(self, enabled: bool) -> None:
+		return self._set_automation_override_impl(enabled=enabled)
+	
+	def set_cpu_throttling_rate(self, rate: float) -> None:
+		return self._set_cpu_throttling_rate_impl(rate=rate)
+	
+	def set_data_saver_override(self, data_saver_enabled: Optional[bool] = None) -> None:
+		return self._set_data_saver_override_impl(data_saver_enabled=data_saver_enabled)
+	
+	def set_default_background_color_override(self, color: Optional[Dict[str, Any]] = None) -> None:
+		return self._set_default_background_color_override_impl(color=color)
+	
+	def set_device_metrics_override(
+			self,
+			width: int,
+			height: int,
+			device_scale_factor: float,
+			mobile: bool,
+			scale: Optional[float] = None,
+			screen_width: Optional[int] = None,
+			screen_height: Optional[int] = None,
+			position_x: Optional[int] = None,
+			position_y: Optional[int] = None,
+			dont_set_visible_size: Optional[bool] = None,
+			screen_orientation: Optional[Dict[str, Any]] = None,
+			viewport: Optional[Dict[str, Any]] = None,
+			display_feature: Optional[Dict[str, Any]] = None,
+			device_posture: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._set_device_metrics_override_impl(
+				width=width,
+				height=height,
+				device_scale_factor=device_scale_factor,
+				mobile=mobile,
+				scale=scale,
+				screen_width=screen_width,
+				screen_height=screen_height,
+				position_x=position_x,
+				position_y=position_y,
+				dont_set_visible_size=dont_set_visible_size,
+				screen_orientation=screen_orientation,
+				viewport=viewport,
+				display_feature=display_feature,
+				device_posture=device_posture
+		)
+	
+	def set_device_posture_override(self, posture: Dict[str, Any]) -> None:
+		return self._set_device_posture_override_impl(posture=posture)
+	
+	def set_disabled_image_types(self, image_types: List[str]) -> None:
+		return self._set_disabled_image_types_impl(image_types=image_types)
+	
+	def set_display_features_override(self, features: List[Dict[str, Any]]) -> None:
+		return self._set_display_features_override_impl(features=features)
+	
+	def set_document_cookie_disabled(self, disabled: bool) -> None:
+		return self._set_document_cookie_disabled_impl(disabled=disabled)
+	
+	def set_emit_touch_events_for_mouse(self, enabled: bool, configuration: Optional[str] = None) -> None:
+		return self._set_emit_touch_events_for_mouse_impl(enabled=enabled, configuration=configuration)
+	
+	def set_emulated_media(
+			self,
+			media: Optional[str] = None,
+			features: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return self._set_emulated_media_impl(media=media, features=features)
+	
+	def set_emulated_os_text_scale(self, scale: Optional[float] = None) -> None:
+		return self._set_emulated_os_text_scale_impl(scale=scale)
+	
+	def set_emulated_vision_deficiency(self, type_: str) -> None:
+		return self._set_emulated_vision_deficiency_impl(type_=type_)
+	
+	def set_focus_emulation_enabled(self, enabled: bool) -> None:
+		return self._set_focus_emulation_enabled_impl(enabled=enabled)
+	
+	def set_geolocation_override(
+			self,
+			latitude: Optional[float] = None,
+			longitude: Optional[float] = None,
+			accuracy: Optional[float] = None,
+			altitude: Optional[float] = None,
+			altitude_accuracy: Optional[float] = None,
+			heading: Optional[float] = None,
+			speed: Optional[float] = None
+	) -> None:
+		return self._set_geolocation_override_impl(
+				latitude=latitude,
+				longitude=longitude,
+				accuracy=accuracy,
+				altitude=altitude,
+				altitude_accuracy=altitude_accuracy,
+				heading=heading,
+				speed=speed
+		)
+	
+	def set_hardware_concurrency_override(self, hardware_concurrency: int) -> None:
+		return self._set_hardware_concurrency_override_impl(hardware_concurrency=hardware_concurrency)
+	
+	def set_idle_override(self, is_user_active: bool, is_screen_unlocked: bool) -> None:
+		return self._set_idle_override_impl(is_user_active=is_user_active, is_screen_unlocked=is_screen_unlocked)
+	
+	def set_locale_override(self, locale: Optional[str] = None) -> None:
+		return self._set_locale_override_impl(locale=locale)
+	
+	def set_navigator_overrides(self, platform: str) -> None:
+		return self._set_navigator_overrides_impl(platform=platform)
+	
+	def set_page_scale_factor(self, page_scale_factor: float) -> None:
+		return self._set_page_scale_factor_impl(page_scale_factor=page_scale_factor)
+	
+	def set_pressure_data_override(
+			self,
+			source: str,
+			state: str,
+			own_contribution_estimate: Optional[float] = None
+	) -> None:
+		return self._set_pressure_data_override_impl(
+				source=source,
+				state=state,
+				own_contribution_estimate=own_contribution_estimate
+		)
+	
+	def set_pressure_source_override_enabled(
+			self,
+			enabled: bool,
+			source: str,
+			metadata: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._set_pressure_source_override_enabled_impl(enabled=enabled, source=source, metadata=metadata)
+	
+	def set_pressure_state_override(self, source: str, state: str) -> None:
+		return self._set_pressure_state_override_impl(source=source, state=state)
+	
+	def set_safe_area_insets_override(self, insets: Dict[str, Any]) -> None:
+		return self._set_safe_area_insets_override_impl(insets=insets)
+	
+	def set_script_execution_disabled(self, value: bool) -> None:
+		return self._set_script_execution_disabled_impl(value=value)
+	
+	def set_scrollbars_hidden(self, hidden: bool) -> None:
+		return self._set_scrollbars_hidden_impl(hidden=hidden)
+	
+	def set_sensor_override_enabled(self, enabled: bool, type_: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+		return self._set_sensor_override_enabled_impl(enabled=enabled, type_=type_, metadata=metadata)
+	
+	def set_sensor_override_readings(self, type_: str, reading: Dict[str, Any]) -> None:
+		return self._set_sensor_override_readings_impl(type_=type_, reading=reading)
+	
+	def set_small_viewport_height_difference_override(self, difference: int) -> None:
+		return self._set_small_viewport_height_difference_override_impl(difference=difference)
+	
+	def set_timezone_override(self, timezone_id: str) -> None:
+		return self._set_timezone_override_impl(timezone_id=timezone_id)
+	
+	def set_touch_emulation_enabled(self, enabled: bool, max_touch_points: Optional[int] = None) -> None:
+		return self._set_touch_emulation_enabled_impl(enabled=enabled, max_touch_points=max_touch_points)
+	
+	def set_user_agent_override(
+			self,
+			user_agent: str,
+			accept_language: Optional[str] = None,
+			platform: Optional[str] = None,
+			user_agent_metadata: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._set_user_agent_override_impl(
+				user_agent=user_agent,
+				accept_language=accept_language,
+				platform=platform,
+				user_agent_metadata=user_agent_metadata
+		)
+	
+	def set_virtual_time_policy(
+			self,
+			policy: str,
+			budget: Optional[float] = None,
+			max_virtual_time_task_starvation_count: Optional[int] = None,
+			initial_virtual_time: Optional[float] = None
+	) -> float:
+		return self._set_virtual_time_policy_impl(
+				policy=policy,
+				budget=budget,
+				max_virtual_time_task_starvation_count=max_virtual_time_task_starvation_count,
+				initial_virtual_time=initial_virtual_time
+		)
+	
+	def set_visible_size(self, width: int, height: int) -> None:
+		return self._set_visible_size_impl(width=width, height=height)

osn_selenium/executors/sync/cdp/event_breakpoints.py

@@ -0,0 +1,27 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.event_breakpoints import (
+	UnifiedEventBreakpointsCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.event_breakpoints import (
+	AbstractEventBreakpointsCDPExecutor
+)
+
+
+__all__ = ["EventBreakpointsCDPExecutor"]
+
+
+class EventBreakpointsCDPExecutor(
+		UnifiedEventBreakpointsCDPExecutor,
+		AbstractEventBreakpointsCDPExecutor
+):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedEventBreakpointsCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def remove_instrumentation_breakpoint(self, event_name: str) -> None:
+		return self._remove_instrumentation_breakpoint_impl(event_name=event_name)
+	
+	def set_instrumentation_breakpoint(self, event_name: str) -> None:
+		return self._set_instrumentation_breakpoint_impl(event_name=event_name)

osn_selenium/executors/sync/cdp/extensions.py

@@ -0,0 +1,39 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.extensions import (
+	UnifiedExtensionsCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.extensions import (
+	AbstractExtensionsCDPExecutor
+)
+
+
+__all__ = ["ExtensionsCDPExecutor"]
+
+
+class ExtensionsCDPExecutor(UnifiedExtensionsCDPExecutor, AbstractExtensionsCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedExtensionsCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def clear_storage_items(self, id_: str, storage_area: str) -> None:
+		return self._clear_storage_items_impl(id_=id_, storage_area=storage_area)
+	
+	def get_storage_items(self, id_: str, storage_area: str, keys: Optional[List[str]] = None) -> Any:
+		return self._get_storage_items_impl(id_=id_, storage_area=storage_area, keys=keys)
+	
+	def load_unpacked(self, path: str) -> str:
+		return self._load_unpacked_impl(path=path)
+	
+	def remove_storage_items(self, id_: str, storage_area: str, keys: List[str]) -> None:
+		return self._remove_storage_items_impl(id_=id_, storage_area=storage_area, keys=keys)
+	
+	def set_storage_items(self, id_: str, storage_area: str, values: Any) -> None:
+		return self._set_storage_items_impl(id_=id_, storage_area=storage_area, values=values)
+	
+	def uninstall(self, id_: str) -> None:
+		return self._uninstall_impl(id_=id_)

osn_selenium/executors/sync/cdp/fed_cm.py

@@ -0,0 +1,45 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.fed_cm import (
+	UnifiedFedCmCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.fed_cm import (
+	AbstractFedCmCDPExecutor
+)
+
+
+__all__ = ["FedCmCDPExecutor"]
+
+
+class FedCmCDPExecutor(UnifiedFedCmCDPExecutor, AbstractFedCmCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedFedCmCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def click_dialog_button(self, dialog_id: str, dialog_button: str) -> None:
+		return self._click_dialog_button_impl(dialog_id=dialog_id, dialog_button=dialog_button)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def dismiss_dialog(self, dialog_id: str, trigger_cooldown: Optional[bool] = None) -> None:
+		return self._dismiss_dialog_impl(dialog_id=dialog_id, trigger_cooldown=trigger_cooldown)
+	
+	def enable(self, disable_rejection_delay: Optional[bool] = None) -> None:
+		return self._enable_impl(disable_rejection_delay=disable_rejection_delay)
+	
+	def open_url(self, dialog_id: str, account_index: int, account_url_type: str) -> None:
+		return self._open_url_impl(
+				dialog_id=dialog_id,
+				account_index=account_index,
+				account_url_type=account_url_type
+		)
+	
+	def reset_cooldown(self) -> None:
+		return self._reset_cooldown_impl()
+	
+	def select_account(self, dialog_id: str, account_index: int) -> None:
+		return self._select_account_impl(dialog_id=dialog_id, account_index=account_index)

osn_selenium/executors/sync/cdp/fetch.py

@@ -0,0 +1,96 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.fetch import (
+	UnifiedFetchCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.fetch import (
+	AbstractFetchCDPExecutor
+)
+
+
+__all__ = ["FetchCDPExecutor"]
+
+
+class FetchCDPExecutor(UnifiedFetchCDPExecutor, AbstractFetchCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedFetchCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def continue_request(
+			self,
+			request_id: str,
+			url: Optional[str] = None,
+			method: Optional[str] = None,
+			post_data: Optional[str] = None,
+			headers: Optional[List[Dict[str, Any]]] = None,
+			intercept_response: Optional[bool] = None
+	) -> None:
+		return self._continue_request_impl(
+				request_id=request_id,
+				url=url,
+				method=method,
+				post_data=post_data,
+				headers=headers,
+				intercept_response=intercept_response
+		)
+	
+	def continue_response(
+			self,
+			request_id: str,
+			response_code: Optional[int] = None,
+			response_phrase: Optional[str] = None,
+			response_headers: Optional[List[Dict[str, Any]]] = None,
+			binary_response_headers: Optional[str] = None
+	) -> None:
+		return self._continue_response_impl(
+				request_id=request_id,
+				response_code=response_code,
+				response_phrase=response_phrase,
+				response_headers=response_headers,
+				binary_response_headers=binary_response_headers
+		)
+	
+	def continue_with_auth(self, request_id: str, auth_challenge_response: Dict[str, Any]) -> None:
+		return self._continue_with_auth_impl(request_id=request_id, auth_challenge_response=auth_challenge_response)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(
+			self,
+			patterns: Optional[List[Dict[str, Any]]] = None,
+			handle_auth_requests: Optional[bool] = None
+	) -> None:
+		return self._enable_impl(patterns=patterns, handle_auth_requests=handle_auth_requests)
+	
+	def fail_request(self, request_id: str, error_reason: str) -> None:
+		return self._fail_request_impl(request_id=request_id, error_reason=error_reason)
+	
+	def fulfill_request(
+			self,
+			request_id: str,
+			response_code: int,
+			response_headers: Optional[List[Dict[str, Any]]] = None,
+			binary_response_headers: Optional[str] = None,
+			body: Optional[str] = None,
+			response_phrase: Optional[str] = None
+	) -> None:
+		return self._fulfill_request_impl(
+				request_id=request_id,
+				response_code=response_code,
+				response_headers=response_headers,
+				binary_response_headers=binary_response_headers,
+				body=body,
+				response_phrase=response_phrase
+		)
+	
+	def get_response_body(self, request_id: str) -> Tuple[str, bool]:
+		return self._get_response_body_impl(request_id=request_id)
+	
+	def take_response_body_as_stream(self, request_id: str) -> str:
+		return self._take_response_body_as_stream_impl(request_id=request_id)

osn_selenium/executors/sync/cdp/file_system.py

@@ -0,0 +1,18 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.file_system import (
+	UnifiedFileSystemCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.file_system import (
+	AbstractFileSystemCDPExecutor
+)
+
+
+__all__ = ["FileSystemCDPExecutor"]
+
+
+class FileSystemCDPExecutor(UnifiedFileSystemCDPExecutor, AbstractFileSystemCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedFileSystemCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def get_directory(self, bucket_file_system_locator: Dict[str, Any]) -> Dict[str, Any]:
+		return self._get_directory_impl(bucket_file_system_locator=bucket_file_system_locator)

osn_selenium/executors/sync/cdp/headless_experimental.py

@@ -0,0 +1,44 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.headless_experimental import (
+	UnifiedHeadlessExperimentalCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.headless_experimental import (
+	AbstractHeadlessExperimentalCDPExecutor
+)
+
+
+__all__ = ["HeadlessExperimentalCDPExecutor"]
+
+
+class HeadlessExperimentalCDPExecutor(
+		UnifiedHeadlessExperimentalCDPExecutor,
+		AbstractHeadlessExperimentalCDPExecutor
+):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedHeadlessExperimentalCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def begin_frame(
+			self,
+			frame_time_ticks: Optional[float] = None,
+			interval: Optional[float] = None,
+			no_display_updates: Optional[bool] = None,
+			screenshot: Optional[Dict[str, Any]] = None
+	) -> Tuple[bool, Optional[str]]:
+		return self._begin_frame_impl(
+				frame_time_ticks=frame_time_ticks,
+				interval=interval,
+				no_display_updates=no_display_updates,
+				screenshot=screenshot
+		)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()

osn_selenium/executors/sync/cdp/heap_profiler.py

@@ -0,0 +1,89 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.heap_profiler import (
+	UnifiedHeapProfilerCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.heap_profiler import (
+	AbstractHeapProfilerCDPExecutor
+)
+
+
+__all__ = ["HeapProfilerCDPExecutor"]
+
+
+class HeapProfilerCDPExecutor(UnifiedHeapProfilerCDPExecutor, AbstractHeapProfilerCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedHeapProfilerCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def add_inspected_heap_object(self, heap_object_id: str) -> None:
+		return self._add_inspected_heap_object_impl(heap_object_id=heap_object_id)
+	
+	def collect_garbage(self) -> None:
+		return self._collect_garbage_impl()
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def get_heap_object_id(self, object_id: str) -> str:
+		return self._get_heap_object_id_impl(object_id=object_id)
+	
+	def get_object_by_heap_object_id(self, object_id: str, object_group: Optional[str] = None) -> Dict[str, Any]:
+		return self._get_object_by_heap_object_id_impl(object_id=object_id, object_group=object_group)
+	
+	def get_sampling_profile(self) -> Dict[str, Any]:
+		return self._get_sampling_profile_impl()
+	
+	def start_sampling(
+			self,
+			sampling_interval: Optional[float] = None,
+			stack_depth: Optional[float] = None,
+			include_objects_collected_by_major_gc: Optional[bool] = None,
+			include_objects_collected_by_minor_gc: Optional[bool] = None
+	) -> None:
+		return self._start_sampling_impl(
+				sampling_interval=sampling_interval,
+				stack_depth=stack_depth,
+				include_objects_collected_by_major_gc=include_objects_collected_by_major_gc,
+				include_objects_collected_by_minor_gc=include_objects_collected_by_minor_gc
+		)
+	
+	def start_tracking_heap_objects(self, track_allocations: Optional[bool] = None) -> None:
+		return self._start_tracking_heap_objects_impl(track_allocations=track_allocations)
+	
+	def stop_sampling(self) -> Dict[str, Any]:
+		return self._stop_sampling_impl()
+	
+	def stop_tracking_heap_objects(
+			self,
+			report_progress: Optional[bool] = None,
+			treat_global_objects_as_roots: Optional[bool] = None,
+			capture_numeric_value: Optional[bool] = None,
+			expose_internals: Optional[bool] = None
+	) -> None:
+		return self._stop_tracking_heap_objects_impl(
+				report_progress=report_progress,
+				treat_global_objects_as_roots=treat_global_objects_as_roots,
+				capture_numeric_value=capture_numeric_value,
+				expose_internals=expose_internals
+		)
+	
+	def take_heap_snapshot(
+			self,
+			report_progress: Optional[bool] = None,
+			treat_global_objects_as_roots: Optional[bool] = None,
+			capture_numeric_value: Optional[bool] = None,
+			expose_internals: Optional[bool] = None
+	) -> None:
+		return self._take_heap_snapshot_impl(
+				report_progress=report_progress,
+				treat_global_objects_as_roots=treat_global_objects_as_roots,
+				capture_numeric_value=capture_numeric_value,
+				expose_internals=expose_internals
+		)