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

osn_selenium/webdrivers/trio_threads/core/__init__.py

@@ -0,0 +1,115 @@
+import trio
+from osn_selenium.models import WindowRect
+from typing import (
+	Mapping,
+	Optional,
+	Type
+)
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.dev_tools.manager import DevTools
+from osn_selenium.flags.base import BrowserFlagsManager
+from osn_selenium.flags.models.base import BrowserFlags
+from osn_selenium.dev_tools.settings import DevToolsSettings
+from osn_selenium.webdrivers.trio_threads.core.auth import CoreAuthMixin
+from osn_selenium.webdrivers.trio_threads.core.base import CoreBaseMixin
+from osn_selenium.webdrivers.trio_threads.core.file import CoreFileMixin
+from osn_selenium.abstract.webdriver.core import (
+	AbstractCoreWebDriver
+)
+from osn_selenium.webdrivers.trio_threads.core.script import CoreScriptMixin
+from osn_selenium.webdrivers.trio_threads.core.window import CoreWindowMixin
+from osn_selenium.webdrivers.trio_threads.core.actions import CoreActionsMixin
+from osn_selenium.webdrivers.trio_threads.core.capture import CoreCaptureMixin
+from osn_selenium.webdrivers.trio_threads.core.element import CoreElementMixin
+from osn_selenium.webdrivers.trio_threads.core.storage import CoreStorageMixin
+from osn_selenium.webdrivers.trio_threads.core.devtools import CoreDevToolsMixin
+from osn_selenium.webdrivers.trio_threads.core.settings import CoreSettingsMixin
+from osn_selenium.webdrivers.trio_threads.core.timeouts import CoreTimeoutsMixin
+from osn_selenium.webdrivers.trio_threads.core.lifecycle import CoreLifecycleMixin
+from osn_selenium.webdrivers.trio_threads.core.comonents import CoreComponentsMixin
+from osn_selenium.webdrivers.trio_threads.core.navigation import CoreNavigationMixin
+
+
+__all__ = ["CoreWebDriver"]
+
+
+class CoreWebDriver(
+		CoreActionsMixin,
+		CoreAuthMixin,
+		CoreBaseMixin,
+		CoreCaptureMixin,
+		CoreComponentsMixin,
+		CoreDevToolsMixin,
+		CoreElementMixin,
+		CoreFileMixin,
+		CoreLifecycleMixin,
+		CoreNavigationMixin,
+		CoreScriptMixin,
+		CoreSettingsMixin,
+		CoreStorageMixin,
+		CoreTimeoutsMixin,
+		CoreWindowMixin,
+		AbstractCoreWebDriver,
+):
+	"""
+	Concrete Core 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[BrowserFlagsManager] = BrowserFlagsManager,
+			flags: Optional[BrowserFlags] = None,
+			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,
+	) -> None:
+		"""
+		Initializes the main WebDriver instance with Trio thread support.
+
+		Args:
+			webdriver_path (str): The file path to the WebDriver executable.
+			flags_manager_type (Type[BrowserFlagsManager]): The class type used to manage
+				browser-specific configuration flags. Defaults to BrowserFlagsManager.
+			flags (Optional[BrowserFlags]): Initial set of browser flags or options
+				to apply upon startup. Defaults to None.
+			implicitly_wait (int): The amount of time (in seconds) that the driver should
+				wait when searching for elements. Defaults to 5.
+			page_load_timeout (int): The amount of time (in seconds) to wait for a page
+				load to complete. Defaults to 5.
+			script_timeout (int): The amount of time (in seconds) to wait for an
+				asynchronous script to finish execution. Defaults to 5.
+			window_rect (Optional[WindowRect]): The initial size and position of the
+				browser window. 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.
+		"""
+		
+		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,
+				cdp_versioned_packages_paths=cdp_versioned_packages_paths,
+				ignore_cdp_version_package_missing=ignore_cdp_version_package_missing,
+		)
+		
+		self._devtools = DevTools(parent_webdriver=self, devtools_settings=devtools_settings)
+	
+	@property
+	def devtools(self) -> DevTools:
+		return self._devtools

osn_selenium/webdrivers/trio_threads/core/actions.py

@@ -0,0 +1,72 @@
+from typing import (
+	Iterable,
+	List,
+	Optional
+)
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium._typehints import DEVICES_TYPEHINT
+from osn_selenium.webdrivers._bridges import (
+	get_js_executor_bridge
+)
+from osn_selenium.instances.trio_threads.action_chains import ActionChains
+from osn_selenium.webdrivers.trio_threads.core.script import CoreScriptMixin
+from osn_selenium.instances.trio_threads.web_driver_wait import WebDriverWait
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.actions import (
+	UnifiedCoreActionsMixin
+)
+from osn_selenium.abstract.webdriver.core.actions import (
+	AbstractCoreActionsMixin
+)
+
+
+__all__ = ["CoreActionsMixin"]
+
+
+class CoreActionsMixin(
+		UnifiedCoreActionsMixin,
+		CoreScriptMixin,
+		TrioThreadMixin,
+		AbstractCoreActionsMixin
+):
+	"""
+	Mixin providing high-level interaction capabilities for Core WebDrivers.
+
+	Includes factories for standard and human-like ActionChains, as well as
+	custom WebDriverWait implementations.
+	"""
+	
+	def action_chains(
+			self,
+			duration: int = 250,
+			devices: Optional[List[DEVICES_TYPEHINT]] = None,
+	) -> ActionChains:
+		legacy = self._action_chains_impl(duration=duration, devices=devices)
+		
+		return ActionChains(
+				selenium_action_chains=legacy,
+				execute_js_script_function=get_js_executor_bridge(self),
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	def web_driver_wait(
+			self,
+			timeout: float,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Optional[Iterable[BaseException]] = None,
+	) -> WebDriverWait:
+		legacy = self._web_driver_wait_impl(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions
+		)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebDriverWait,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/webdrivers/trio_threads/core/auth.py

@@ -0,0 +1,88 @@
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	List,
+	Optional,
+	Union
+)
+from osn_selenium.instances.trio_threads.fedcm import FedCM
+from osn_selenium.instances.trio_threads.dialog import Dialog
+from osn_selenium.webdrivers.unified.core.auth import UnifiedCoreAuthMixin
+from osn_selenium.abstract.webdriver.core.auth import (
+	AbstractCoreAuthMixin
+)
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from selenium.webdriver.common.virtual_authenticator import (
+	Credential,
+	VirtualAuthenticatorOptions
+)
+
+
+__all__ = ["CoreAuthMixin"]
+
+
+class CoreAuthMixin(UnifiedCoreAuthMixin, TrioThreadMixin, AbstractCoreAuthMixin):
+	"""
+	Mixin handling authentication and credential management for Core WebDrivers.
+
+	Provides interfaces for adding/removing credentials, managing virtual
+	authenticators, and handling Federated Credential Management (FedCM) dialogs.
+	"""
+	
+	async def add_credential(self, credential: Credential) -> None:
+		await self.sync_to_trio(sync_function=self._add_credential_impl)(credential=credential)
+	
+	async def add_virtual_authenticator(self, options: VirtualAuthenticatorOptions) -> None:
+		await self.sync_to_trio(sync_function=self._add_virtual_authenticator_impl)(options=options)
+	
+	async def fedcm(self) -> FedCM:
+		legacy = await self.sync_to_trio(sync_function=self._fedcm_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=FedCM,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def fedcm_dialog(
+			self,
+			timeout: int = 5,
+			poll_frequency: float = 0.5,
+			ignored_exceptions: Any = None,
+	) -> Dialog:
+		legacy = await self.sync_to_trio(sync_function=self._fedcm_dialog_impl)(
+				timeout=timeout,
+				poll_frequency=poll_frequency,
+				ignored_exceptions=ignored_exceptions,
+		)
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Dialog,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def get_credentials(self) -> List[Credential]:
+		return await self.sync_to_trio(sync_function=self._get_credentials_impl)()
+	
+	async def remove_all_credentials(self) -> None:
+		await self.sync_to_trio(sync_function=self._remove_all_credentials_impl)()
+	
+	async def remove_credential(self, credential_id: Union[str, bytearray]) -> None:
+		await self.sync_to_trio(sync_function=self._remove_credential_impl)(credential_id=credential_id)
+	
+	async def remove_virtual_authenticator(self) -> None:
+		await self.sync_to_trio(sync_function=self._remove_virtual_authenticator_impl)()
+	
+	async def set_user_verified(self, verified: bool) -> None:
+		await self.sync_to_trio(sync_function=self._set_user_verified_impl)(verified=verified)
+	
+	async def supports_fedcm(self) -> bool:
+		return await self.sync_to_trio(sync_function=self._supports_fedcm_impl)()
+	
+	async def virtual_authenticator_id(self) -> Optional[str]:
+		return await self.sync_to_trio(sync_function=self._virtual_authenticator_id_impl)()

osn_selenium/webdrivers/trio_threads/core/base.py

@@ -0,0 +1,199 @@
+import trio
+from osn_selenium.models import WindowRect
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.flags.base import BrowserFlagsManager
+from osn_selenium.flags.models.base import BrowserFlags
+from selenium.webdriver.common.bidi.session import Session
+from typing import (
+	Any,
+	Dict,
+	Mapping,
+	Optional,
+	Type
+)
+from selenium.webdriver.remote.errorhandler import ErrorHandler
+from osn_selenium.executors.trio_threads.cdp import CDPExecutor
+from osn_selenium.executors.trio_threads.javascript import JSExecutor
+from selenium.webdriver.remote.locator_converter import LocatorConverter
+from selenium.webdriver.remote.remote_connection import RemoteConnection
+from osn_selenium.webdrivers.unified.core.base import UnifiedCoreBaseMixin
+from osn_selenium._typehints import (
+	ARCHITECTURES_TYPEHINT,
+	PATH_TYPEHINT
+)
+from osn_selenium.abstract.webdriver.core.base import (
+	AbstractCoreBaseMixin
+)
+from selenium.webdriver.remote.webdriver import (
+	WebDriver as legacyWebDriver
+)
+from osn_selenium.webdrivers._bridges import (
+	get_cdp_executor_bridge,
+	get_js_executor_bridge
+)
+
+
+__all__ = ["CoreBaseMixin"]
+
+
+class CoreBaseMixin(UnifiedCoreBaseMixin, TrioThreadMixin, AbstractCoreBaseMixin):
+	"""
+	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,
+			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,
+			capacity_limiter: Optional[trio.CapacityLimiter] = None,
+			cdp_versioned_packages_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+			ignore_cdp_version_package_missing: bool = True,
+	) -> None:
+		"""
+		Initializes the base mixin for Trio-based WebDrivers.
+
+		Sets up the core synchronization primitives, default timeouts,
+		and the browser flag manager.
+
+		Args:
+			webdriver_path (str): The file path to the WebDriver executable.
+			flags_manager_type (Type[BrowserFlagsManager]): The class type used to manage
+				browser-specific configuration flags. Defaults to BrowserFlagsManager.
+			flags (Optional[BrowserFlags]): Initial set of browser flags or options
+				to apply upon startup. Defaults to None.
+			implicitly_wait (int): The amount of time (in seconds) that the driver should
+				wait when searching for elements. Defaults to 5.
+			page_load_timeout (int): The amount of time (in seconds) to wait for a page
+				load to complete. Defaults to 5.
+			script_timeout (int): The amount of time (in seconds) to wait for an
+				asynchronous script to finish execution. Defaults to 5.
+			window_rect (Optional[WindowRect]): The initial size and position of the
+				browser window. Defaults to None.
+			capacity_limiter (Optional[trio.CapacityLimiter]): A Trio capacity limiter used to
+				throttle concurrent thread-based operations. Defaults to None.
+			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.
+		"""
+		
+		UnifiedCoreBaseMixin.__init__(
+				self,
+				webdriver_path=webdriver_path,
+				architecture="trio_threads",
+				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,
+				cdp_versioned_packages_paths=cdp_versioned_packages_paths,
+				ignore_cdp_version_package_missing=ignore_cdp_version_package_missing,
+		)
+		
+		TrioThreadMixin.__init__(
+				self,
+				lock=trio.Lock(),
+				limiter=capacity_limiter
+				if capacity_limiter is not None
+				else trio.CapacityLimiter(100),
+		)
+		
+		self._cdp_executor = CDPExecutor(
+				execute_function=get_cdp_executor_bridge(self),
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+		
+		self._js_executor = JSExecutor(
+				execute_function=get_js_executor_bridge(self),
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	@property
+	def architecture(self) -> ARCHITECTURES_TYPEHINT:
+		return self._architecture_impl
+	
+	@property
+	def capabilities(self) -> Dict[str, Any]:
+		return self._capabilities_impl()
+	
+	@property
+	def caps(self) -> Dict[str, Any]:
+		return self._caps_get_impl()
+	
+	@caps.setter
+	def caps(self, value: Dict[str, Any]) -> None:
+		self._caps_set_impl(value=value)
+	
+	@property
+	def cdp(self) -> CDPExecutor:
+		return self._cdp_executor
+	
+	@property
+	def command_executor(self) -> RemoteConnection:
+		return self._command_executor_get_impl()
+	
+	@command_executor.setter
+	def command_executor(self, value: RemoteConnection) -> None:
+		self._command_executor_set_impl(value=value)
+	
+	@property
+	def driver(self) -> Optional[legacyWebDriver]:
+		return self._driver_impl
+	
+	@property
+	def error_handler(self) -> ErrorHandler:
+		return self._error_handler_get_impl()
+	
+	@error_handler.setter
+	def error_handler(self, value: ErrorHandler) -> None:
+		self._error_handler_set_impl(value=value)
+	
+	async def execute(self, driver_command: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+		return await self.sync_to_trio(sync_function=self._execute_impl)(driver_command=driver_command, params=params)
+	
+	@property
+	def is_active(self) -> bool:
+		return self._is_active_impl
+	
+	@property
+	def javascript(self) -> JSExecutor:
+		return self._js_executor
+	
+	@property
+	def locator_converter(self) -> LocatorConverter:
+		return self._locator_converter_get_impl()
+	
+	@locator_converter.setter
+	def locator_converter(self, value: LocatorConverter) -> None:
+		self._locator_converter_set_impl(value=value)
+	
+	@property
+	def name(self) -> str:
+		return self._name_impl()
+	
+	@property
+	def pinned_scripts(self) -> Dict[str, Any]:
+		return self._pinned_scripts_get_impl()
+	
+	@pinned_scripts.setter
+	def pinned_scripts(self, value: Dict[str, Any]) -> None:
+		self._pinned_scripts_set_impl(value=value)
+	
+	async def session(self) -> Session:
+		return await self.sync_to_trio(sync_function=self._session_impl)()
+	
+	@property
+	def session_id(self) -> Optional[str]:
+		return self._session_id_get_impl()
+	
+	@session_id.setter
+	def session_id(self, value: Optional[str]) -> None:
+		self._session_id_set_impl(value=value)

osn_selenium/webdrivers/trio_threads/core/capture.py

@@ -0,0 +1,38 @@
+from typing import Any, Optional
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.webdrivers.unified.core.capture import (
+	UnifiedCoreCaptureMixin
+)
+from osn_selenium.abstract.webdriver.core.capture import (
+	AbstractCoreCaptureMixin
+)
+
+
+__all__ = ["CoreCaptureMixin"]
+
+
+class CoreCaptureMixin(UnifiedCoreCaptureMixin, TrioThreadMixin, AbstractCoreCaptureMixin):
+	"""
+	Mixin enabling screen capture and page source retrieval for Core WebDrivers.
+
+	Offers methods to take screenshots (file, base64, png), print pages,
+	and extract the current DOM source.
+	"""
+	
+	async def get_screenshot_as_base64(self) -> str:
+		return await self.sync_to_trio(sync_function=self._get_screenshot_as_base64_impl)()
+	
+	async def get_screenshot_as_file(self, filename: str) -> bool:
+		return await self.sync_to_trio(sync_function=self._get_screenshot_as_file_impl)(filename=filename)
+	
+	async def get_screenshot_as_png(self) -> bytes:
+		return await self.sync_to_trio(sync_function=self._get_screenshot_as_png_impl)()
+	
+	async def page_source(self) -> str:
+		return await self.sync_to_trio(sync_function=self._page_source_impl)()
+	
+	async def print_page(self, print_options: Optional[Any] = None) -> str:
+		return await self.sync_to_trio(sync_function=self._print_page_impl)(print_options=print_options)
+	
+	async def save_screenshot(self, filename: str) -> bool:
+		return await self.sync_to_trio(sync_function=self._save_screenshot_impl)(filename=filename)

osn_selenium/webdrivers/trio_threads/core/comonents.py

@@ -0,0 +1,92 @@
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from osn_selenium.instances.trio_threads.dialog import Dialog
+from osn_selenium.instances.trio_threads.mobile import Mobile
+from osn_selenium.instances.trio_threads.browser import Browser
+from osn_selenium.instances.trio_threads.permissions import Permissions
+from osn_selenium.instances.trio_threads.web_extension import WebExtension
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.instances.trio_threads.browsing_context import BrowsingContext
+from osn_selenium.webdrivers.unified.core.components import (
+	UnifiedCoreComponentsMixin
+)
+from osn_selenium.abstract.webdriver.core.components import (
+	AbstractCoreComponentsMixin
+)
+
+
+__all__ = ["CoreComponentsMixin"]
+
+
+class CoreComponentsMixin(
+		UnifiedCoreComponentsMixin,
+		TrioThreadMixin,
+		AbstractCoreComponentsMixin
+):
+	"""
+	Mixin providing access to specialized browser components for Core WebDrivers.
+
+	Exposes interfaces for interacting with specific browser domains such as
+	permissions, mobile emulation, dialog handling, and web extensions.
+	"""
+	
+	async def browser(self) -> Browser:
+		legacy = await self.sync_to_trio(sync_function=self._browser_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Browser,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def browsing_context(self) -> BrowsingContext:
+		legacy = await self.sync_to_trio(sync_function=self._browsing_context_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=BrowsingContext,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def dialog(self) -> Dialog:
+		legacy = await self.sync_to_trio(sync_function=self._dialog_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Dialog,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def mobile(self) -> Mobile:
+		legacy = await self.sync_to_trio(sync_function=self._mobile_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Mobile,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def permissions(self) -> Permissions:
+		legacy = await self.sync_to_trio(sync_function=self._permissions_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Permissions,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def webextension(self) -> WebExtension:
+		legacy = await self.sync_to_trio(sync_function=self._webextension_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=WebExtension,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)

osn_selenium/webdrivers/trio_threads/core/devtools.py

@@ -0,0 +1,53 @@
+from contextlib import asynccontextmanager
+from osn_selenium.trio_threads_mixin import TrioThreadMixin
+from typing import (
+	Any,
+	AsyncGenerator,
+	Dict,
+	Tuple
+)
+from osn_selenium.instances.trio_threads.network import Network
+from selenium.webdriver.remote.bidi_connection import BidiConnection
+from selenium.webdriver.remote.websocket_connection import WebSocketConnection
+from osn_selenium.instances.convert import (
+	get_trio_thread_instance_wrapper
+)
+from osn_selenium.webdrivers.unified.core.devtools import (
+	UnifiedCoreDevToolsMixin
+)
+from osn_selenium.abstract.webdriver.core.devtools import (
+	AbstractCoreDevToolsMixin
+)
+
+
+__all__ = ["CoreDevToolsMixin"]
+
+
+class CoreDevToolsMixin(UnifiedCoreDevToolsMixin, TrioThreadMixin, AbstractCoreDevToolsMixin):
+	"""
+	Mixin for Chrome DevTools Protocol (CDP) and BiDi interactions in Core WebDrivers.
+
+	Facilitates low-level browser control via CDP commands, network interception,
+	and bidirectional communication sessions.
+	"""
+	
+	@asynccontextmanager
+	async def bidi_connection(self) -> AsyncGenerator[BidiConnection, Any]:
+		async with self._bidi_connection_impl() as bidi:
+			yield bidi
+	
+	async def execute_cdp_cmd(self, cmd: str, cmd_args: Dict[str, Any]) -> Any:
+		return await self.sync_to_trio(sync_function=self._execute_cdp_cmd_impl)(cmd=cmd, cmd_args=cmd_args)
+	
+	async def network(self) -> Network:
+		legacy = await self.sync_to_trio(sync_function=self._network_impl)()
+		
+		return get_trio_thread_instance_wrapper(
+				wrapper_class=Network,
+				legacy_object=legacy,
+				lock=self._lock,
+				limiter=self._capacity_limiter,
+		)
+	
+	async def start_devtools(self) -> Tuple[Any, WebSocketConnection]:
+		return await self.sync_to_trio(sync_function=self._start_devtools_impl)()