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

osn_selenium/webdrivers/trio_threads/yandex/base.py

@@ -0,0 +1,100 @@
+import trio
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.models.yandex import YandexFlags
+from osn_selenium.flags.yandex import YandexFlagsManager
+from osn_selenium.webdrivers.trio_threads.chrome.base import ChromeBaseMixin
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.webdrivers.unified.yandex.base import (
+	UnifiedYandexBaseMixin
+)
+from osn_selenium.abstract.webdriver.yandex.base import (
+	AbstractYandexBaseMixin
+)
+
+
+__all__ = ["YandexBaseMixin"]
+
+
+class YandexBaseMixin(UnifiedYandexBaseMixin, ChromeBaseMixin, AbstractYandexBaseMixin):
+	"""
+	Base mixin for Yandex WebDrivers handling core initialization and state management.
+
+	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,
+			architecture: ARCHITECTURES_TYPEHINT,
+			flags_manager_type: Type[YandexFlagsManager] = YandexFlagsManager,
+			use_browser_exe: bool = True,
+			browser_name_in_system: str = "Yandex",
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			flags: Optional[YandexFlags] = 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,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+	):
+		"""
+		Initializes the Trio-based Yandex WebDriver mixin.
+
+		Args:
+			webdriver_path (str): Path to the YandexDriver executable.
+			architecture (ARCHITECTURE_TYPEHINT): System architecture.
+			flags_manager_type (Type[YandexFlagsManager]): The class type used for managing Yandex flags.
+				Defaults to YandexFlagsManager.
+			use_browser_exe (bool): Whether to use a specific browser executable path or auto-detect.
+				Defaults to True.
+			browser_name_in_system (str): The name of the browser in the system registry or path.
+				Defaults to "Yandex".
+			browser_exe (Optional[PATH_TYPEHINT]): Explicit path to the Yandex browser executable.
+			flags (Optional[YandexFlags]): Initial set of flags.
+			start_page_url (str): The initial URL. Defaults to "about:blank".
+			implicitly_wait (int): Default implicit wait time.
+			page_load_timeout (int): Default page load timeout.
+			script_timeout (int): Default script timeout.
+			window_rect (Optional[WindowRect]): Initial window dimensions.
+			capacity_limiter (Optional[trio.CapacityLimiter]): Trio capacity limiter.
+		"""
+		
+		ChromeBaseMixin.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				use_browser_exe=use_browser_exe,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				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,
+				capacity_limiter=capacity_limiter,
+		)
+		
+		UnifiedYandexBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				flags_manager_type=flags_manager_type,
+				use_browser_exe=use_browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				browser_exe=browser_exe,
+				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,
+		)

osn_selenium/webdrivers/trio_threads/yandex/lifecycle.py

@@ -0,0 +1,63 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.yandex import YandexFlags
+from osn_selenium.webdrivers.trio_threads.chrome import ChromeLifecycleMixin
+from osn_selenium.webdrivers.unified.yandex.lifecycle import (
+	UnifiedYandexLifecycleMixin
+)
+from osn_selenium.abstract.webdriver.yandex.lifecycle import (
+	AbstractYandexLifecycleMixin
+)
+
+
+__all__ = ["YandexLifecycleMixin"]
+
+
+class YandexLifecycleMixin(
+		UnifiedYandexLifecycleMixin,
+		ChromeLifecycleMixin,
+		AbstractYandexLifecycleMixin
+):
+	"""
+	Mixin for managing the lifecycle of the Yandex WebDriver.
+
+	Handles the creation, startup, shutdown, and restarting processes of the
+	underlying browser instance, ensuring clean session management.
+	"""
+	
+	async def restart_webdriver(
+			self,
+			flags: Optional[YandexFlags] = 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:
+		await self.sync_to_trio(sync_function=self._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,
+		)
+	
+	async def start_webdriver(
+			self,
+			flags: Optional[YandexFlags] = 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:
+		await self.sync_to_trio(sync_function=self._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/trio_threads/yandex/settings.py

@@ -0,0 +1,63 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.yandex import YandexFlags
+from osn_selenium.webdrivers.trio_threads.chrome import ChromeSettingsMixin
+from osn_selenium.webdrivers.unified.yandex.settings import (
+	UnifiedYandexSettingsMixin
+)
+from osn_selenium.abstract.webdriver.yandex.settings import (
+	AbstractYandexSettingsMixin
+)
+
+
+__all__ = ["YandexSettingsMixin"]
+
+
+class YandexSettingsMixin(
+		UnifiedYandexSettingsMixin,
+		ChromeSettingsMixin,
+		AbstractYandexSettingsMixin
+):
+	"""
+	Mixin for configuring and updating settings of the Yandex WebDriver.
+
+	Provides methods to modify browser flags, window rectangles, and other
+	configuration parameters either before startup or during a reset.
+	"""
+	
+	async def reset_settings(
+			self,
+			flags: Optional[YandexFlags] = 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:
+		await self.sync_to_trio(sync_function=self._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,
+		)
+	
+	async def update_settings(
+			self,
+			flags: Optional[YandexFlags] = 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:
+		await self.sync_to_trio(sync_function=self._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/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/unified/blink/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/unified/blink/base.py

@@ -0,0 +1,131 @@
+import pathlib
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium.flags.blink import BlinkFlagsManager
+from osn_selenium.flags.models.values import ArgumentValue
+from osn_selenium.browsers_handler import get_path_to_browser
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from selenium.webdriver.chromium.webdriver import (
+	ChromiumDriver as legacyWebDriver
+)
+from osn_selenium.webdrivers._executable_tables.functions import (
+	find_browser_previous_session
+)
+from osn_selenium.flags.models.blink import (
+	BlinkArguments,
+	BlinkExperimentalOptions,
+	BlinkFlags
+)
+from osn_system_utils.api.network import (
+	get_localhost_free_port_of,
+	get_random_localhost_free_port
+)
+
+
+__all__ = ["UnifiedBlinkBaseMixin"]
+
+
+class UnifiedBlinkBaseMixin(UnifiedCoreBaseMixin):
+	def __init__(
+			self,
+			browser_exe: Optional[PATH_TYPEHINT],
+			browser_name_in_system: str,
+			webdriver_path: str,
+			architecture: ARCHITECTURES_TYPEHINT,
+			use_browser_exe: bool = True,
+			flags_manager_type: Type[BlinkFlagsManager] = BlinkFlagsManager,
+			flags: Optional[BlinkFlags] = None,
+			start_page_url: str = "",
+			implicitly_wait: int = 5,
+			page_load_timeout: int = 5,
+			script_timeout: int = 5,
+			window_rect: Optional[WindowRect] = None,
+	):
+		UnifiedCoreBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				architecture=architecture,
+				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,
+		)
+		
+		if browser_exe is not None:
+			self._webdriver_flags_manager.browser_exe = browser_exe
+		
+		if start_page_url is not None:
+			self._webdriver_flags_manager.start_page_url = start_page_url
+		
+		if window_rect is not None:
+			self._window_rect = window_rect
+		
+		if use_browser_exe is not None and browser_name_in_system is not None:
+			self._detect_browser_exe_impl(
+					browser_name_in_system=browser_name_in_system,
+					use_browser_exe=use_browser_exe
+			)
+	
+	def _detect_browser_exe_impl(self, browser_name_in_system: str, use_browser_exe: bool) -> None:
+		if self._browser_exe_impl is None and use_browser_exe:
+			self._webdriver_flags_manager.browser_exe = get_path_to_browser(browser_name_in_system)
+		elif self._browser_exe_impl is not None and not use_browser_exe:
+			self._webdriver_flags_manager.browser_exe = None
+	
+	@property
+	def _debugging_ip_impl(self) -> Optional[str]:
+		return self._webdriver_flags_manager.arguments.get("remote_debugging_address", ArgumentValue(command_line="", value=None)).value
+	
+	@property
+	def _driver_impl(self) -> Optional[legacyWebDriver]:
+		return super()._driver_impl
+	
+	@property
+	def _debugging_port_impl(self) -> Optional[int]:
+		return self._webdriver_flags_manager.arguments.get("remote_debugging_port", ArgumentValue(command_line="", value=None)).value
+	
+	@property
+	def _browser_exe_impl(self) -> Optional[pathlib.Path]:
+		return self._webdriver_flags_manager.browser_exe
+	
+	def _find_debugging_port_impl(self, debugging_port: Optional[int]) -> int:
+		if self._browser_exe_impl is not None:
+			user_data_dir_command = self._webdriver_flags_manager.flags_definitions.get("user_data_dir", None)
+			user_data_dir_value = self._webdriver_flags_manager.arguments.get("user_data_dir", None)
+		
+			user_data_dir = None if user_data_dir_command is None else user_data_dir_value.value if user_data_dir_value is not None else None
+		
+			if user_data_dir_command is not None:
+				previous_session = find_browser_previous_session(self._browser_exe_impl, user_data_dir_command.command, user_data_dir)
+		
+				if previous_session is not None:
+					return previous_session
+		
+		if debugging_port is not None:
+			return get_localhost_free_port_of(ports_to_check=debugging_port, on_candidates="min")
+		
+		if self._debugging_port_impl is None or self._debugging_port_impl == 0:
+			return get_random_localhost_free_port()
+		
+		return self._debugging_port_impl
+	
+	def _set_debugging_port_impl(self, debugging_port: Optional[int], debugging_address: Optional[str]) -> None:
+		if self._browser_exe_impl is not None:
+			_debugging_address = "127.0.0.1" if debugging_address is None else debugging_address
+			_debugging_port = 0 if debugging_port is None else debugging_port
+		
+			self._webdriver_flags_manager.update_flags(
+					BlinkFlags(
+							argument=BlinkArguments(
+									remote_debugging_port=debugging_port,
+									remote_debugging_address=debugging_address,
+							),
+							experimental_option=BlinkExperimentalOptions(debugger_address=f"{_debugging_address}:{_debugging_port}"),
+					)
+			)

osn_selenium/webdrivers/unified/blink/casting.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkCastingMixin"]
+
+
+class UnifiedBlinkCastingMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _get_sinks_impl(self) -> List[Dict[str, Any]]:
+		return self._driver_impl.get_sinks()
+	
+	@requires_driver
+	def _set_sink_to_use_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.set_sink_to_use(sink_name=sink_name)
+	
+	@requires_driver
+	def _start_desktop_mirroring_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.start_desktop_mirroring(sink_name=sink_name)
+	
+	@requires_driver
+	def _start_tab_mirroring_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.start_tab_mirroring(sink_name=sink_name)
+	
+	@requires_driver
+	def _stop_casting_impl(self, sink_name: str) -> Dict[str, Any]:
+		return self._driver_impl.stop_casting(sink_name=sink_name)

osn_selenium/webdrivers/unified/blink/features.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkFeaturesMixin"]
+
+
+class UnifiedBlinkFeaturesMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _get_issue_message_impl(self) -> Any:
+		return self._driver_impl.get_issue_message()
+	
+	@requires_driver
+	def _launch_app_impl(self, id: str) -> Dict[str, Any]:
+		return self._driver_impl.launch_app(id=id)
+	
+	@requires_driver
+	def _set_permissions_impl(self, name: str, value: str) -> None:
+		self._driver_impl.set_permissions(name=name, value=value)

osn_selenium/webdrivers/unified/blink/lifecycle.py

@@ -0,0 +1,114 @@
+import re
+import time
+from typing import Optional
+from subprocess import Popen
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.blink import BlinkFlags
+from osn_system_utils.api.process import kill_process_by_pid
+from osn_selenium.webdrivers.unified.blink.settings import (
+	UnifiedBlinkSettingsMixin
+)
+from osn_selenium.webdrivers.unified.core.lifecycle import (
+	UnifiedCoreLifecycleMixin
+)
+from osn_system_utils.api.network import (
+	get_localhost_pids_with_addresses,
+	get_localhost_pids_with_ports
+)
+
+
+__all__ = ["UnifiedBlinkLifecycleMixin"]
+
+
+class UnifiedBlinkLifecycleMixin(UnifiedBlinkSettingsMixin, UnifiedCoreLifecycleMixin):
+	def _create_driver_impl(self) -> None:
+		raise NotImplementedError("This function must be implemented in child classes.")
+	
+	def _check_browser_exe_active_impl(self) -> bool:
+		debugging_port = self._debugging_port_impl
+		debugging_ip = self._debugging_ip_impl
+		
+		for pid, addresses in get_localhost_pids_with_addresses().items():
+			for address_str in addresses:
+				if re.search(rf":{debugging_port}\Z", address_str) is not None:
+					found_ip = re.search(rf"\A(.+):{debugging_port}\Z", address_str).group(1)
+		
+					if found_ip != debugging_ip:
+						self._set_debugging_port_impl(debugging_port=debugging_port, debugging_address=found_ip)
+		
+					return True
+		return False
+	
+	def _start_webdriver_impl(
+			self,
+			flags: Optional[BlinkFlags] = 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:
+		if self._driver_impl is None:
+			self._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,
+			)
+		
+			if self._browser_exe_impl is not None:
+				is_active = self._check_browser_exe_active_impl()
+		
+				if not is_active:
+					Popen(args=self._webdriver_flags_manager.start_command, shell=True)
+		
+					while not is_active:
+						is_active = self._check_browser_exe_active_impl()
+						if not is_active:
+							time.sleep(0.1)
+		
+			self._create_driver_impl()
+			self._is_active = True
+	
+	def _close_webdriver_impl(self) -> None:
+		if self._browser_exe_impl is not None:
+			debugging_port = self._debugging_port_impl
+			pids_with_ports = get_localhost_pids_with_ports()
+		
+			for pid, ports in pids_with_ports.items():
+				if debugging_port in ports and 1 <= len(ports) <= 2:
+					kill_process_by_pid(pid=pid, force=True)
+		
+					is_active = self._check_browser_exe_active_impl()
+					while is_active:
+						is_active = self._check_browser_exe_active_impl()
+						if is_active:
+							time.sleep(0.05)
+		
+		if self._driver_impl is not None:
+			self._quit_impl()
+			self._driver = None
+		
+		self._is_active = False
+	
+	def _restart_webdriver_impl(
+			self,
+			flags: Optional[BlinkFlags] = 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:
+		self._close_webdriver_impl()
+		self._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/blink/logging.py

@@ -0,0 +1,18 @@
+from typing import Any
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkLoggingMixin"]
+
+
+class UnifiedBlinkLoggingMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _get_log_impl(self, log_type: str) -> Any:
+		return self._driver_impl.get_log(log_type=log_type)
+	
+	@requires_driver
+	def _log_types_impl(self) -> Any:
+		return self._driver_impl.log_types

osn_selenium/webdrivers/unified/blink/network.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict
+from osn_selenium.webdrivers._decorators import requires_driver
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkNetworkMixin"]
+
+
+class UnifiedBlinkNetworkMixin(UnifiedBlinkBaseMixin):
+	@requires_driver
+	def _delete_network_conditions_impl(self) -> None:
+		self._driver_impl.delete_network_conditions()
+	
+	@requires_driver
+	def _get_network_conditions_impl(self) -> Dict[str, Any]:
+		return self._driver_impl.get_network_conditions()
+	
+	@requires_driver
+	def _set_network_conditions_impl(self, **network_conditions: Any) -> None:
+		self._driver_impl.set_network_conditions(**network_conditions)

osn_selenium/webdrivers/unified/blink/settings.py

@@ -0,0 +1,86 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.models.blink import BlinkFlags
+from osn_selenium.exceptions.webdriver import (
+	WebDriverAlreadyRunningError
+)
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+
+
+__all__ = ["UnifiedBlinkSettingsMixin"]
+
+
+class UnifiedBlinkSettingsMixin(UnifiedBlinkBaseMixin):
+	def _reset_settings_impl(
+			self,
+			flags: Optional[BlinkFlags] = 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:
+		if not self._is_active:
+			if flags is not None:
+				self._webdriver_flags_manager.set_flags(flags)
+			else:
+				self._webdriver_flags_manager.clear_flags()
+		
+			self._webdriver_flags_manager.browser_exe = browser_exe
+			self._webdriver_flags_manager.start_page_url = start_page_url
+			self._window_rect = window_rect
+		
+			if use_browser_exe is not None and browser_name_in_system is not None:
+				self._detect_browser_exe_impl(
+						browser_name_in_system=browser_name_in_system,
+						use_browser_exe=use_browser_exe
+				)
+		
+			if self._browser_exe_impl is not None and (
+					self._debugging_port_impl is not None
+					or self._debugging_ip_impl is not None
+			):
+				self._set_debugging_port_impl(
+						self._find_debugging_port_impl(self._debugging_port_impl),
+						self._debugging_ip_impl
+				)
+		else:
+			raise WebDriverAlreadyRunningError()
+	
+	def _update_settings_impl(
+			self,
+			flags: Optional[BlinkFlags] = 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:
+		if not self._is_active:
+			if flags is not None:
+				self._webdriver_flags_manager.update_flags(flags)
+		
+			if browser_exe is not None:
+				self._webdriver_flags_manager.browser_exe = browser_exe
+		
+			if start_page_url is not None:
+				self._webdriver_flags_manager.start_page_url = start_page_url
+		
+			if window_rect is not None:
+				self._window_rect = window_rect
+		
+			if use_browser_exe is not None and browser_name_in_system is not None:
+				self._detect_browser_exe_impl(
+						browser_name_in_system=browser_name_in_system,
+						use_browser_exe=use_browser_exe
+				)
+		
+			self._set_debugging_port_impl(
+					self._find_debugging_port_impl(self._debugging_port_impl),
+					self._debugging_ip_impl
+			)
+		else:
+			raise WebDriverAlreadyRunningError()

osn_selenium/webdrivers/unified/chrome/__init__.py

@@ -0,0 +1 @@
+