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

osn_selenium/webdrivers/trio_threads/core/element.py

@@ -0,0 +1,58 @@
+from typing import List, Optional
+from selenium.webdriver.common.by import By
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances.trio_threads.web_element import WebElement
+from osn_selenium.instances.convert import (
+	get_trio_thread_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, TrioThreadMixin, AbstractCoreElementMixin):
+	"""
+	Mixin for DOM element retrieval in Core WebDrivers.
+
+	Provides standard methods to locate single or multiple elements within
+	the current page context.
+	"""
+	
+	async def create_web_element(self, element_id: str) -> WebElement:
+		legacy = await self.sync_to_trio(sync_function=self._create_web_element_impl)(element_id=element_id)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebElement,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def find_element(self, by: str = By.ID, value: Optional[str] = None) -> WebElement:
+		legacy = await self.sync_to_trio(sync_function=self._find_element_impl)(by=by, value=value)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebElement,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def find_elements(self, by: str = By.ID, value: Optional[str] = None) -> List[WebElement]:
+		legacy_elements = await self.sync_to_trio(sync_function=self._find_elements_impl)(by=by, value=value)
+		
+		return [
+			get_trio_thread_instance_wrapper(
+					wrapper_class=WebElement,
+					legacy_object=element,
+					lock=self._lock,
+					limiter=self._capacity_limiter,
+			)
+			for element in legacy_elements
+		]

osn_selenium/webdrivers/trio_threads/core/file.py

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

osn_selenium/webdrivers/trio_threads/core/lifecycle.py

@@ -0,0 +1,60 @@
+from osn_selenium.models import WindowRect
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+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, TrioThreadMixin, 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.
+	"""
+	
+	async def close_webdriver(self) -> None:
+		await self.sync_to_trio(sync_function=self._close_webdriver_impl)()
+	
+	async def quit(self) -> None:
+		await self.sync_to_trio(sync_function=self._quit_impl)()
+	
+	async def remote_connect_driver(self, command_executor: Union[str, RemoteConnection]) -> None:
+		await self.sync_to_trio(sync_function=self._remote_connect_driver_impl)(command_executor=command_executor)
+	
+	async def restart_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._restart_webdriver_impl)(flags=flags, window_rect=window_rect)
+	
+	async def start_client(self) -> None:
+		await self.sync_to_trio(sync_function=self._start_client_impl)()
+	
+	async def start_session(self, capabilities: Dict[str, Any]) -> None:
+		await self.sync_to_trio(sync_function=self._start_session_impl)(capabilities=capabilities)
+	
+	async def start_webdriver(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._start_webdriver_impl)(flags=flags, window_rect=window_rect)
+	
+	async def stop_client(self) -> None:
+		await self.sync_to_trio(sync_function=self._stop_client_impl)()

osn_selenium/webdrivers/trio_threads/core/navigation.py

@@ -0,0 +1,41 @@
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.core.navigation import (
+	UnifiedCoreNavigationMixin
+)
+from osn_selenium.abstract.webdriver.core.navigation import (
+	AbstractCoreNavigationMixin
+)
+
+
+__all__ = ["CoreNavigationMixin"]
+
+
+class CoreNavigationMixin(
+		UnifiedCoreNavigationMixin,
+		TrioThreadMixin,
+		AbstractCoreNavigationMixin
+):
+	"""
+	Mixin controlling browser navigation for Core WebDrivers.
+
+	Includes standard navigation commands such as visiting URLs, history
+	traversal (back/forward), and page refreshing.
+	"""
+	
+	async def back(self) -> None:
+		await self.sync_to_trio(sync_function=self._back_impl)()
+	
+	async def current_url(self) -> str:
+		return await self.sync_to_trio(sync_function=self._current_url_impl)()
+	
+	async def forward(self) -> None:
+		await self.sync_to_trio(sync_function=self._forward_impl)()
+	
+	async def get(self, url: str) -> None:
+		await self.sync_to_trio(sync_function=self._get_impl)(url=url)
+	
+	async def refresh(self) -> None:
+		await self.sync_to_trio(sync_function=self._refresh_impl)()
+	
+	async def title(self) -> str:
+		return await self.sync_to_trio(sync_function=self._title_impl)()

osn_selenium/webdrivers/trio_threads/core/script.py

@@ -0,0 +1,59 @@
+from typing import Any, List, Optional
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances.trio_threads.script import Script
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.script import (
+	UnifiedCoreScriptMixin
+)
+from osn_selenium.abstract.webdriver.core.script import (
+	AbstractCoreScriptMixin
+)
+from osn_selenium.webdrivers._args_helpers import (
+	unwrap_args,
+	wrap_trio_thread_args
+)
+
+
+__all__ = ["CoreScriptMixin"]
+
+
+class CoreScriptMixin(UnifiedCoreScriptMixin, TrioThreadMixin, AbstractCoreScriptMixin):
+	"""
+	Mixin for JavaScript execution and management in Core WebDrivers.
+
+	Allows execution of synchronous and asynchronous JavaScript, as well as
+	pinning scripts for repeated use.
+	"""
+	
+	async def execute_async_script(self, script: str, *args: Any) -> Any:
+		unwrapped = unwrap_args(args=args)
+		result = await self.sync_to_trio(sync_function=self._execute_async_script_impl)(script, *unwrapped)
+		
+		return wrap_trio_thread_args(args=result, lock=self._lock, limiter=self._capacity_limiter)
+	
+	async def execute_script(self, script: str, *args: Any) -> Any:
+		unwrapped = unwrap_args(args=args)
+		result = await self.sync_to_trio(sync_function=self._execute_script_impl)(script, *unwrapped)
+		
+		return wrap_trio_thread_args(args=result, lock=self._lock, limiter=self._capacity_limiter)
+	
+	async def get_pinned_scripts(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._get_pinned_scripts_impl)()
+	
+	async def pin_script(self, script: str, script_key: Optional[Any] = None) -> Any:
+		return await self.sync_to_trio(sync_function=self._pin_script_impl)(script=script, script_key=script_key)
+	
+	async def script(self) -> Script:
+		legacy = await self.sync_to_trio(sync_function=self._script_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Script,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def unpin(self, script_key: Any) -> None:
+		await self.sync_to_trio(sync_function=self._unpin_impl)(script_key=script_key)

osn_selenium/webdrivers/trio_threads/core/settings.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from osn_selenium.models import WindowRect
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.webdrivers.unified.core.settings import (
+	UnifiedCoreSettingsMixin
+)
+from osn_selenium.abstract.webdriver.core.settings import (
+	AbstractCoreSettingsMixin
+)
+
+
+__all__ = ["CoreSettingsMixin"]
+
+
+class CoreSettingsMixin(UnifiedCoreSettingsMixin, TrioThreadMixin, AbstractCoreSettingsMixin):
+	"""
+	Mixin for configuring and updating settings of the Core 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[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._reset_settings_impl)(flags=flags, window_rect=window_rect)
+	
+	async def update_settings(
+			self,
+			flags: Optional[BrowserFlags] = None,
+			window_rect: Optional[WindowRect] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._update_settings_impl)(flags=flags, window_rect=window_rect)

osn_selenium/webdrivers/trio_threads/core/storage.py

@@ -0,0 +1,54 @@
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.instances.trio_threads.storage import Storage
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.storage import (
+	UnifiedCoreStorageMixin
+)
+from osn_selenium.abstract.webdriver.core.storage import (
+	AbstractCoreStorageMixin
+)
+
+
+__all__ = ["CoreStorageMixin"]
+
+
+class CoreStorageMixin(UnifiedCoreStorageMixin, TrioThreadMixin, AbstractCoreStorageMixin):
+	"""
+	Mixin for managing browser storage and cookies in Core WebDrivers.
+
+	Provides methods to add, retrieve, and delete cookies, as well as access
+	other storage mechanisms.
+	"""
+	
+	async def add_cookie(self, cookie_dict: Dict[str, Any]) -> None:
+		await self.sync_to_trio(sync_function=self._add_cookie_impl)(cookie_dict=cookie_dict)
+	
+	async def delete_all_cookies(self) -> None:
+		await self.sync_to_trio(sync_function=self._delete_all_cookies_impl)()
+	
+	async def delete_cookie(self, name: str) -> None:
+		await self.sync_to_trio(sync_function=self._delete_cookie_impl)(name=name)
+	
+	async def get_cookie(self, name: str) -> Optional[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_cookie_impl)(name=name)
+	
+	async def get_cookies(self) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_cookies_impl)()
+	
+	async def storage(self) -> Storage:
+		legacy = await self.sync_to_trio(sync_function=self._storage_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Storage,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/webdrivers/trio_threads/core/timeouts.py

@@ -0,0 +1,60 @@
+from typing import Optional
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from selenium.webdriver.common.timeouts import Timeouts
+from osn_selenium.webdrivers.unified.core.timeouts import (
+	UnifiedCoreTimeoutsMixin
+)
+from osn_selenium.abstract.webdriver.core.timeouts import (
+	AbstractCoreTimeoutsMixin
+)
+
+
+__all__ = ["CoreTimeoutsMixin"]
+
+
+class CoreTimeoutsMixin(UnifiedCoreTimeoutsMixin, TrioThreadMixin, AbstractCoreTimeoutsMixin):
+	"""
+	Mixin for configuring execution timeouts in Core WebDrivers.
+
+	Manages implicit waits, page load timeouts, and script execution limits
+	to control driver behavior during delays.
+	"""
+	
+	async def get_timeouts(self) -> Timeouts:
+		return await self.sync_to_trio(sync_function=self._get_timeouts_impl)()
+	
+	async def implicitly_wait(self, time_to_wait: float) -> None:
+		await self.sync_to_trio(sync_function=self._implicitly_wait_impl)(time_to_wait=time_to_wait)
+	
+	async def set_driver_timeouts(
+			self,
+			page_load_timeout: float,
+			implicit_wait_timeout: float,
+			script_timeout: float,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._set_driver_timeouts_impl)(
+				page_load_timeout=page_load_timeout,
+				implicit_wait_timeout=implicit_wait_timeout,
+				script_timeout=script_timeout,
+		)
+	
+	async def set_page_load_timeout(self, time_to_wait: float) -> None:
+		await self.sync_to_trio(sync_function=self._set_page_load_timeout_impl)(time_to_wait=time_to_wait)
+	
+	async def set_script_timeout(self, time_to_wait: float) -> None:
+		await self.sync_to_trio(sync_function=self._set_script_timeout_impl)(time_to_wait=time_to_wait)
+	
+	async def set_timeouts(self, timeouts: Timeouts) -> None:
+		await self.sync_to_trio(sync_function=self._set_timeouts_impl)(timeouts=timeouts)
+	
+	async def update_times(
+			self,
+			temp_implicitly_wait: Optional[float] = None,
+			temp_page_load_timeout: Optional[float] = None,
+			temp_script_timeout: Optional[float] = None,
+	) -> None:
+		await self.sync_to_trio(sync_function=self._update_times_impl)(
+				temp_implicitly_wait=temp_implicitly_wait,
+				temp_page_load_timeout=temp_page_load_timeout,
+				temp_script_timeout=temp_script_timeout,
+		)

osn_selenium/webdrivers/trio_threads/core/window.py

@@ -0,0 +1,105 @@
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from typing import (
+	List,
+	Literal,
+	Optional,
+	Union
+)
+from osn_selenium.models import (
+	Position,
+	Rectangle,
+	Size
+)
+from osn_selenium.instances.trio_threads.switch_to import SwitchTo
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.window import (
+	UnifiedCoreWindowMixin
+)
+from osn_selenium.abstract.webdriver.core.window import (
+	AbstractCoreWindowMixin
+)
+
+
+__all__ = ["CoreWindowMixin"]
+
+
+class CoreWindowMixin(UnifiedCoreWindowMixin, TrioThreadMixin, AbstractCoreWindowMixin):
+	"""
+	Mixin for window and tab management in Core WebDrivers.
+
+	Controls window dimensions, position, state (minimized/maximized), and
+	switching between active window handles or frames.
+	"""
+	
+	async def close(self) -> None:
+		await self.sync_to_trio(sync_function=self._close_impl)()
+	
+	async def close_all_windows(self) -> None:
+		await self.sync_to_trio(sync_function=self._close_all_windows_impl)()
+	
+	async def close_window(self, window: Optional[Union[str, int]] = None) -> None:
+		await self.sync_to_trio(sync_function=self._close_window_impl)(window=window)
+	
+	async def current_window_handle(self) -> str:
+		return await self.sync_to_trio(sync_function=self._current_window_handle_impl)()
+	
+	async def fullscreen_window(self) -> None:
+		await self.sync_to_trio(sync_function=self._fullscreen_window_impl)()
+	
+	async def get_window_handle(self, window: Optional[Union[str, int]] = None) -> str:
+		return await self.sync_to_trio(sync_function=self._get_window_handle_impl)(window=window)
+	
+	async def get_window_position(self, windowHandle: str = "current") -> Position:
+		position = await self.sync_to_trio(sync_function=self._get_window_position_impl)(windowHandle=windowHandle)
+		return Position.model_validate(position)
+	
+	async def get_window_rect(self) -> Rectangle:
+		rectangle = await self.sync_to_trio(sync_function=self._get_window_rect_impl)()
+		return Rectangle.model_validate(rectangle)
+	
+	async def get_window_size(self, windowHandle: str = "current") -> Size:
+		size = await self.sync_to_trio(sync_function=self._get_window_size_impl)(windowHandle=windowHandle)
+		return Size.model_validate(size)
+	
+	async def maximize_window(self) -> None:
+		await self.sync_to_trio(sync_function=self._maximize_window_impl)()
+	
+	async def minimize_window(self) -> None:
+		await self.sync_to_trio(sync_function=self._minimize_window_impl)()
+	
+	async def orientation(self) -> Literal["LANDSCAPE", "PORTRAIT"]:
+		return await self.sync_to_trio(sync_function=self._orientation_get_impl)()
+	
+	async def set_orientation(self, value: Literal["LANDSCAPE", "PORTRAIT"]) -> None:
+		await self.sync_to_trio(sync_function=self._orientation_set_impl)(value=value)
+	
+	async def set_window_position(self, x: int, y: int, windowHandle: str = "current") -> Position:
+		position = await self.sync_to_trio(sync_function=self._set_window_position_impl)(x=x, y=y, windowHandle=windowHandle)
+		return Position.model_validate(position)
+	
+	async def set_window_rect(
+			self,
+			x: Optional[int] = None,
+			y: Optional[int] = None,
+			width: Optional[int] = None,
+			height: Optional[int] = None,
+	) -> Rectangle:
+		rectangle = await self.sync_to_trio(sync_function=self._set_window_rect_impl)(x=x, y=y, width=width, height=height)
+		return Rectangle.model_validate(rectangle)
+	
+	async def set_window_size(self, width: int, height: int, windowHandle: str = "current") -> None:
+		await self.sync_to_trio(sync_function=self._set_window_size_impl)(width=width, height=height, windowHandle=windowHandle)
+	
+	def switch_to(self) -> SwitchTo:
+		legacy = self._switch_to_impl()
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=SwitchTo,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def window_handles(self) -> List[str]:
+		return await self.sync_to_trio(sync_function=self._window_handles_impl)()

osn_selenium/webdrivers/trio_threads/edge/__init__.py

@@ -0,0 +1,114 @@
+import trio
+from osn_selenium.models import WindowRect
+from typing import (
+	Mapping,
+	Optional,
+	Type
+)
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.edge import EdgeFlagsManager
+from osn_selenium.flags.models.edge import EdgeFlags
+from osn_selenium.dev_tools.settings import DevToolsSettings
+from osn_selenium.webdrivers.trio_threads.blink import BlinkWebDriver
+from osn_selenium.webdrivers.trio_threads.edge.base import EdgeBaseMixin
+from osn_selenium.abstract.webdriver.edge import (
+	AbstractEdgeWebDriver
+)
+from osn_selenium.webdrivers.trio_threads.edge.settings import EdgeSettingsMixin
+from osn_selenium.webdrivers.trio_threads.edge.lifecycle import EdgeLifecycleMixin
+
+
+__all__ = ["EdgeWebDriver"]
+
+
+class EdgeWebDriver(
+		EdgeBaseMixin,
+		EdgeLifecycleMixin,
+		EdgeSettingsMixin,
+		BlinkWebDriver,
+		AbstractEdgeWebDriver,
+):
+	"""
+	Concrete Edge 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[EdgeFlagsManager] = EdgeFlagsManager,
+			use_browser_exe: bool = True,
+			browser_name_in_system: str = "Microsoft Edge",
+			browser_exe: Optional[PATH_TYPEHINT] = None,
+			flags: Optional[EdgeFlags] = 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,
+			devtools_settings: Optional[DevToolsSettings] = None,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+			cdp_versioned_packages_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+			ignore_cdp_version_package_missing: bool = True,
+	):
+		"""
+		Initializes the Trio-based Edge WebDriver with specified configuration.
+
+		Args:
+			webdriver_path (str): Path to the EdgeDriver executable.
+			flags_manager_type (Type[EdgeFlagsManager]): The class type used for managing Edge flags.
+				Defaults to EdgeFlagsManager.
+			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 "Microsoft Edge".
+			browser_exe (Optional[PATH_TYPEHINT]): Explicit path to the Edge browser executable.
+			flags (Optional[EdgeFlags]): 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.
+			cdp_versioned_packages_paths (Optional[Mapping[int, PATH_TYPEHINT]]): Custom local paths for specific CDP versions packages.
+			ignore_cdp_version_package_missing (bool): Whether to ignore missing CDP package errors.
+		"""
+		
+		BlinkWebDriver.__init__(
+				self,
+				browser_exe=browser_exe,
+				browser_name_in_system=browser_name_in_system,
+				webdriver_path=webdriver_path,
+				use_browser_exe=use_browser_exe,
+				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,
+				devtools_settings=devtools_settings,
+				capacity_limiter=capacity_limiter,
+				cdp_versioned_packages_paths=cdp_versioned_packages_paths,
+				ignore_cdp_version_package_missing=ignore_cdp_version_package_missing,
+		)
+		
+		EdgeBaseMixin.__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="trio_threads",
+				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,
+				cdp_versioned_packages_paths=cdp_versioned_packages_paths,
+				ignore_cdp_version_package_missing=ignore_cdp_version_package_missing,
+		)