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

osn_selenium/webdrivers/sync/core/__init__.py

@@ -0,0 +1,91 @@
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.base import BrowserFlagsManager
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.webdrivers.sync.core.auth import CoreAuthMixin
+from osn_selenium.webdrivers.sync.core.base import CoreBaseMixin
+from osn_selenium.webdrivers.sync.core.file import CoreFileMixin
+from osn_selenium.webdrivers.sync.core.script import CoreScriptMixin
+from osn_selenium.webdrivers.sync.core.window import CoreWindowMixin
+from osn_selenium.webdrivers.sync.core.actions import CoreActionsMixin
+from osn_selenium.webdrivers.sync.core.capture import CoreCaptureMixin
+from osn_selenium.webdrivers.sync.core.element import CoreElementMixin
+from osn_selenium.webdrivers.sync.core.storage import CoreStorageMixin
+from osn_selenium.webdrivers.sync.core.devtools import CoreDevToolsMixin
+from osn_selenium.webdrivers.sync.core.settings import CoreSettingsMixin
+from osn_selenium.webdrivers.sync.core.timeouts import CoreTimeoutsMixin
+from osn_selenium.webdrivers.sync.core.lifecycle import CoreLifecycleMixin
+from osn_selenium.abstract.webdriver.core import (
+	AbstractCoreWebDriver
+)
+from osn_selenium.webdrivers.sync.core.comonents import CoreComponentsMixin
+from osn_selenium.webdrivers.sync.core.navigation import CoreNavigationMixin
+
+
+__all__ = ["CoreWebDriver"]
+
+
+class CoreWebDriver(
+		CoreActionsMixin,
+		CoreAuthMixin,
+		CoreBaseMixin,
+		CoreCaptureMixin,
+		CoreComponentsMixin,
+		CoreDevToolsMixin,
+		CoreElementMixin,
+		CoreFileMixin,
+		CoreLifecycleMixin,
+		CoreNavigationMixin,
+		CoreScriptMixin,
+		CoreSettingsMixin,
+		CoreStorageMixin,
+		CoreTimeoutsMixin,
+		CoreWindowMixin,
+		AbstractCoreWebDriver,
+):
+	"""
+	Concrete Core WebDriver implementation combining all functional mixins.
+
+	This class aggregates lifecycle management, element interaction, navigation,
+	and browser-specific features into a single usable driver instance.
+	"""
+	
+	def __init__(
+			self,
+			webdriver_path: str,
+			flags_manager_type: Type[BrowserFlagsManager] = BrowserFlagsManager,
+			flags: Optional[BrowserFlags] = None,
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		"""
+		Initializes the synchronous WebDriver instance.
+
+		Args:
+			webdriver_path (str): The file path to the WebDriver executable.
+			flags_manager_type (Type[BrowserFlagsManager]): The class type used to manage
+				browser-specific configuration flags. Defaults to BrowserFlagsManager.
+			flags (Optional[BrowserFlags]): Initial set of browser flags or options
+				to apply upon startup. Defaults to None.
+			implicitly_wait (int): The amount of time (in seconds) that the driver should
+				wait when searching for elements. Defaults to 5.
+			page_load_timeout (int): The amount of time (in seconds) to wait for a page
+				load to complete. Defaults to 5.
+			script_timeout (int): The amount of time (in seconds) to wait for an
+				asynchronous script to finish execution. Defaults to 5.
+			window_rect (Optional[WindowRect]): The initial size and position of the
+				browser window. Defaults to None.
+		"""
+		
+		CoreBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				flags_manager_type=flags_manager_type,
+				flags=flags,
+				implicitly_wait=implicitly_wait,
+				page_load_timeout=page_load_timeout,
+				script_timeout=script_timeout,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/sync/core/actions.py

@@ -0,0 +1,59 @@
+from typing import (
+	Iterable,
+	List,
+	Optional
+)
+from osn_selenium._typehints import DEVICES_TYPEHINT
+from osn_selenium.instances.sync.action_chains import ActionChains
+from osn_selenium.webdrivers.sync.core.script import CoreScriptMixin
+from osn_selenium.instances.sync.web_driver_wait import WebDriverWait
+from osn_selenium.webdrivers._bridges import (
+	get_js_executor_bridge
+)
+from osn_selenium.instances.convert import (
+	get_sync_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.actions import (
+	UnifiedCoreActionsMixin
+)
+from osn_selenium.abstract.webdriver.core.actions import (
+	AbstractCoreActionsMixin
+)
+
+
+__all__ = ["CoreActionsMixin"]
+
+
+class CoreActionsMixin(UnifiedCoreActionsMixin, CoreScriptMixin, AbstractCoreActionsMixin):
+	"""
+	Mixin providing high-level interaction capabilities for Core WebDrivers.
+
+	Includes factories for standard and human-like ActionChains, as well as
+	custom WebDriverWait implementations.
+	"""
+	
+	def action_chains(
+			self,
+			duration: int = 250,
+			devices: Optional[List[DEVICES_TYPEHINT]] = None,
+	) -> ActionChains:
+		legacy = self._action_chains_impl(duration=duration, devices=devices)
+		
+		return ActionChains(
+				selenium_action_chains=legacy,
+				execute_js_script_function=get_js_executor_bridge(self),
+		)
+	
+	def web_driver_wait(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> WebDriverWait:
+		legacy = self._web_driver_wait_impl(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions
+		)
+		
+		return get_sync_instance_wrapper(wrapper_class=WebDriverWait, legacy_object=legacy)

osn_selenium/webdrivers/sync/core/auth.py

@@ -0,0 +1,77 @@
+from osn_selenium.instances.sync.fedcm import FedCM
+from typing import (
+	Any,
+	List,
+	Optional,
+	Union
+)
+from osn_selenium.instances.sync.dialog import Dialog
+from osn_selenium.instances.convert import (
+	get_sync_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.auth import UnifiedCoreAuthMixin
+from osn_selenium.abstract.webdriver.core.auth import (
+	AbstractCoreAuthMixin
+)
+from selenium.webdriver.common.virtual_authenticator import (
+	Credential,
+	VirtualAuthenticatorOptions
+)
+
+
+__all__ = ["CoreAuthMixin"]
+
+
+class CoreAuthMixin(UnifiedCoreAuthMixin, AbstractCoreAuthMixin):
+	"""
+	Mixin handling authentication and credential management for Core WebDrivers.
+
+	Provides interfaces for adding/removing credentials, managing virtual
+	authenticators, and handling Federated Credential Management (FedCM) dialogs.
+	"""
+	
+	def add_credential(self, credential: Credential) -> None:
+		self._add_credential_impl(credential=credential)
+	
+	def add_virtual_authenticator(self, options: VirtualAuthenticatorOptions) -> None:
+		self._add_virtual_authenticator_impl(options=options)
+	
+	def fedcm(self) -> FedCM:
+		legacy = self._fedcm_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=FedCM, legacy_object=legacy)
+	
+	def fedcm_dialog(
+			self,
+			timeout: int = 5,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Any = None,
+	) -> Dialog:
+		legacy = self._fedcm_dialog_impl(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)
+		
+		return get_sync_instance_wrapper(wrapper_class=Dialog, legacy_object=legacy)
+	
+	def get_credentials(self) -> List[Credential]:
+		return self._get_credentials_impl()
+	
+	def remove_all_credentials(self) -> None:
+		self._remove_all_credentials_impl()
+	
+	def remove_credential(self, credential_id: Union[str, bytearray]) -> None:
+		self._remove_credential_impl(credential_id=credential_id)
+	
+	def remove_virtual_authenticator(self) -> None:
+		self._remove_virtual_authenticator_impl()
+	
+	def set_user_verified(self, verified: bool) -> None:
+		self._set_user_verified_impl(verified=verified)
+	
+	def supports_fedcm(self) -> bool:
+		return self._supports_fedcm_impl()
+	
+	def virtual_authenticator_id(self) -> Optional[str]:
+		return self._virtual_authenticator_id_impl()

osn_selenium/webdrivers/sync/core/base.py

@@ -0,0 +1,167 @@
+from osn_selenium.models import WindowRect
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Type
+)
+from osn_selenium.executors.sync.cdp import CDPExecutor
+from osn_selenium.flags.base import BrowserFlagsManager
+from osn_selenium.flags.models.base import BrowserFlags
+from selenium.webdriver.common.bidi.session import Session
+from osn_selenium.executors.sync.javascript import JSExecutor
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT
+)
+from selenium.webdriver.remote.errorhandler import ErrorHandler
+from selenium.webdriver.remote.locator_converter import LocatorConverter
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium.abstract.webdriver.core.base import (
+	AbstractCoreBaseMixin
+)
+from selenium.webdriver.remote.webdriver import (
+	WebDriver as legacyWebDriver
+)
+from osn_selenium.webdrivers._bridges import (
+	get_cdp_executor_bridge,
+	get_js_executor_bridge
+)
+
+
+__all__ = ["CoreBaseMixin"]
+
+
+class CoreBaseMixin(UnifiedCoreBaseMixin, AbstractCoreBaseMixin):
+	"""
+	This class serves as the foundation for browser-specific implementations, managing
+	the WebDriver executable path, configuration flags, timeouts, and the active
+	driver instance.
+	"""
+	
+	def __init__(
+			self,
+			webdriver_path: str,
+			flags_manager_type: Type[BrowserFlagsManager] = BrowserFlagsManager,
+			flags: Optional[BrowserFlags] = None,
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		"""
+		Initializes the base mixin for synchronous WebDrivers.
+
+		Args:
+			webdriver_path (str): The file path to the WebDriver executable.
+			flags_manager_type (Type[BrowserFlagsManager]): The class type used to manage
+				browser-specific configuration flags. Defaults to BrowserFlagsManager.
+			flags (Optional[BrowserFlags]): Initial set of browser flags or options
+				to apply upon startup. Defaults to None.
+			implicitly_wait (int): The amount of time (in seconds) that the driver should
+				wait when searching for elements. Defaults to 5.
+			page_load_timeout (int): The amount of time (in seconds) to wait for a page
+				load to complete. Defaults to 5.
+			script_timeout (int): The amount of time (in seconds) to wait for an
+				asynchronous script to finish execution. Defaults to 5.
+			window_rect (Optional[WindowRect]): The initial size and position of the
+				browser window. Defaults to None.
+		"""
+		
+		UnifiedCoreBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				architecture="sync",
+				flags_manager_type=flags_manager_type,
+				flags=flags,
+				implicitly_wait=implicitly_wait,
+				page_load_timeout=page_load_timeout,
+				script_timeout=script_timeout,
+				window_rect=window_rect,
+		)
+		
+		self._cdp_executor = CDPExecutor(execute_function=get_cdp_executor_bridge(self))
+		
+		self._js_executor = JSExecutor(execute_function=get_js_executor_bridge(self))
+	
+	@property
+	def architecture(self) -> ARCHITECTURES_TYPEHINT:
+		return self._architecture_impl
+	
+	@property
+	def capabilities(self) -> Dict[str, Any]:
+		return self._capabilities_impl()
+	
+	@property
+	def caps(self) -> Dict[str, Any]:
+		return self._caps_get_impl()
+	
+	@caps.setter
+	def caps(self, value: Dict[str, Any]) -> None:
+		self._caps_set_impl(value)
+	
+	@property
+	def cdp(self) -> CDPExecutor:
+		return self._cdp_executor
+	
+	@property
+	def command_executor(self) -> RemoteConnection:
+		return self._command_executor_get_impl()
+	
+	@command_executor.setter
+	def command_executor(self, value: RemoteConnection) -> None:
+		self._command_executor_set_impl(value)
+	
+	@property
+	def driver(self) -> Optional[legacyWebDriver]:
+		return self._driver_impl
+	
+	@property
+	def error_handler(self) -> ErrorHandler:
+		return self._error_handler_get_impl()
+	
+	@error_handler.setter
+	def error_handler(self, value: ErrorHandler) -> None:
+		self._error_handler_set_impl(value)
+	
+	def execute(self, driver_command: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+		return self._execute_impl(driver_command=driver_command, params=params)
+	
+	@property
+	def is_active(self) -> bool:
+		return self._is_active_impl
+	
+	@property
+	def javascript(self) -> JSExecutor:
+		return self._js_executor
+	
+	@property
+	def locator_converter(self) -> LocatorConverter:
+		return self._locator_converter_get_impl()
+	
+	@locator_converter.setter
+	def locator_converter(self, value: LocatorConverter) -> None:
+		self._locator_converter_set_impl(value)
+	
+	@property
+	def name(self) -> str:
+		return self._name_impl()
+	
+	@property
+	def pinned_scripts(self) -> Dict[str, Any]:
+		return self._pinned_scripts_get_impl()
+	
+	@pinned_scripts.setter
+	def pinned_scripts(self, value: Dict[str, Any]) -> None:
+		self._pinned_scripts_set_impl(value)
+	
+	def session(self) -> Session:
+		return self._session_impl()
+	
+	@property
+	def session_id(self) -> Optional[str]:
+		return self._session_id_get_impl()
+	
+	@session_id.setter
+	def session_id(self, value: Optional[str]) -> None:
+		self._session_id_set_impl(value)

osn_selenium/webdrivers/sync/core/capture.py

@@ -0,0 +1,37 @@
+from typing import Any, Optional
+from osn_selenium.webdrivers.unified.core.capture import (
+	UnifiedCoreCaptureMixin
+)
+from osn_selenium.abstract.webdriver.core.capture import (
+	AbstractCoreCaptureMixin
+)
+
+
+__all__ = ["CoreCaptureMixin"]
+
+
+class CoreCaptureMixin(UnifiedCoreCaptureMixin, AbstractCoreCaptureMixin):
+	"""
+	Mixin enabling screen capture and page source retrieval for Core WebDrivers.
+
+	Offers methods to take screenshots (file, base64, png), print pages,
+	and extract the current DOM source.
+	"""
+	
+	def get_screenshot_as_base64(self) -> str:
+		return self._get_screenshot_as_base64_impl()
+	
+	def get_screenshot_as_file(self, filename: str) -> bool:
+		return self._get_screenshot_as_file_impl(filename=filename)
+	
+	def get_screenshot_as_png(self) -> bytes:
+		return self._get_screenshot_as_png_impl()
+	
+	def page_source(self) -> str:
+		return self._page_source_impl()
+	
+	def print_page(self, print_options: Optional[Any] = None) -> str:
+		return self._print_page_impl(print_options=print_options)
+	
+	def save_screenshot(self, filename: str) -> bool:
+		return self._save_screenshot_impl(filename=filename)

osn_selenium/webdrivers/sync/core/comonents.py

@@ -0,0 +1,57 @@
+from osn_selenium.instances.sync.dialog import Dialog
+from osn_selenium.instances.sync.mobile import Mobile
+from osn_selenium.instances.sync.browser import Browser
+from osn_selenium.instances.sync.permissions import Permissions
+from osn_selenium.instances.sync.web_extension import WebExtension
+from osn_selenium.instances.sync.browsing_context import BrowsingContext
+from osn_selenium.instances.convert import (
+	get_sync_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.components import (
+	UnifiedCoreComponentsMixin
+)
+from osn_selenium.abstract.webdriver.core.components import (
+	AbstractCoreComponentsMixin
+)
+
+
+__all__ = ["CoreComponentsMixin"]
+
+
+class CoreComponentsMixin(UnifiedCoreComponentsMixin, AbstractCoreComponentsMixin):
+	"""
+	Mixin providing access to specialized browser components for Core WebDrivers.
+
+	Exposes interfaces for interacting with specific browser domains such as
+	permissions, mobile emulation, dialog handling, and web extensions.
+	"""
+	
+	def browser(self) -> Browser:
+		legacy = self._browser_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=Browser, legacy_object=legacy)
+	
+	def browsing_context(self) -> BrowsingContext:
+		legacy = self._browsing_context_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=BrowsingContext, legacy_object=legacy)
+	
+	def dialog(self) -> Dialog:
+		legacy = self._dialog_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=Dialog, legacy_object=legacy)
+	
+	def mobile(self) -> Mobile:
+		legacy = self._mobile_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=Mobile, legacy_object=legacy)
+	
+	def permissions(self) -> Permissions:
+		legacy = self._permissions_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=Permissions, legacy_object=legacy)
+	
+	def webextension(self) -> WebExtension:
+		legacy = self._webextension_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=WebExtension, legacy_object=legacy)

osn_selenium/webdrivers/sync/core/devtools.py

@@ -0,0 +1,47 @@
+from contextlib import asynccontextmanager
+from osn_selenium.instances.sync.network import Network
+from typing import (
+	Any,
+	AsyncGenerator,
+	Dict,
+	Tuple
+)
+from selenium.webdriver.remote.bidi_connection import BidiConnection
+from osn_selenium.instances.convert import (
+	get_sync_instance_wrapper
+)
+from selenium.webdriver.remote.websocket_connection import WebSocketConnection
+from osn_selenium.webdrivers.unified.core.devtools import (
+	UnifiedCoreDevToolsMixin
+)
+from osn_selenium.abstract.webdriver.core.devtools import (
+	AbstractCoreDevToolsMixin
+)
+
+
+__all__ = ["CoreDevToolsMixin"]
+
+
+class CoreDevToolsMixin(UnifiedCoreDevToolsMixin, AbstractCoreDevToolsMixin):
+	"""
+	Mixin for Chrome DevTools Protocol (CDP) and BiDi interactions in Core WebDrivers.
+
+	Facilitates low-level browser control via CDP commands, network interception,
+	and bidirectional communication sessions.
+	"""
+	
+	@asynccontextmanager
+	async def bidi_connection(self) -> AsyncGenerator[BidiConnection, Any]:
+		async with self._bidi_connection_impl() as bidi:
+			yield bidi
+	
+	def execute_cdp_cmd(self, cmd: str, cmd_args: Dict[str, Any]) -> Any:
+		return self._execute_cdp_cmd_impl(cmd=cmd, cmd_args=cmd_args)
+	
+	def network(self) -> Network:
+		legacy = self._network_impl()
+		
+		return get_sync_instance_wrapper(wrapper_class=Network, legacy_object=legacy)
+	
+	def start_devtools(self) -> Tuple[Any, WebSocketConnection]:
+		return self._start_devtools_impl()

osn_selenium/webdrivers/sync/core/element.py

@@ -0,0 +1,42 @@
+from typing import List, Optional
+from selenium.webdriver.common.by import By
+from osn_selenium.instances.sync.web_element import WebElement
+from osn_selenium.instances.convert import (
+	get_sync_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.element import (
+	UnifiedCoreElementMixin
+)
+from osn_selenium.abstract.webdriver.core.element import (
+	AbstractCoreElementMixin
+)
+
+
+__all__ = ["CoreElementMixin"]
+
+
+class CoreElementMixin(UnifiedCoreElementMixin, AbstractCoreElementMixin):
+	"""
+	Mixin for DOM element retrieval in Core WebDrivers.
+
+	Provides standard methods to locate single or multiple elements within
+	the current page context.
+	"""
+	
+	def create_web_element(self, element_id: str) -> WebElement:
+		legacy = self._create_web_element_impl(element_id=element_id)
+		
+		return get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=legacy)
+	
+	def find_element(self, by: str = By.ID, value: Optional[str] = None) -> WebElement:
+		legacy = self._find_element_impl(by=by, value=value)
+		
+		return get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=legacy)
+	
+	def find_elements(self, by: str = By.ID, value: Optional[str] = None) -> List[WebElement]:
+		legacy_elements = self._find_elements_impl(by=by, value=value)
+		
+		return [
+			get_sync_instance_wrapper(wrapper_class=WebElement, legacy_object=element)
+			for element in legacy_elements
+		]

osn_selenium/webdrivers/sync/core/file.py

@@ -0,0 +1,40 @@
+from contextlib import contextmanager
+from typing import Any, Generator, List
+from osn_selenium.webdrivers.unified.core.file import UnifiedCoreFileMixin
+from osn_selenium.abstract.webdriver.core.file import (
+	AbstractCoreFileMixin
+)
+
+
+__all__ = ["CoreFileMixin"]
+
+
+class CoreFileMixin(UnifiedCoreFileMixin, AbstractCoreFileMixin):
+	"""
+	Mixin for file system interactions within Core WebDrivers.
+
+	Manages file upload detection, download verification, and cleanup of
+	downloaded files.
+	"""
+	
+	def delete_downloadable_files(self) -> None:
+		self._delete_downloadable_files_impl()
+	
+	def download_file(self, file_name: str, target_directory: str) -> None:
+		self._download_file_impl(file_name=file_name, target_directory=target_directory)
+	
+	@property
+	def file_detector(self) -> Any:
+		return self._file_detector_get_impl()
+	
+	@file_detector.setter
+	def file_detector(self, value: Any) -> None:
+		self._file_detector_set_impl(value)
+	
+	@contextmanager
+	def file_detector_context(self, file_detector_class: Any, *args: Any, **kwargs: Any) -> Generator[None, Any, None]:
+		with self._file_detector_context_impl(file_detector_class, *args, **kwargs) as file_detector:
+			yield file_detector
+	
+	def get_downloadable_files(self) -> List[str]:
+		return self._get_downloadable_files_impl()

osn_selenium/webdrivers/sync/core/lifecycle.py

@@ -0,0 +1,59 @@
+from osn_selenium.models import WindowRect
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Union
+)
+from osn_selenium.flags.models.base import BrowserFlags
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.webdrivers.unified.core.lifecycle import (
+	UnifiedCoreLifecycleMixin
+)
+from osn_selenium.abstract.webdriver.core.lifecycle import (
+	AbstractCoreLifecycleMixin
+)
+
+
+__all__ = ["CoreLifecycleMixin"]
+
+
+class CoreLifecycleMixin(UnifiedCoreLifecycleMixin, AbstractCoreLifecycleMixin):
+	"""
+	Mixin for managing the lifecycle of the Core WebDriver.
+
+	Handles the creation, startup, shutdown, and restarting processes of the
+	underlying browser instance, ensuring clean session management.
+	"""
+	
+	def close_webdriver(self) -> None:
+		self._close_webdriver_impl()
+	
+	def quit(self) -> None:
+		self._quit_impl()
+	
+	def remote_connect_driver(self, command_executor: Union[str, RemoteConnection]) -> None:
+		self._remote_connect_driver_impl(command_executor=command_executor)
+	
+	def restart_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		self._restart_webdriver_impl(flags=flags, window_rect=window_rect)
+	
+	def start_client(self) -> None:
+		self._start_client_impl()
+	
+	def start_session(self, capabilities: Dict[str, Any]) -> None:
+		self._start_session_impl(capabilities=capabilities)
+	
+	def start_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		self._start_webdriver_impl(flags=flags, window_rect=window_rect)
+	
+	def stop_client(self) -> None:
+		self._stop_client_impl()