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

osn_selenium/webdrivers/sync/yandex/base.py

@@ -0,0 +1,99 @@
+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.sync.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,
+	):
+		"""
+		Initializes the synchronous Yandex WebDriver mixin with specified configuration.
+
+		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.
+				If None, it may be auto-detected based on other parameters.
+			flags (Optional[YandexFlags]): Initial set of flags to configure the Yandex instance.
+			start_page_url (str): The URL to navigate to immediately upon startup.
+				Defaults to "about:blank".
+			implicitly_wait (int): Default implicit wait time in seconds. Defaults to 5.
+			page_load_timeout (int): Default page load timeout in seconds. Defaults to 5.
+			script_timeout (int): Default script execution timeout in seconds. Defaults to 5.
+			window_rect (Optional[WindowRect]): Initial window dimensions and position.
+				If None, browser defaults are used.
+		"""
+		
+		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,
+		)
+		
+		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/sync/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.sync.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.
+	"""
+	
+	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:
+		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,
+		)
+	
+	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:
+		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/sync/yandex/settings.py

@@ -0,0 +1,58 @@
+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.unified.yandex.settings import (
+	UnifiedYandexSettingsMixin
+)
+from osn_selenium.abstract.webdriver.yandex.settings import (
+	AbstractYandexSettingsMixin
+)
+
+
+__all__ = ["YandexSettingsMixin"]
+
+
+class YandexSettingsMixin(UnifiedYandexSettingsMixin, 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 either during a reset.
+	"""
+	
+	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:
+		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,
+		)
+	
+	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:
+		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/trio_threads/__init__.py

@@ -0,0 +1 @@
+

osn_selenium/webdrivers/trio_threads/blink/__init__.py

@@ -0,0 +1,124 @@
+import trio
+from typing import Optional, Type
+from osn_selenium.models import WindowRect
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.blink import BlinkFlagsManager
+from osn_selenium.flags.models.blink import BlinkFlags
+from osn_selenium.dev_tools.settings import DevToolsSettings
+from osn_selenium.webdrivers.trio_threads.core import CoreWebDriver
+from osn_selenium.webdrivers.trio_threads.blink.base import BlinkBaseMixin
+from osn_selenium.abstract.webdriver.blink import (
+	AbstractBlinkWebDriver
+)
+from osn_selenium.webdrivers.trio_threads.blink.casting import BlinkCastingMixin
+from osn_selenium.webdrivers.trio_threads.blink.logging import BlinkLoggingMixin
+from osn_selenium.webdrivers.trio_threads.blink.network import BlinkNetworkMixin
+from osn_selenium.webdrivers.trio_threads.blink.features import BlinkFeaturesMixin
+from osn_selenium.webdrivers.trio_threads.blink.settings import BlinkSettingsMixin
+from osn_selenium.webdrivers.trio_threads.blink.lifecycle import BlinkLifecycleMixin
+
+
+__all__ = ["BlinkWebDriver"]
+
+
+class BlinkWebDriver(
+		BlinkBaseMixin,
+		BlinkCastingMixin,
+		BlinkFeaturesMixin,
+		BlinkLifecycleMixin,
+		BlinkLoggingMixin,
+		BlinkNetworkMixin,
+		BlinkSettingsMixin,
+		CoreWebDriver,
+		AbstractBlinkWebDriver,
+):
+	"""
+	Concrete Blink 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,
+			browser_exe: Optional[PATH_TYPEHINT],
+			browser_name_in_system: str,
+			webdriver_path: str,
+			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,
+			devtools_settings: Optional[DevToolsSettings] = None,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+	):
+		"""
+		Initializes the BlinkWebDriver instance.
+
+		This constructor sets up the necessary components for controlling a Blink-based browser,
+		including paths, flag managers, timeouts, and integration with DevTools and Trio.
+		It also initializes properties related to console encoding and IP pattern matching
+		for managing browser processes.
+
+		Args:
+			browser_exe (Optional[PATH_TYPEHINT]): The path to the browser executable
+				(e.g., `chrome.exe` or `msedge.exe`). If None, the browser executable will not be
+				managed directly by this class (e.g., for remote WebDriver connections where the
+				browser is already running).
+			browser_name_in_system (str): The common name of the browser executable in the system
+				(e.g., "Chrome", "Edge"). Used to auto-detect `browser_exe` if `use_browser_exe` is True.
+			webdriver_path (str): The file path to the WebDriver executable (e.g., `chromedriver.exe`).
+			use_browser_exe (bool): If True, the browser executable path will be
+				automatically determined based on `browser_name_in_system` if `browser_exe`
+				is not explicitly provided. If False, `browser_exe` must be None.
+				Defaults to True.
+			flags_manager_type (Type[BlinkFlagsManager]): The type of flags manager to use.
+				Defaults to `BlinkFlagsManager`, which is suitable for Chrome/Edge.
+			flags (Optional[BlinkFlags]): Initial browser flags or options
+				specific to Blink-based browsers. Can be a `BlinkFlags` object or a generic mapping.
+				Defaults to None.
+			start_page_url (str): The URL that the browser will attempt to navigate to
+				immediately after starting. Defaults to an empty string.
+			implicitly_wait (int): The default implicit wait time in seconds for element searches.
+				Defaults to 5.
+			page_load_timeout (int): The default page load timeout in seconds. Defaults to 5.
+			script_timeout (int): The default asynchronous script timeout in seconds. Defaults to 5.
+			window_rect (Optional[WindowRect]): The initial window size and position. If None,
+				the browser's default window size will be used. Defaults to None.
+			devtools_settings (Optional[DevToolsSettings]): Configuration for Chrome DevTools Protocol.
+			capacity_limiter (Optional[trio.CapacityLimiter]): A Trio capacity limiter used to
+				throttle concurrent thread-based operations. Defaults to None.
+		"""
+		
+		CoreWebDriver.__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,
+				devtools_settings=devtools_settings,
+				capacity_limiter=capacity_limiter,
+		)
+		
+		BlinkBaseMixin.__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,
+		)

osn_selenium/webdrivers/trio_threads/blink/base.py

@@ -0,0 +1,133 @@
+import trio
+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.blink import BlinkFlags
+from osn_selenium.webdrivers.trio_threads.core.base import CoreBaseMixin
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.webdrivers.unified.blink.base import (
+	UnifiedBlinkBaseMixin
+)
+from osn_selenium.abstract.webdriver.blink.base import (
+	AbstractBlinkBaseMixin
+)
+from selenium.webdriver.chromium.webdriver import (
+	ChromiumDriver as legacyWebDriver
+)
+
+
+__all__ = ["BlinkBaseMixin"]
+
+
+class BlinkBaseMixin(UnifiedBlinkBaseMixin, CoreBaseMixin, AbstractBlinkBaseMixin):
+	"""
+	Base mixin for Blink 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,
+			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,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+	):
+		"""
+		Initializes the BlinkWebDriver instance.
+
+		This constructor sets up the necessary components for controlling a Blink-based browser,
+		including paths, flag managers, timeouts, and integration with DevTools and Trio.
+		It also initializes properties related to console encoding and IP pattern matching
+		for managing browser processes.
+
+		Args:
+			browser_exe (Optional[PATH_TYPEHINT]): The path to the browser executable
+				(e.g., `chrome.exe` or `msedge.exe`). If None, the browser executable will not be
+				managed directly by this class (e.g., for remote WebDriver connections where the
+				browser is already running).
+			browser_name_in_system (str): The common name of the browser executable in the system
+				(e.g., "Chrome", "Edge"). Used to auto-detect `browser_exe` if `use_browser_exe` is True.
+			webdriver_path (str): The file path to the WebDriver executable (e.g., `chromedriver.exe`).
+			use_browser_exe (bool): If True, the browser executable path will be
+				automatically determined based on `browser_name_in_system` if `browser_exe`
+				is not explicitly provided. If False, `browser_exe` must be None.
+				Defaults to True.
+			flags_manager_type (Type[BlinkFlagsManager]): The type of flags manager to use.
+				Defaults to `BlinkFlagsManager`, which is suitable for Chrome/Edge.
+			flags (Optional[BlinkFlags]): Initial browser flags or options
+				specific to Blink-based browsers. Can be a `BlinkFlags` object or a generic mapping.
+				Defaults to None.
+			start_page_url (str): The URL that the browser will attempt to navigate to
+				immediately after starting. Defaults to an empty string.
+			implicitly_wait (int): The default implicit wait time in seconds for element searches.
+				Defaults to 5.
+			page_load_timeout (int): The default page load timeout in seconds. Defaults to 5.
+			script_timeout (int): The default asynchronous script timeout in seconds. Defaults to 5.
+			window_rect (Optional[WindowRect]): The initial window size and position. If None,
+				the browser's default window size will be used. Defaults to None.
+			capacity_limiter (Optional[trio.CapacityLimiter]): A Trio capacity limiter used to
+				throttle concurrent thread-based operations. 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,
+				capacity_limiter=capacity_limiter,
+		)
+		
+		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 browser_exe(self) -> Optional[pathlib.Path]:
+		return self._browser_exe_impl
+	
+	@property
+	def debugging_ip(self) -> Optional[str]:
+		return self._debugging_ip_impl
+	
+	@property
+	def debugging_port(self) -> Optional[int]:
+		return self._debugging_port_impl
+	
+	@property
+	def driver(self) -> Optional[legacyWebDriver]:
+		return self._driver_impl
+	
+	def set_start_page_url(self, start_page_url: str) -> None:
+		self._webdriver_flags_manager.start_page_url = start_page_url

osn_selenium/webdrivers/trio_threads/blink/casting.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, List
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.blink.casting import (
+	UnifiedBlinkCastingMixin
+)
+from osn_selenium.abstract.webdriver.blink.casting import (
+	AbstractBlinkCastingMixin
+)
+
+
+__all__ = ["BlinkCastingMixin"]
+
+
+class BlinkCastingMixin(UnifiedBlinkCastingMixin, TrioThreadMixin, AbstractBlinkCastingMixin):
+	"""
+	Mixin handling object type casting and wrapping for Blink WebDrivers.
+
+	Ensures that raw Selenium objects are converted into their corresponding
+	internal wrapper representations and vice versa during method calls.
+	"""
+	
+	async def get_sinks(self) -> List[Dict[str, Any]]:
+		return await self.sync_to_trio(sync_function=self._get_sinks_impl)()
+	
+	async def set_sink_to_use(self, sink_name: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._set_sink_to_use_impl)(sink_name=sink_name)
+	
+	async def start_desktop_mirroring(self, sink_name: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._start_desktop_mirroring_impl)(sink_name=sink_name)
+	
+	async def start_tab_mirroring(self, sink_name: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._start_tab_mirroring_impl)(sink_name=sink_name)
+	
+	async def stop_casting(self, sink_name: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._stop_casting_impl)(sink_name=sink_name)

osn_selenium/webdrivers/trio_threads/blink/features.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.blink.features import (
+	UnifiedBlinkFeaturesMixin
+)
+from osn_selenium.abstract.webdriver.blink.features import (
+	AbstractBlinkFeaturesMixin
+)
+
+
+__all__ = ["BlinkFeaturesMixin"]
+
+
+class BlinkFeaturesMixin(UnifiedBlinkFeaturesMixin, TrioThreadMixin, AbstractBlinkFeaturesMixin):
+	"""
+	Mixin for managing browser features and capabilities for Blink WebDrivers.
+
+	Provides interfaces to query, enable, or disable specific browser features
+	and inspect the supported capabilities of the current session.
+	"""
+	
+	async def get_issue_message(self) -> Any:
+		return await self.sync_to_trio(sync_function=self._get_issue_message_impl)()
+	
+	async def launch_app(self, id: str) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._launch_app_impl)(id=id)
+	
+	async def set_permissions(self, name: str, value: str) -> None:
+		await self.sync_to_trio(sync_function=self._set_permissions_impl)(name=name, value=value)

osn_selenium/webdrivers/trio_threads/blink/lifecycle.py

@@ -0,0 +1,66 @@
+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.webdrivers.trio_threads.core.lifecycle import CoreLifecycleMixin
+from osn_selenium.webdrivers.unified.blink.lifecycle import (
+	UnifiedBlinkLifecycleMixin
+)
+from osn_selenium.abstract.webdriver.blink.lifecycle import (
+	AbstractBlinkLifecycleMixin
+)
+
+
+__all__ = ["BlinkLifecycleMixin"]
+
+
+class BlinkLifecycleMixin(
+		UnifiedBlinkLifecycleMixin,
+		CoreLifecycleMixin,
+		AbstractBlinkLifecycleMixin
+):
+	"""
+	Mixin for managing the lifecycle of the Blink 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 restart_webdriver(
+			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:
+		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[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:
+		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/blink/logging.py

@@ -0,0 +1,26 @@
+from typing import Any
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.blink.logging import (
+	UnifiedBlinkLoggingMixin
+)
+from osn_selenium.abstract.webdriver.blink.logging import (
+	AbstractBlinkLoggingMixin
+)
+
+
+__all__ = ["BlinkLoggingMixin"]
+
+
+class BlinkLoggingMixin(UnifiedBlinkLoggingMixin, TrioThreadMixin, AbstractBlinkLoggingMixin):
+	"""
+	Mixin for retrieving and managing browser logs for Blink WebDrivers.
+
+	Allows access to various log types (e.g., browser, performance, driver)
+	generated during the session execution.
+	"""
+	
+	async def get_log(self, log_type: str) -> Any:
+		return await self.sync_to_trio(sync_function=self._get_log_impl)(log_type=log_type)
+	
+	async def log_types(self) -> Any:
+		return await self.sync_to_trio(sync_function=self._log_types_impl)()

osn_selenium/webdrivers/trio_threads/blink/network.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict
+from osn_selenium.base_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.blink.network import (
+	UnifiedBlinkNetworkMixin
+)
+from osn_selenium.abstract.webdriver.blink.network import (
+	AbstractBlinkNetworkMixin
+)
+
+
+__all__ = ["BlinkNetworkMixin"]
+
+
+class BlinkNetworkMixin(UnifiedBlinkNetworkMixin, TrioThreadMixin, AbstractBlinkNetworkMixin):
+	"""
+	Mixin for network interception and condition simulation for Blink WebDrivers.
+
+	Facilitates monitoring of network traffic, modifying requests/responses,
+	and emulating specific network conditions like offline mode or latency.
+	"""
+	
+	async def delete_network_conditions(self) -> None:
+		await self.sync_to_trio(sync_function=self._delete_network_conditions_impl)()
+	
+	async def get_network_conditions(self) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._get_network_conditions_impl)()
+	
+	async def set_network_conditions(self, **network_conditions: Any) -> None:
+		await self.sync_to_trio(sync_function=self._set_network_conditions_impl)(**network_conditions)