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

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:
 	"""
@@ -41,43 +33,20 @@ class BaseMixin:
 	by using an asynchronous context manager.
 
 	Attributes:
-		_webdriver (CoreWebDriver): The parent WebDriver instance associated with this DevTools instance.
-		_new_targets_filter (Optional[List[Dict[str, Any]]]): Processed filters for new targets.
-		_new_targets_buffer_size (int): Buffer size for new target events.
-		_target_background_task (Optional[devtools_background_func_type]): Optional background task for targets.
-		_logger_settings (LoggerSettings): Logging configuration for the entire DevTools manager.
-		_bidi_connection (Optional[AbstractAsyncContextManager[BidiConnection, Any]]): Asynchronous context manager for the BiDi connection.
-		_bidi_connection_object (Optional[BidiConnection]): The BiDi connection object when active.
-		_nursery (Optional[AbstractAsyncContextManager[trio.Nursery, object]]): Asynchronous context manager for the Trio nursery.
-		_nursery_object (Optional[trio.Nursery]): The Trio nursery object when active, managing concurrent tasks.
-		_domains_settings (DomainsSettings): Settings for configuring DevTools domain handlers.
-		_handling_targets (Dict[str, DevToolsTarget]): Dictionary of target IDs currently being handled by event listeners.
 		targets_lock (trio.Lock): A lock used for synchronizing access to shared resources, like the List of handled targets.
 		exit_event (Optional[trio.Event]): Trio Event to signal exiting of DevTools event handling.
-		_is_active (bool): Flag indicating if the DevTools event handler is currently active.
-		_is_closing (bool): Flag indicating if the DevTools manager is in the process of closing.
-		_num_cdp_logs (int): Total count of all CDP log entries across all targets.
-		_num_fingerprint_logs (int): Total count of all Fingerprint log entries across all targets.
-		_cdp_targets_types_stats (Dict[str, CDPTargetTypeStats]): Statistics for each target type.
-		_cdp_log_level_stats (Dict[str, CDPLogLevelStats]): Overall statistics for each log level.
-		_main_logger_cdp_send_channel (Optional[trio.MemorySendChannel[CDPMainLogEntry]]): Send channel for the main logger.
-		_fingerprint_categories_stats (Dict[str, FingerprintAPIStats]): Statistics for each API category.
-		_fingerprint_log_level_stats (Dict[str, FingerprintLogLevelStats]): Overall statistics for each log level.
-		_main_logger_fingerprint_send_channel (Optional[trio.MemorySendChannel[FingerprintMainLogEntry]]): Send channel for the main logger.
-		_main_logger (Optional[MainLogger]): The main logger instance.
-		_fingerprint_injection_script (Optional[str]): Injection script for fingerprinting.
 	"""
 	
 	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.
 		"""
@@ -97,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,115 +122,124 @@ 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():
 				try:
 					await target.stop()
 					await target.stopped_event.wait()
-				except (BaseException):
+				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/models.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 
 
 __all__ = ["FingerprintData", "TargetData"]

osn_selenium/dev_tools/settings.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 from pydantic import Field
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 from osn_selenium.dev_tools.filters import TargetFilter
 from osn_selenium.dev_tools.domains import DomainsSettings
 from typing import (
@@ -39,6 +39,7 @@ class FingerprintLoggerSettings(DictModel):
 			Defaults to "exclude".
 		category_filter (Optional[Union[str, Sequence[str]]]): Specific categories to filter.
 			Defaults to None.
+		send_wait (bool): Whether to wait for the log to be sent. Defaults to False.
 	"""
 	
 	buffer_size: int = 100
@@ -51,6 +52,7 @@ class FingerprintLoggerSettings(DictModel):
 	] = None
 	category_filter_mode: Literal["exclude", "include"] = "exclude"
 	category_filter: Optional[Union[str, Sequence[str]]] = None
+	send_wait: bool = False
 
 
 class CDPLoggerSettings(DictModel):
@@ -62,24 +64,26 @@ 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.
+		send_wait (bool): Whether to wait for the log to be sent. Defaults to False.
 	"""
 	
 	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
 
 
 class LoggerSettings(DictModel):

osn_selenium/dev_tools/target/base.py

@@ -50,29 +50,6 @@ class BaseMixin:
 		about_to_stop_event (trio.Event): Event set when the target is about to stop.
 		stopped_event (trio.Event): Event set when the target handling has fully stopped.
 		background_task_ended (Optional[trio.Event]): Event set when the background task completes.
-		_is_main_target (bool): Whether this is the primary target.
-		_logger_settings ("LoggerSettings"): Configuration for logging.
-		_domains_settings (Optional["DomainsSettings"]): Configuration for enabled domains and handlers.
-		_new_targets_filter_list (Sequence[Mapping[str, Any]]): Filters for discovering new targets.
-		_new_targets_buffer_size (int): Buffer size for new target events.
-		_nursery_object (trio.Nursery): Trio nursery for background tasks.
-		_target_background_task (Optional[devtools_background_func_type]): Optional background task to run.
-		_add_target_func (Callable): Callback to add a new target.
-		_remove_target_func (Callable): Callback to remove this target.
-		_add_cdp_log_func (Callable): Callback to record a CDP log entry.
-		_add_fingerprint_log_func (Callable): Callback to record a fingerprint log entry.
-		_fingerprint_injection_script (Optional[str]): JS script to inject into the target.
-		_new_targets_events_filters (Any): Validated filters for target events.
-		_cdp_target_type_log_accepted (bool): Whether CDP logging is enabled for this target type.
-		_cdp_log_stats (CDPLoggerChannelStats): Statistics for CDP logs.
-		_fingerprint_log_stats (FingerprintLoggerChannelStats): Statistics for fingerprint logs.
-		_logger_cdp_send_channel (Optional[trio.MemorySendChannel]): Channel to send CDP logs to the logger.
-		_logger_fingerprint_send_channel (Optional[trio.MemorySendChannel]): Channel to send fingerprint logs.
-		_logger (Optional[TargetLogger]): The logger instance for this target.
-		_cdp_session (Optional[CdpSession]): The active CDP session.
-		_new_target_receive_channel (Optional[Tuple[trio.MemoryReceiveChannel, trio.Event]]): Channel for new target events.
-		_detached_receive_channel (Optional[trio.MemoryReceiveChannel]): Channel for detach events.
-		_events_receive_channels (Dict[str, Tuple[trio.MemoryReceiveChannel, trio.Event]]): Channels for domain events.
 	"""
 	
 	def __init__(
@@ -124,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
@@ -135,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,
@@ -164,6 +144,7 @@ class BaseMixin:
 		self._new_target_receive_channel: Optional[Tuple[trio.MemoryReceiveChannel, trio.Event]] = None
 		self._detached_receive_channel: Optional[trio.MemoryReceiveChannel] = None
 		self._events_receive_channels: Dict[str, Tuple[trio.MemoryReceiveChannel, trio.Event]] = {}
+		self._cancel_scopes: Dict[str, trio.CancelScope] = {}
 	
 	@property
 	def type_(self) -> Optional[str]:
@@ -185,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
@@ -258,6 +243,17 @@ class BaseMixin:
 		
 		self.target_data.can_access_opener = value
 	
+	@property
+	def cancel_scopes(self) -> Dict[str, trio.CancelScope]:
+		"""
+		Provides access to the dictionary of cancellation scopes.
+
+		Returns:
+			Dict[str, trio.CancelScope]: The cancel scopes dictionary.
+		"""
+		
+		return self._cancel_scopes
+	
 	@property
 	def cdp_log_stats(self) -> CDPLoggerChannelStats:
 		"""

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: