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

osn_selenium/webdrivers/unified/chrome/base.py

@@ -0,0 +1,54 @@
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.chrome import ChromeFlagsManager
+from osn_selenium.flags.models.chrome import ChromeFlags
+from selenium.webdriver import (
+	Chrome as legacyChrome
+)
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedChromeBaseMixin"]
+
+
+class UnifiedChromeBaseMixin(UnifiedBlinkBaseMixin):
+	def __init__(
+			self,
+			webdriver_path: str,
+			architecture: ARCHITECTURES_TYPEHINT,
+			flags_manager_type: Type[ChromeFlagsManager] = ChromeFlagsManager,
+			use_browser_exe: bool = True,
+			browser_name_in_system: str = "Google Chrome",
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			flags: Optional[ChromeFlags] = None,
+			start_page_url: str = "about:blank",
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+	):
+		UnifiedBlinkBaseMixin.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				use_browser_exe=use_browser_exe,
+				flags_manager_type=flags_manager_type,
+				flags=flags,
+				start_page_url=start_page_url,
+				implicitly_wait=implicitly_wait,
+				page_load_timeout=page_load_timeout,
+				script_timeout=script_timeout,
+				window_rect=window_rect,
+		)
+	
+	@property
+	def _driver_impl(self) -> Optional[legacyChrome]:
+		return super()._driver_impl

osn_selenium/webdrivers/unified/chrome/lifecycle.py

@@ -0,0 +1,88 @@
+from typing import Optional
+from selenium import webdriver
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from selenium.webdriver.chrome.service import Service
+from osn_selenium.flags.models.chrome import ChromeFlags
+from osn_selenium.webdrivers.unified.core.window import (
+	UnifiedCoreWindowMixin
+)
+from osn_selenium.webdrivers.unified.core.timeouts import (
+	UnifiedCoreTimeoutsMixin
+)
+from osn_selenium.webdrivers.unified.blink.lifecycle import (
+	UnifiedBlinkLifecycleMixin
+)
+
+
+__all__ = ["UnifiedChromeLifecycleMixin"]
+
+
+class UnifiedChromeLifecycleMixin(
+		UnifiedBlinkLifecycleMixin,
+		UnifiedCoreTimeoutsMixin,
+		UnifiedCoreWindowMixin
+):
+	def _create_driver_impl(self) -> None:
+		webdriver_options = self._webdriver_flags_manager.options
+		webdriver_service = Service(
+				executable_path=self._webdriver_path,
+				port=self._debugging_port_impl
+				if self._browser_exe_impl is None
+				else 0,
+				service_args=self._webdriver_flags_manager.start_args
+				if self._browser_exe_impl is None
+				else None
+		)
+		
+		self._driver = webdriver.Chrome(options=webdriver_options, service=webdriver_service)
+		
+		if self._window_rect is not None:
+			self._set_window_rect_impl(
+					x=self._window_rect.x,
+					y=self._window_rect.y,
+					width=self._window_rect.width,
+					height=self._window_rect.height,
+			)
+		
+		self._set_driver_timeouts_impl(
+				page_load_timeout=self._base_page_load_timeout,
+				implicit_wait_timeout=self._base_implicitly_wait,
+				script_timeout=self._base_implicitly_wait,
+		)
+	
+	def _restart_webdriver_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._restart_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _start_webdriver_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._start_webdriver_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/unified/chrome/settings.py

@@ -0,0 +1,48 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.chrome import ChromeFlags
+from osn_selenium.webdrivers.unified.blink.settings import (
+	UnifiedBlinkSettingsMixin
+)
+
+
+__all__ = ["UnifiedChromeSettingsMixin"]
+
+
+class UnifiedChromeSettingsMixin(UnifiedBlinkSettingsMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: str = "",
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._reset_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[ChromeFlags] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			browser_name_in_system: Optional[str] = None,
+			use_browser_exe: Optional[bool] = None,
+			start_page_url: Optional[str] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		super()._update_settings_impl(
+				flags=flags,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				start_page_url=start_page_url,
+				window_rect=window_rect,
+		)

osn_selenium/webdrivers/unified/core/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/unified/core/actions.py

@@ -0,0 +1,43 @@
+from typing import (
+	Iterable,
+	List,
+	Optional
+)
+from osn_selenium._typehints import DEVICES_TYPEHINT
+from osn_selenium.webdrivers._decorators import requires_driver
+from selenium.webdriver import (
+	ActionChains as legacyActionChains
+)
+from osn_selenium.webdrivers.unified.core.script import (
+	UnifiedCoreScriptMixin
+)
+from selenium.webdriver.support.wait import (
+	WebDriverWait as legacyWebDriverWait
+)
+
+
+__all__ = ["UnifiedCoreActionsMixin"]
+
+
+class UnifiedCoreActionsMixin(UnifiedCoreScriptMixin):
+	@requires_driver
+	def _action_chains_impl(
+			self,
+			duration: int = 250,
+			devices: Optional[List[DEVICES_TYPEHINT]] = None,
+	) -> legacyActionChains:
+		return legacyActionChains(driver=self._driver_impl, duration=duration, devices=devices)
+	
+	@requires_driver
+	def _web_driver_wait_impl(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> legacyWebDriverWait:
+		return legacyWebDriverWait(
+				driver=self._driver_impl,
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)

osn_selenium/webdrivers/unified/core/auth.py

@@ -0,0 +1,70 @@
+from typing import (
+	Any,
+	List,
+	Optional,
+	Union
+)
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from selenium.webdriver.common.virtual_authenticator import (
+	Credential,
+	VirtualAuthenticatorOptions
+)
+
+
+__all__ = ["UnifiedCoreAuthMixin"]
+
+
+class UnifiedCoreAuthMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _add_credential_impl(self, credential: Credential) -> None:
+		self._driver_impl.add_credential(credential=credential)
+	
+	@requires_driver
+	def _add_virtual_authenticator_impl(self, options: VirtualAuthenticatorOptions) -> None:
+		self._driver_impl.add_virtual_authenticator(options=options)
+	
+	@requires_driver
+	def _fedcm_dialog_impl(
+			self,
+			timeout: int = 5,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Any = None,
+	) -> Any:
+		return self._driver_impl.fedcm_dialog(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)
+	
+	@requires_driver
+	def _fedcm_impl(self) -> Any:
+		return self._driver_impl.fedcm
+	
+	@requires_driver
+	def _get_credentials_impl(self) -> List[Credential]:
+		return self._driver_impl.get_credentials()
+	
+	@requires_driver
+	def _remove_all_credentials_impl(self) -> None:
+		self._driver_impl.remove_all_credentials()
+	
+	@requires_driver
+	def _remove_credential_impl(self, credential_id: Union[str, bytearray]) -> None:
+		self._driver_impl.remove_credential(credential_id=credential_id)
+	
+	@requires_driver
+	def _remove_virtual_authenticator_impl(self) -> None:
+		self._driver_impl.remove_virtual_authenticator()
+	
+	@requires_driver
+	def _set_user_verified_impl(self, verified: bool) -> None:
+		self._driver_impl.set_user_verified(verified=verified)
+	
+	@requires_driver
+	def _supports_fedcm_impl(self) -> bool:
+		return self._driver_impl.supports_fedcm
+	
+	@requires_driver
+	def _virtual_authenticator_id_impl(self) -> Optional[str]:
+		return self._driver_impl.virtual_authenticator_id

osn_selenium/webdrivers/unified/core/base.py

@@ -0,0 +1,132 @@
+from osn_selenium.models import WindowRect
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Type
+)
+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._typehints import (
+	ARCHITECTURES_TYPEHINT
+)
+from selenium.webdriver.remote.errorhandler import ErrorHandler
+from osn_selenium.webdrivers._decorators import requires_driver
+from selenium.webdriver.remote.locator_converter import LocatorConverter
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.exceptions.webdriver import (
+	WebDriverNotStartedError
+)
+from selenium.webdriver.remote.webdriver import (
+	WebDriver as legacyWebDriver
+)
+
+
+__all__ = ["UnifiedCoreBaseMixin"]
+
+
+class UnifiedCoreBaseMixin:
+	def __init__(
+			self,
+			webdriver_path: str,
+			architecture: ARCHITECTURES_TYPEHINT,
+			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:
+		self._window_rect = window_rect
+		self._webdriver_path = webdriver_path
+		self._webdriver_flags_manager = flags_manager_type()
+		self._driver: Optional[legacyWebDriver] = None
+		self._architecture = architecture
+		self._base_implicitly_wait = float(implicitly_wait)
+		self._base_page_load_timeout = float(page_load_timeout)
+		self._base_script_timeout = float(script_timeout)
+		self._is_active = False
+		
+		if flags is not None:
+			self._webdriver_flags_manager.update_flags(flags)
+	
+	@property
+	def _architecture_impl(self) -> ARCHITECTURES_TYPEHINT:
+		return self._architecture
+	
+	@requires_driver
+	def _capabilities_impl(self) -> Dict[str, Any]:
+		return self._driver_impl.capabilities
+	
+	@requires_driver
+	def _caps_get_impl(self) -> Dict[str, Any]:
+		return self._driver_impl.caps
+	
+	@requires_driver
+	def _caps_set_impl(self, value: Dict[str, Any]) -> None:
+		self._driver_impl.caps = value
+	
+	@requires_driver
+	def _command_executor_get_impl(self) -> RemoteConnection:
+		return self._driver_impl.command_executor
+	
+	@requires_driver
+	def _command_executor_set_impl(self, value: RemoteConnection) -> None:
+		self._driver_impl.command_executor = value
+	
+	@property
+	def _driver_impl(self) -> Optional[legacyWebDriver]:
+		return self._driver
+	
+	def _ensure_driver(self) -> None:
+		if self._driver is None:
+			raise WebDriverNotStartedError()
+	
+	@requires_driver
+	def _error_handler_get_impl(self) -> ErrorHandler:
+		return self._driver_impl.error_handler
+	
+	@requires_driver
+	def _error_handler_set_impl(self, value: ErrorHandler) -> None:
+		self._driver_impl.error_handler = value
+	
+	@requires_driver
+	def _execute_impl(self, driver_command: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+		return self._driver_impl.execute(driver_command=driver_command, params=params)
+	
+	@property
+	def _is_active_impl(self) -> bool:
+		return self._is_active
+	
+	@requires_driver
+	def _locator_converter_get_impl(self) -> LocatorConverter:
+		return self._driver_impl.locator_converter
+	
+	@requires_driver
+	def _locator_converter_set_impl(self, value: LocatorConverter) -> None:
+		self._driver_impl.locator_converter = value
+	
+	@requires_driver
+	def _name_impl(self) -> str:
+		return self._driver_impl.name
+	
+	@requires_driver
+	def _pinned_scripts_get_impl(self) -> Dict[str, Any]:
+		return self._driver_impl.pinned_scripts
+	
+	@requires_driver
+	def _pinned_scripts_set_impl(self, value: Dict[str, Any]) -> None:
+		self._driver_impl.pinned_scripts = value
+	
+	@requires_driver
+	def _session_id_get_impl(self) -> Optional[str]:
+		return self._driver_impl.session_id
+	
+	@requires_driver
+	def _session_id_set_impl(self, value: Optional[str]) -> None:
+		self._driver_impl.session_id = value
+	
+	@requires_driver
+	def _session_impl(self) -> Session:
+		return self._driver_impl._session

osn_selenium/webdrivers/unified/core/capture.py

@@ -0,0 +1,32 @@
+from typing import Any, Optional
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreCaptureMixin"]
+
+
+class UnifiedCoreCaptureMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _get_screenshot_as_base64_impl(self) -> str:
+		return self._driver_impl.get_screenshot_as_base64()
+	
+	@requires_driver
+	def _get_screenshot_as_file_impl(self, filename: str) -> bool:
+		return self._driver_impl.get_screenshot_as_file(filename=filename)
+	
+	@requires_driver
+	def _get_screenshot_as_png_impl(self) -> bytes:
+		return self._driver_impl.get_screenshot_as_png()
+	
+	@requires_driver
+	def _page_source_impl(self) -> str:
+		return self._driver_impl.page_source
+	
+	@requires_driver
+	def _print_page_impl(self, print_options: Optional[Any] = None) -> str:
+		return self._driver_impl.print_page(print_options=print_options)
+	
+	@requires_driver
+	def _save_screenshot_impl(self, filename: str) -> bool:
+		return self._driver_impl.save_screenshot(filename=filename)

osn_selenium/webdrivers/unified/core/components.py

@@ -0,0 +1,32 @@
+from typing import Any
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreComponentsMixin"]
+
+
+class UnifiedCoreComponentsMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _browser_impl(self) -> Any:
+		return self._driver_impl.browser
+	
+	@requires_driver
+	def _browsing_context_impl(self) -> Any:
+		return self._driver_impl.browsing_context
+	
+	@requires_driver
+	def _dialog_impl(self) -> Any:
+		return self._driver_impl.dialog
+	
+	@requires_driver
+	def _mobile_impl(self) -> Any:
+		return self._driver_impl.mobile
+	
+	@requires_driver
+	def _permissions_impl(self) -> Any:
+		return self._driver_impl.permissions
+	
+	@requires_driver
+	def _webextension_impl(self) -> Any:
+		return self._driver_impl.webextension

osn_selenium/webdrivers/unified/core/devtools.py

@@ -0,0 +1,35 @@
+from contextlib import asynccontextmanager
+from typing import (
+	Any,
+	AsyncGenerator,
+	Dict,
+	Tuple
+)
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers._args_helpers import build_cdp_kwargs
+from selenium.webdriver.remote.bidi_connection import BidiConnection
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from selenium.webdriver.remote.websocket_connection import WebSocketConnection
+
+
+__all__ = ["UnifiedCoreDevToolsMixin"]
+
+
+class UnifiedCoreDevToolsMixin(UnifiedCoreBaseMixin):
+	@asynccontextmanager
+	@requires_driver
+	async def _bidi_connection_impl(self) -> AsyncGenerator[BidiConnection, Any]:
+		async with self._driver_impl.bidi_connection() as bidi_connection:
+			yield bidi_connection
+	
+	@requires_driver
+	def _execute_cdp_cmd_impl(self, cmd: str, cmd_args: Dict[str, Any]) -> Any:
+		return self._driver_impl.execute_cdp_cmd(cmd=cmd, cmd_args=build_cdp_kwargs(**cmd_args))
+	
+	@requires_driver
+	def _network_impl(self) -> Any:
+		return self._driver_impl.network
+	
+	@requires_driver
+	def _start_devtools_impl(self) -> Tuple[Any, WebSocketConnection]:
+		return self._driver_impl.start_devtools()

osn_selenium/webdrivers/unified/core/element.py

@@ -0,0 +1,24 @@
+from typing import List, Optional
+from selenium.webdriver.common.by import By
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from selenium.webdriver.remote.webelement import (
+	WebElement as legacyWebElement
+)
+
+
+__all__ = ["UnifiedCoreElementMixin"]
+
+
+class UnifiedCoreElementMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _create_web_element_impl(self, element_id: str) -> legacyWebElement:
+		return self._driver_impl.create_web_element(element_id=element_id)
+	
+	@requires_driver
+	def _find_element_impl(self, by: str = By.ID, value: Optional[str] = None) -> legacyWebElement:
+		return self._driver_impl.find_element(by=by, value=value)
+	
+	@requires_driver
+	def _find_elements_impl(self, by: str = By.ID, value: Optional[str] = None) -> List[legacyWebElement]:
+		return self._driver_impl.find_elements(by=by, value=value)

osn_selenium/webdrivers/unified/core/file.py

@@ -0,0 +1,35 @@
+from contextlib import contextmanager
+from typing import Any, Generator, List
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreFileMixin"]
+
+
+class UnifiedCoreFileMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _delete_downloadable_files_impl(self) -> None:
+		self._driver_impl.delete_downloadable_files()
+	
+	@requires_driver
+	def _download_file_impl(self, file_name: str, target_directory: str) -> None:
+		self._driver_impl.download_file(file_name=file_name, target_directory=target_directory)
+	
+	@contextmanager
+	@requires_driver
+	def _file_detector_context_impl(self, file_detector_class: Any, *args: Any, **kwargs: Any) -> Generator[None, Any, None]:
+		with self._driver_impl.file_detector_context(file_detector_class, *args, **kwargs) as file_detector:
+			yield file_detector
+	
+	@requires_driver
+	def _file_detector_get_impl(self) -> Any:
+		return self._driver_impl.file_detector
+	
+	@requires_driver
+	def _file_detector_set_impl(self, value: Any) -> None:
+		self._driver_impl.file_detector = value
+	
+	@requires_driver
+	def _get_downloadable_files_impl(self) -> List[str]:
+		return self._driver_impl.get_downloadable_files()

osn_selenium/webdrivers/unified/core/lifecycle.py

@@ -0,0 +1,84 @@
+from osn_selenium.models import WindowRect
+from typing import (
+	Any,
+	Dict,
+	Optional,
+	Union
+)
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.webdrivers._decorators import requires_driver
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.exceptions.logic import (
+	AbstractImplementationError
+)
+from selenium.webdriver.remote.webdriver import (
+	WebDriver as legacyWebDriver
+)
+from osn_selenium.webdrivers.unified.core.settings import (
+	UnifiedCoreSettingsMixin
+)
+from osn_selenium.webdrivers.unified.core.timeouts import (
+	UnifiedCoreTimeoutsMixin
+)
+
+
+__all__ = ["UnifiedCoreLifecycleMixin"]
+
+
+class UnifiedCoreLifecycleMixin(UnifiedCoreSettingsMixin, UnifiedCoreTimeoutsMixin):
+	def _remote_connect_driver_impl(self, command_executor: Union[str, RemoteConnection]) -> None:
+		self._driver = legacyWebDriver(
+				command_executor=command_executor,
+				options=self._webdriver_flags_manager.options,
+		)
+		
+		self._set_driver_timeouts_impl(
+				page_load_timeout=self._base_page_load_timeout,
+				implicit_wait_timeout=self._base_implicitly_wait,
+				script_timeout=self._base_script_timeout,
+		)
+		
+		self._is_active = True
+	
+	def _create_driver_impl(self) -> None:
+		raise AbstractImplementationError(method_name="_create_driver_impl", class_name=self.__class__.__name__)
+	
+	def _start_webdriver_impl(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if self._driver_impl is None:
+			self._update_settings_impl(flags=flags, window_rect=window_rect)
+			self._create_driver_impl()
+	
+	@requires_driver
+	def _quit_impl(self) -> None:
+		self._driver_impl.quit()
+	
+	def _close_webdriver_impl(self) -> None:
+		if self._driver_impl is not None:
+			self._quit_impl()
+		
+		self._driver = None
+		self._is_active = False
+	
+	def _restart_webdriver_impl(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		self._close_webdriver_impl()
+		self._start_webdriver_impl(flags=flags, window_rect=window_rect)
+	
+	@requires_driver
+	def _start_client_impl(self) -> None:
+		self._driver_impl.start_client()
+	
+	@requires_driver
+	def _start_session_impl(self, capabilities: Dict[str, Any]) -> None:
+		self._driver_impl.start_session(capabilities=capabilities)
+	
+	@requires_driver
+	def _stop_client_impl(self) -> None:
+		self._driver_impl.stop_client()