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

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,139 @@
+from osn_selenium._cdp_import import install_cdp_hook
+from osn_selenium.models import WindowRect
+from typing import (
+	Any,
+	Dict,
+	Mapping, 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, PATH_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,
+			cdp_versioned_packages_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+			ignore_cdp_version_package_missing: bool = True,
+	) -> 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)
+
+		if not getattr(self, "cdp_hook_installed", False):
+			install_cdp_hook(cdp_paths=cdp_versioned_packages_paths, ignore_package_missing=ignore_cdp_version_package_missing)
+			setattr(self, "cdp_hook_installed", True)
+	
+	@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()

osn_selenium/webdrivers/unified/core/navigation.py

@@ -0,0 +1,31 @@
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreNavigationMixin"]
+
+
+class UnifiedCoreNavigationMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _back_impl(self) -> None:
+		self._driver_impl.back()
+	
+	@requires_driver
+	def _current_url_impl(self) -> str:
+		return self._driver_impl.current_url
+	
+	@requires_driver
+	def _forward_impl(self) -> None:
+		self._driver_impl.forward()
+	
+	@requires_driver
+	def _get_impl(self, url: str) -> None:
+		self._driver_impl.get(url=url)
+	
+	@requires_driver
+	def _refresh_impl(self) -> None:
+		self._driver_impl.refresh()
+	
+	@requires_driver
+	def _title_impl(self) -> str:
+		return self._driver_impl.title

osn_selenium/webdrivers/unified/core/script.py

@@ -0,0 +1,32 @@
+from typing import Any, List, Optional
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreScriptMixin"]
+
+
+class UnifiedCoreScriptMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _execute_async_script_impl(self, script: str, *args: Any) -> Any:
+		return self._driver_impl.execute_async_script(script, *args)
+	
+	@requires_driver
+	def _execute_script_impl(self, script: str, *args: Any) -> Any:
+		return self._driver_impl.execute_script(script, *args)
+	
+	@requires_driver
+	def _get_pinned_scripts_impl(self) -> List[str]:
+		return self._driver_impl.get_pinned_scripts()
+	
+	@requires_driver
+	def _pin_script_impl(self, script: str, script_key: Optional[Any] = None) -> Any:
+		return self._driver_impl.pin_script(script=script, script_key=script_key)
+	
+	@requires_driver
+	def _script_impl(self) -> Any:
+		return self._driver_impl.script
+	
+	@requires_driver
+	def _unpin_impl(self, script_key: Any) -> None:
+		self._driver_impl.unpin(script_key=script_key)

osn_selenium/webdrivers/unified/core/settings.py

@@ -0,0 +1,44 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium.exceptions.webdriver import (
+	WebDriverAlreadyRunningError
+)
+
+
+__all__ = ["UnifiedCoreSettingsMixin"]
+
+
+class UnifiedCoreSettingsMixin(UnifiedCoreBaseMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if not self._is_active_impl:
+			if window_rect is None:
+				window_rect = WindowRect()
+		
+			if flags is not None:
+				self._webdriver_flags_manager.set_flags(flags=flags)
+			else:
+				self._webdriver_flags_manager.clear_flags()
+		
+			self._window_rect = window_rect
+		else:
+			raise WebDriverAlreadyRunningError()
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		if not self._is_active_impl:
+			if flags is not None:
+				self._webdriver_flags_manager.update_flags(flags=flags)
+		
+			if window_rect is not None:
+				self._window_rect = window_rect
+		else:
+			raise WebDriverAlreadyRunningError()

osn_selenium/webdrivers/unified/core/storage.py

@@ -0,0 +1,37 @@
+from typing import (
+	Any,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreStorageMixin"]
+
+
+class UnifiedCoreStorageMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _add_cookie_impl(self, cookie_dict: Dict[str, Any]) -> None:
+		self._driver_impl.add_cookie(cookie_dict=cookie_dict)
+	
+	@requires_driver
+	def _delete_all_cookies_impl(self) -> None:
+		self._driver_impl.delete_all_cookies()
+	
+	@requires_driver
+	def _delete_cookie_impl(self, name: str) -> None:
+		self._driver_impl.delete_cookie(name=name)
+	
+	@requires_driver
+	def _get_cookie_impl(self, name: str) -> Optional[Dict[str, Any]]:
+		return self._driver_impl.get_cookie(name=name)
+	
+	@requires_driver
+	def _get_cookies_impl(self) -> List[Dict[str, Any]]:
+		return self._driver_impl.get_cookies()
+	
+	@requires_driver
+	def _storage_impl(self) -> Any:
+		return self._driver_impl.storage

osn_selenium/webdrivers/unified/core/timeouts.py

@@ -0,0 +1,56 @@
+from typing import Optional
+from selenium.webdriver.common.timeouts import Timeouts
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+
+
+__all__ = ["UnifiedCoreTimeoutsMixin"]
+
+
+class UnifiedCoreTimeoutsMixin(UnifiedCoreBaseMixin):
+	@requires_driver
+	def _get_timeouts_impl(self) -> Timeouts:
+		return self._driver_impl.timeouts
+	
+	@requires_driver
+	def _implicitly_wait_impl(self, time_to_wait: float) -> None:
+		self._driver_impl.implicitly_wait(time_to_wait=time_to_wait)
+	
+	@requires_driver
+	def _set_page_load_timeout_impl(self, time_to_wait: float) -> None:
+		self._driver_impl.set_page_load_timeout(time_to_wait=time_to_wait)
+	
+	@requires_driver
+	def _set_script_timeout_impl(self, time_to_wait: float) -> None:
+		self._driver_impl.set_script_timeout(time_to_wait=time_to_wait)
+	
+	@requires_driver
+	def _set_timeouts_impl(self, timeouts: Timeouts) -> None:
+		self._driver_impl.timeouts = timeouts
+	
+	@requires_driver
+	def _set_driver_timeouts_impl(
+			self,
+			page_load_timeout: float,
+			implicit_wait_timeout: float,
+			script_timeout: float,
+	) -> None:
+		self._driver_impl.set_page_load_timeout(page_load_timeout)
+		self._driver_impl.implicitly_wait(implicit_wait_timeout)
+		self._driver_impl.set_script_timeout(script_timeout)
+	
+	def _update_times_impl(
+			self,
+			temp_implicitly_wait: Optional[float] = None,
+			temp_page_load_timeout: Optional[float] = None,
+			temp_script_timeout: Optional[float] = None,
+	) -> None:
+		implicitly_wait = temp_implicitly_wait if temp_implicitly_wait is not None else self._base_implicitly_wait
+		page_load_timeout = temp_page_load_timeout if temp_page_load_timeout is not None else self._base_page_load_timeout
+		script_timeout = temp_script_timeout if temp_script_timeout is not None else self._base_script_timeout
+		
+		self._set_driver_timeouts_impl(
+				page_load_timeout=page_load_timeout,
+				implicit_wait_timeout=implicitly_wait,
+				script_timeout=script_timeout,
+		)