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

osn_selenium/dev_tools/logger/target.py

@@ -6,10 +6,10 @@ from typing import (
 	Tuple
 )
 from osn_selenium.dev_tools.models import TargetData
+from osn_selenium._exception_helpers import log_exception
 from osn_selenium.dev_tools.settings import LoggerSettings
 from osn_selenium.exceptions.devtools import TrioEndExceptions
 from osn_selenium.dev_tools._validators import validate_log_filter
-from osn_selenium.dev_tools._exception_helpers import log_exception
 from osn_selenium.dev_tools.logger.models import (
 	CDPTargetLogEntry,
 	FingerprintTargetLogEntry
@@ -30,7 +30,7 @@ class TargetLogger:
 	def __init__(
 			self,
 			logger_settings: LoggerSettings,
-			nursery_object: trio.Nursery,
+			nursery: trio.Nursery,
 			target_data: TargetData,
 			cdp_receive_channel: Optional[trio.MemoryReceiveChannel[CDPTargetLogEntry]],
 			fingerprint_receive_channel: Optional[trio.MemoryReceiveChannel[FingerprintTargetLogEntry]],
@@ -40,7 +40,7 @@ class TargetLogger:
 
 		Args:
 			logger_settings (LoggerSettings): Configuration for logging.
-			nursery_object (trio.Nursery): The Trio nursery to spawn background tasks.
+			nursery (trio.Nursery): The Trio nursery to spawn background tasks.
 			target_data (TargetData): The data of the browser target this logger will log for.
 			cdp_receive_channel (Optional[trio.MemoryReceiveChannel[CDPTargetLogEntry]]):
 				Channel to receive CDP logs.
@@ -52,7 +52,7 @@ class TargetLogger:
 		"""
 		
 		self._target_data = target_data
-		self._nursery_object = nursery_object
+		self._nursery = nursery
 		self._cdp_receive_channel = cdp_receive_channel
 		self._fingerprint_receive_channel = fingerprint_receive_channel
 		self._cdp_file_path: Optional[pathlib.Path] = None
@@ -220,12 +220,12 @@ class TargetLogger:
 				self._cdp_file_writing_stopped = trio.Event()
 		
 				if self._cdp_file_path is not None:
-					self._nursery_object.start_soon(self._write_cdp_file)
+					self._nursery.start_soon(self._write_cdp_file)
 		
 				self._fingerprint_file_writing_stopped = trio.Event()
 		
 				if self._fingerprint_file_path is not None:
-					self._nursery_object.start_soon(self._write_fingerprint_file)
+					self._nursery.start_soon(self._write_fingerprint_file)
 		
 				self._is_active = True
 		except* TrioEndExceptions:
@@ -269,7 +269,7 @@ def build_target_logger(
 	
 	target_logger = TargetLogger(
 			logger_settings=logger_settings,
-			nursery_object=nursery_object,
+			nursery=nursery_object,
 			target_data=target_data,
 			cdp_receive_channel=cdp_recv,
 			fingerprint_receive_channel=fp_recv,

osn_selenium/dev_tools/manager/base.py

@@ -1,20 +1,15 @@
 import trio
-from contextlib import (
-	AbstractAsyncContextManager
-)
+from typing import Dict, Optional
+from contextlib import AsyncExitStack
 from osn_selenium.dev_tools.target import DevToolsTarget
 from osn_selenium.dev_tools.logger.main import MainLogger
-from osn_selenium.dev_tools.domains import DomainsSettings
 from osn_selenium.dev_tools._wrappers import DevToolsPackage
 from osn_selenium.dev_tools.settings import DevToolsSettings
-from typing import (
-	Any,
-	Dict,
-	Optional,
-	TYPE_CHECKING
-)
 from osn_selenium.dev_tools._system_utils import prepare_log_dir
 from selenium.webdriver.remote.bidi_connection import BidiConnection
+from osn_selenium.webdrivers._typehints import (
+	ANY_TRIO_WEBDRIVER_TYPEHINT
+)
 from osn_selenium.dev_tools.logger.models import (
 	CDPLogLevelStats,
 	CDPMainLogEntry,
@@ -27,9 +22,6 @@ from osn_selenium.dev_tools.logger.models import (
 
 __all__ = ["BaseMixin"]
 
-if TYPE_CHECKING:
-	from osn_selenium.webdrivers.trio_threads.core import CoreWebDriver
-
 
 class BaseMixin:
 	"""
@@ -47,14 +39,14 @@ class BaseMixin:
 	
 	def __init__(
 			self,
-			parent_webdriver: "CoreWebDriver",
+			parent_webdriver: ANY_TRIO_WEBDRIVER_TYPEHINT,
 			devtools_settings: Optional[DevToolsSettings] = None
 	):
 		"""
 		Initializes the DevTools manager.
 
 		Args:
-			parent_webdriver (CoreWebDriver): The WebDriver instance to which this DevTools manager is attached.
+			parent_webdriver (ANY_TRIO_WEBDRIVER_TYPEHINT): The WebDriver instance to which this DevTools manager is attached.
 			devtools_settings (Optional[DevToolsSettings]): Configuration settings for DevTools.
 				If None, default settings will be used.
 		"""
@@ -74,12 +66,11 @@ class BaseMixin:
 			for filter_ in devtools_settings.new_targets_filter
 		] if devtools_settings.new_targets_filter is not None else None
 		
-		self._bidi_connection: Optional[AbstractAsyncContextManager[BidiConnection, Any]] = None
-		self._bidi_connection_object: Optional[BidiConnection] = None
+		self._bidi_connection: Optional[BidiConnection] = None
+		self._nursery: Optional[trio.Nursery] = None
+		self._exit_stack = AsyncExitStack()
 		self._devtools_package: Optional[DevToolsPackage] = None
 		self._websocket_url: Optional[str] = None
-		self._nursery: Optional[AbstractAsyncContextManager[trio.Nursery, Optional[bool]]] = None
-		self._nursery_object: Optional[trio.Nursery] = None
 		self._handling_targets: Dict[str, DevToolsTarget] = {}
 		self.targets_lock = trio.Lock()
 		self.exit_event: Optional[trio.Event] = None

osn_selenium/dev_tools/manager/lifecycle.py

@@ -1,15 +1,16 @@
 import trio
 from types import TracebackType
 from typing import Optional, Type
-from osn_selenium.dev_tools._decorators import log_on_error
+from osn_selenium._decorators import log_on_error
+from osn_selenium._exception_helpers import log_exception
 from osn_selenium.dev_tools._wrappers import DevToolsPackage
 from osn_selenium.dev_tools.manager.targets import TargetsMixin
 from osn_selenium.dev_tools.logger.main import build_main_logger
-from osn_selenium.dev_tools._exception_helpers import log_exception
 from osn_selenium.exceptions.devtools import (
 	BidiConnectionNotEstablishedError,
 	CDPEndExceptions,
-	CantEnterDevToolsContextError
+	CantEnterDevToolsContextError,
+	TrioEndExceptions
 )
 
 
@@ -41,9 +42,11 @@ class LifecycleMixin(TargetsMixin):
 		
 			if driver is None:
 				self._websocket_url = None
+				return
 		
 			if driver.caps.get("se:cdp"):
 				self._websocket_url = driver.caps.get("se:cdp")
+				return
 		
 			self._websocket_url = driver._get_cdp_details()[1]
 		except CDPEndExceptions as error:
@@ -64,8 +67,8 @@ class LifecycleMixin(TargetsMixin):
 		"""
 		
 		try:
-			if self._bidi_connection_object is not None:
-				self._devtools_package = DevToolsPackage(package=self._bidi_connection_object.devtools)
+			if self._bidi_connection is not None:
+				self._devtools_package = DevToolsPackage(package=self._bidi_connection.devtools)
 			else:
 				raise BidiConnectionNotEstablishedError()
 		except CDPEndExceptions as error:
@@ -74,9 +77,9 @@ class LifecycleMixin(TargetsMixin):
 			log_exception(error)
 			raise error
 	
-	async def run(self) -> None:
+	async def start(self) -> None:
 		"""
-		Initializes and runs the DevTools manager.
+		Initializes and starts the DevTools manager.
 
 		This method sets up the BiDi connection, starts the Trio nursery, retrieves
 		necessary CDP packages and URLs, initializes the main logger, and adds the
@@ -89,21 +92,18 @@ class LifecycleMixin(TargetsMixin):
 		if self._webdriver.driver is None:
 			raise CantEnterDevToolsContextError(reason="Driver is not initialized")
 		
-		self._bidi_connection = self._webdriver.bidi_connection()
-		self._bidi_connection_object = await self._bidi_connection.__aenter__()
-		
-		self._nursery = trio.open_nursery()
-		self._nursery_object = await self._nursery.__aenter__()
+		self._nursery = await self._exit_stack.enter_async_context(trio.open_nursery())
+		self._bidi_connection = await self._exit_stack.enter_async_context(self._webdriver.bidi_connection())
 		
 		self._get_devtools_package()
 		self._get_websocket_url()
 		
-		self._main_logger_cdp_send_channel, self._main_logger_fingerprint_send_channel, self._main_logger = build_main_logger(self._nursery_object, self._logger_settings)
+		self._main_logger_cdp_send_channel, self._main_logger_fingerprint_send_channel, self._main_logger = build_main_logger(nursery=self._nursery, logger_settings=self._logger_settings)
 		await self._main_logger.run()
 		
 		self.exit_event = trio.Event()
 		
-		self._fingerprint_injection_script = await self._webdriver.sync_to_trio(sync_function=self._fingerprint_settings.generate_js)()
+		self._fingerprint_injection_script = await self._webdriver.sync_to_trio(sync_function=self._fingerprint_settings.generate_js)() if self._fingerprint_settings is not None else None
 		main_target = (await self._get_all_targets())[0]
 		
 		await self._add_target(target_event=main_target, is_main_target=True)
@@ -122,44 +122,46 @@ class LifecycleMixin(TargetsMixin):
 			BaseException: If any other unexpected error occurs during context entry.
 		"""
 		
-		await self.run()
+		await self.start()
 	
-	async def stop(
-			self,
-			exc_type: Optional[Type[BaseException]],
-			exc_val: Optional[BaseException],
-			exc_tb: Optional[TracebackType],
-	) -> None:
+	async def stop(self) -> None:
 		"""
 		Stops the DevTools manager and cleans up resources.
 
 		This method signals all targets to stop, closes the main logger, cancels the nursery,
 		and closes the BiDi connection.
-
-		Args:
-			exc_type (Optional[Type[BaseException]]): The exception type if stopping due to an error.
-			exc_val (Optional[BaseException]): The exception value if stopping due to an error.
-			exc_tb (Optional[TracebackType]): The traceback if stopping due to an error.
 		"""
 		
 		@log_on_error
-		async def _stop_main_logger():
+		async def _stop_main_logger() -> None:
 			"""Stops the main logger and closes its channels."""
 			
 			if self._main_logger_cdp_send_channel is not None:
-				await self._main_logger_cdp_send_channel.aclose()
+				try:
+					await self._main_logger_cdp_send_channel.aclose()
+				except TrioEndExceptions:
+					pass
+			
 				self._main_logger_cdp_send_channel = None
 			
 			if self._main_logger_fingerprint_send_channel is not None:
-				await self._main_logger_fingerprint_send_channel.aclose()
+				try:
+					await self._main_logger_fingerprint_send_channel.aclose()
+				except TrioEndExceptions:
+					pass
+			
 				self._main_logger_fingerprint_send_channel = None
 			
 			if self._main_logger is not None:
-				await self._main_logger.close()
+				try:
+					await self._main_logger.close()
+				except TrioEndExceptions:
+					pass
+			
 				self._main_logger = None
 		
 		@log_on_error
-		async def _stop_all_targets():
+		async def _stop_all_targets() -> None:
 			"""Signals all active targets to stop and waits for their completion."""
 			
 			for target in self._handling_targets.copy().values():
@@ -169,68 +171,75 @@ class LifecycleMixin(TargetsMixin):
 				except (BaseException,):
 					pass
 			
-			self._handling_targets = {}
+			self._handling_targets.clear()
 		
 		@log_on_error
-		async def _close_nursery():
-			"""Asynchronously exits the Trio nursery context manager."""
-			
-			if self._nursery_object is not None:
-				self._nursery_object.cancel_scope.cancel()
-				self._nursery_object = None
+		async def _close_async_stack() -> None:
+			"""
+			Closes the asynchronous resource stack.
+			"""
 			
 			if self._nursery is not None:
-				await self._nursery.__aexit__(exc_type, exc_val, exc_tb)
+				try:
+					self._nursery.cancel_scope.cancel()
+				except TrioEndExceptions:
+					pass
+			
 				self._nursery = None
-		
-		@log_on_error
-		async def _close_bidi_connection():
-			"""Asynchronously exits the BiDi connection context manager."""
 			
 			if self._bidi_connection is not None:
-				await self._bidi_connection.__aexit__(exc_type, exc_val, exc_tb)
 				self._bidi_connection = None
-				self._bidi_connection_object = None
-		
-		if self._is_active:
-			self._is_closing = True
-			self.exit_event.set()
-		
-			await _stop_all_targets()
-			await _stop_main_logger()
-			await _close_nursery()
-			await _close_bidi_connection()
-		
-			self.exit_event = None
-			self._devtools_package = None
-			self._websocket_url = None
-			self._num_cdp_logs = 0
-			self._num_fingerprint_logs = 0
-			self._cdp_targets_types_stats = {}
-			self._cdp_log_level_stats = {}
-			self._fingerprint_categories_stats = {}
-			self._fingerprint_log_level_stats = {}
-			self._is_active = False
-			self._is_closing = False
+			
+			try:
+				await self._exit_stack.aclose()
+			except TrioEndExceptions:
+				pass
+			except AssertionError:
+				pass  # TODO solve exit issue
+		
+		if not self._is_active:
+			return
+		
+		self._is_closing = True
+		self.exit_event.set()
+		
+		await _stop_all_targets()
+		await _stop_main_logger()
+		await _close_async_stack()
+		
+		self.exit_event = None
+		self._devtools_package = None
+		self._websocket_url = None
+		self._num_cdp_logs = 0
+		self._num_fingerprint_logs = 0
+		self._cdp_targets_types_stats.clear()
+		self._cdp_log_level_stats.clear()
+		self._fingerprint_categories_stats.clear()
+		self._fingerprint_log_level_stats.clear()
+		self._is_active = False
+		self._is_closing = False
 	
 	async def __aexit__(
 			self,
 			exc_type: Optional[Type[BaseException]],
 			exc_val: Optional[BaseException],
 			exc_tb: Optional[TracebackType],
-	):
+	) -> bool:
 		"""
 		Asynchronously exits the DevTools event handling context.
 
-		This method is called when exiting an `async with` block with a DevTools instance.
-		It ensures that all event listeners are cancelled, the Trio nursery is closed,
-		and the BiDi connection is properly shut down. Cleanup attempts are made even if
-		an exception occurred within the `async with` block.
-
 		Args:
-			exc_type (Optional[Type[BaseException]]): The exception type, if any, that caused the context to be exited.
+			exc_type (Optional[Type[BaseException]]): The exception type, if any.
 			exc_val (Optional[BaseException]): The exception value, if any.
 			exc_tb (Optional[TracebackType]): The exception traceback, if any.
+
+		Returns:
+			bool: True if an exception was suppressed, False otherwise.
 		"""
 		
-		await self.stop(exc_type=exc_type, exc_val=exc_val, exc_tb=exc_tb)
+		await self.stop()
+		
+		if exc_type is not None and exc_val is not None and exc_tb is not None:
+			return True
+		
+		return False

osn_selenium/dev_tools/manager/logging.py

@@ -1,7 +1,7 @@
 import trio
 from osn_selenium.dev_tools.manager.base import BaseMixin
+from osn_selenium._exception_helpers import log_exception
 from osn_selenium.exceptions.devtools import CDPEndExceptions
-from osn_selenium.dev_tools._exception_helpers import log_exception
 from osn_selenium.dev_tools.logger.models import (
 	CDPLogLevelStats,
 	CDPMainLogEntry,

osn_selenium/dev_tools/manager/targets.py

@@ -1,8 +1,11 @@
 from typing import Any, List, Optional
+
+import trio
+
 from osn_selenium.dev_tools.models import TargetData
 from osn_selenium.dev_tools.target import DevToolsTarget
+from osn_selenium._exception_helpers import log_exception
 from osn_selenium.dev_tools.manager.logging import LoggingMixin
-from osn_selenium.dev_tools._exception_helpers import log_exception
 from osn_selenium.dev_tools.logger.models import CDPTargetTypeStats
 from osn_selenium.exceptions.devtools import (
 	BidiConnectionNotEstablishedError,
@@ -106,7 +109,7 @@ class TargetsMixin(LoggingMixin):
 							websocket_url=self._websocket_url,
 							new_targets_filter_list=self._new_targets_filter,
 							new_targets_buffer_size=self._new_targets_buffer_size,
-							nursery=self._nursery_object,
+							nursery=self._nursery,
 							exit_event=self.exit_event,
 							fingerprint_injection_script=self._fingerprint_injection_script,
 							target_background_task=self._target_background_task,
@@ -123,7 +126,12 @@ class TargetsMixin(LoggingMixin):
 		
 					await self._add_main_cdp_log()
 		
-					self._nursery_object.start_soon(self._handling_targets[target_id].run)
+					if is_main_target:
+						self._nursery.start_soon(self._handling_targets[target_id].run)
+						await self._handling_targets[target_id].started_event.wait()
+						await trio.sleep(1.0)
+					else:
+						self._nursery.start_soon(self._handling_targets[target_id].run)
 		
 					return True
 				else:
@@ -156,7 +164,7 @@ class TargetsMixin(LoggingMixin):
 		"""
 		
 		try:
-			if self._bidi_connection_object is not None:
+			if self._bidi_connection is not None:
 				targets_filter = self._devtools_package.get("target.TargetFilter")(
 						[
 							{"exclude": False, "type": "page"},
@@ -165,7 +173,7 @@ class TargetsMixin(LoggingMixin):
 						]
 				)
 		
-				return await self._bidi_connection_object.session.execute(self._devtools_package.get("target.get_targets")(targets_filter))
+				return await self._bidi_connection.session.execute(self._devtools_package.get("target.get_targets")(targets_filter))
 		
 			raise BidiConnectionNotEstablishedError()
 		except CDPEndExceptions as error:

osn_selenium/dev_tools/settings.py

@@ -64,14 +64,14 @@ class CDPLoggerSettings(DictModel):
 		log_level_filter_mode (Literal["exclude", "include"]): The mode for filtering log levels.
 			"exclude" means log levels in `log_level_filter` will be excluded.
 			"include" means only log levels in `log_level_filter` will be included.
-			Defaults to "exclude".
+			Defaults to "include".
 		log_level_filter (Optional[Union[CDPLogLevelsType, Sequence[CDPLogLevelsType]]]):
 			A single log level or a sequence of log levels to filter by.
 			Used in conjunction with `log_level_filter_mode`. Defaults to None.
 		target_type_filter_mode (Literal["exclude", "include"]): The mode for filtering target types.
 			"exclude" means target types in `target_type_filter` will be excluded.
 			"include" means only target types in `target_type_filter` will be included.
-			Defaults to "exclude".
+			Defaults to "include".
 		target_type_filter (Optional[Union[str, Sequence[str]]]):
 			A single target type string or a sequence of target type strings to filter by.
 			Used in conjunction with `target_type_filter_mode`. Defaults to None.
@@ -79,9 +79,9 @@ class CDPLoggerSettings(DictModel):
 	"""
 	
 	buffer_size: int = 100
-	log_level_filter_mode: Literal["exclude", "include"] = "exclude"
+	log_level_filter_mode: Literal["exclude", "include"] = "include"
 	log_level_filter: Optional[Union[CDP_LOG_LEVELS_TYPEHINT, Sequence[CDP_LOG_LEVELS_TYPEHINT]]] = None
-	target_type_filter_mode: Literal["exclude", "include"] = "exclude"
+	target_type_filter_mode: Literal["exclude", "include"] = "include"
 	target_type_filter: Optional[Union[str, Sequence[str]]] = None
 	send_wait: bool = False
 

osn_selenium/dev_tools/target/base.py

@@ -101,7 +101,7 @@ class BaseMixin:
 		self.websocket_url = websocket_url
 		self._new_targets_filter_list = new_targets_filter_list
 		self._new_targets_buffer_size = new_targets_buffer_size
-		self._nursery_object = nursery
+		self._nursery = nursery
 		self.exit_event = exit_event
 		self._target_background_task = target_background_task
 		self._add_target_func = add_target_func
@@ -112,11 +112,14 @@ class BaseMixin:
 		
 		self._new_targets_events_filters = validate_target_event_filter(filter_=new_targets_filter_list)
 		
-		self._cdp_target_type_log_accepted = validate_type_filter(
-				type_=self.type_,
-				filter_mode=self._logger_settings.cdp_settings.target_type_filter_mode,
-				filter_instances=self._logger_settings.cdp_settings.target_type_filter
-		)
+		if self._logger_settings.cdp_settings is not None:
+			self._cdp_target_type_log_accepted = validate_type_filter(
+					type_=self.type_,
+					filter_mode=self._logger_settings.cdp_settings.target_type_filter_mode,
+					filter_instances=self._logger_settings.cdp_settings.target_type_filter
+			)
+		else:
+			self._cdp_target_type_log_accepted = False
 		
 		self._cdp_log_stats = CDPLoggerChannelStats(
 				target_id=target_data.target_id,
@@ -163,11 +166,15 @@ class BaseMixin:
 			value (Optional[str]): The new target type.
 		"""
 		
-		self._cdp_target_type_log_accepted = validate_type_filter(
-				type_=value,
-				filter_mode=self._logger_settings.cdp_settings.target_type_filter_mode,
-				filter_instances=self._logger_settings.cdp_settings.target_type_filter
-		)
+		if self._logger_settings.cdp_settings is not None:
+			self._cdp_target_type_log_accepted = validate_type_filter(
+					type_=value,
+					filter_mode=self._logger_settings.cdp_settings.target_type_filter_mode,
+					filter_instances=self._logger_settings.cdp_settings.target_type_filter
+			)
+		else:
+			self._cdp_target_type_log_accepted = False
+		
 		self.target_data.type_ = value
 	
 	@property

osn_selenium/dev_tools/target/discovery.py

@@ -65,7 +65,7 @@ class DiscoveryMixin(LoggingMixin):
 							flatten=True
 					)
 		
-					self._nursery_object.start_soon(self._add_target_func, event)
+					self._nursery.start_soon(self._add_target_func, event)
 			except* CDPEndExceptions:
 				keep_alive = False
 			except* BaseException as error:

osn_selenium/dev_tools/target/events.py

@@ -59,7 +59,7 @@ class EventHandlersMixin(LoggingMixin):
 		while keep_alive:
 			try:
 				event = await receiver_channel.receive()
-				self._nursery_object.start_soon(handler, self, event_config, event)
+				self._nursery.start_soon(handler, self, event_config, event)
 			except* CDPEndExceptions:
 				keep_alive = False
 			except* BaseException as error:
@@ -99,7 +99,7 @@ class EventHandlersMixin(LoggingMixin):
 					event_handler_ready_event = trio.Event()
 					events_handlers_ready_events.append(event_handler_ready_event)
 		
-					self._nursery_object.start_soon(
+					self._nursery.start_soon(
 							self._run_event_handler,
 							event_handler_ready_event,
 							getattr(domain_config.handlers, event_name)

osn_selenium/dev_tools/target/fingerprint.py

@@ -118,7 +118,7 @@ class FingerprintMixin(LoggingMixin):
 						run_immediately=True,
 				)
 		
-				self._nursery_object.start_soon(self._run_fingerprint_detect_listener, ready_event)
+				self._nursery.start_soon(self._run_fingerprint_detect_listener, ready_event)
 			except* CDPEndExceptions as error:
 				raise error
 			except* BaseException as error: