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

osn_selenium/_base_models.py

@@ -0,0 +1,41 @@
+from pydantic import (
+	BaseModel,
+	ConfigDict
+)
+
+
+__all__ = ["DictModel", "ExtraDictModel"]
+
+
+class ExtraDictModel(BaseModel):
+	"""
+	Base class for Pydantic models that allows extra fields.
+
+	This configuration allows the model to accept fields that are not
+	explicitly defined in the model's schema.
+	"""
+	
+	model_config = ConfigDict(
+			populate_by_name=True,
+			extra="allow",
+			use_enum_values=True,
+			str_strip_whitespace=True,
+			validate_assignment=True,
+	)
+
+
+class DictModel(BaseModel):
+	"""
+	Base class for Pydantic models with a predefined configuration.
+
+	This configuration enforces strict validation rules such as forbidding extra
+	fields and stripping whitespace from string inputs.
+	"""
+	
+	model_config = ConfigDict(
+			populate_by_name=True,
+			extra="forbid",
+			use_enum_values=True,
+			str_strip_whitespace=True,
+			validate_assignment=True,
+	)

osn_selenium/_cdp_import.py

@@ -0,0 +1,253 @@
+import re
+import sys
+import pathlib
+import importlib.util
+import urllib.request
+from types import ModuleType
+from datetime import datetime, timedelta
+from importlib.abc import MetaPathFinder
+from importlib.machinery import ModuleSpec
+from osn_selenium._typehints import PATH_TYPEHINT
+from typing import (
+	Dict,
+	Mapping,
+	Optional,
+	Sequence,
+	Tuple,
+	Union
+)
+
+
+__all__ = ["check_cdp_version_exists_on_github", "install_cdp_hook"]
+
+_SELENIUM_CDP_PATTERN = re.compile(r"selenium\.webdriver\.common\.devtools\.v(\d+)(.*)")
+_INTERNAL_CDP_PATTERN = re.compile(r"osn_selenium_cdp_v(\d+)(?!\.legacy)(.*)")
+
+_GITHUB_VERSIONS_CACHE: Dict[str, Tuple[bool, datetime]] = {}
+_CDP_PACKAGE_ERROR = None
+
+
+def _build_cdp_package_error(version: int) -> Exception:
+	"""
+	Creates an instance of the CDPPackageError exception.
+
+	Args:
+		version (int): The version of the CDP package.
+
+	Returns:
+		Exception: An instance of the CDPPackageError.
+	"""
+	
+	global _CDP_PACKAGE_ERROR
+	
+	if _CDP_PACKAGE_ERROR is None:
+		from osn_selenium.exceptions.dependencies import CDPPackageError
+		_CDP_PACKAGE_ERROR = CDPPackageError
+	
+	return _CDP_PACKAGE_ERROR(version=version)
+
+
+def _get_external_spec(fullname: str, root_path: pathlib.Path, submodule_part: str) -> Optional[ModuleSpec]:
+	"""
+	Creates a module spec for an external path.
+
+	Args:
+		fullname (str): The full name of the module.
+		root_path (pathlib.Path): The root directory where the module is located.
+		submodule_part (str): The part of the name representing submodules.
+
+	Returns:
+		Optional[ModuleSpec]: The module spec if found, otherwise None.
+	"""
+	
+	if not submodule_part:
+		target_path = root_path / "__init__.py"
+		is_package = True
+	else:
+		rel_path = submodule_part.lstrip(".").replace(".", "/")
+		target_path = root_path / f"{rel_path}.py"
+	
+		if not target_path.exists():
+			target_path = root_path / rel_path / "__init__.py"
+			is_package = True
+		else:
+			is_package = False
+	
+	if target_path.exists():
+		spec = importlib.util.spec_from_file_location(
+				name=fullname,
+				location=str(target_path),
+				submodule_search_locations=[str(root_path)]
+				if is_package
+				else None
+		)
+	
+		return spec
+	
+	return None
+
+
+class _CdpMetaPathFinder(MetaPathFinder):
+	"""
+	A custom meta path finder to redirect Selenium CDP imports.
+	"""
+	
+	def __init__(
+			self,
+			cdp_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+			ignore_package_missing: bool = True
+	) -> None:
+		"""
+		Initializes the finder with user-defined CDP paths.
+
+		Args:
+			cdp_paths (Optional[Mapping[int, PATH_TYPEHINT]]): Mapping of versions to paths.
+			ignore_package_missing (bool): Whether to ignore missing package errors.
+		"""
+		
+		self._user_cdp_paths = {k: pathlib.Path(v).resolve() for k, v in (cdp_paths or {}).items()}
+		
+		self._ignore_package_missing = ignore_package_missing
+	
+	def _find_spec_bypassing_self(self, fullname: str, path: Optional[Sequence[str]]) -> Optional[ModuleSpec]:
+		"""
+		Attempts to find the module specification using other finders in sys.meta_path.
+
+		Args:
+			fullname (str): The full name of the module.
+			path (Optional[Sequence[str]]): The search path for the module.
+
+		Returns:
+			Optional[ModuleSpec]: The module spec if found, otherwise None.
+		"""
+		
+		for finder in sys.meta_path:
+			if finder is self:
+				continue
+		
+			try:
+				if hasattr(finder, "find_spec"):
+					spec = finder.find_spec(fullname, path)
+		
+					if spec:
+						return spec
+			except (Exception,):
+				continue
+		
+		return None
+	
+	def find_spec(
+			self,
+			fullname: str,
+			path: Optional[Sequence[str]],
+			target: Optional[ModuleType] = None,
+	) -> Optional[ModuleSpec]:
+		"""
+		Finds the specification for the requested module if it matches the CDP pattern.
+
+		Args:
+			fullname (str): The full name of the module to find.
+			path (Optional[Sequence[str]]): The search path for the module.
+			target (Optional[ModuleType]): The module object if it is being reloaded.
+
+		Returns:
+			Optional[ModuleSpec]: The module spec if found, otherwise None.
+		"""
+		
+		selenium_match = _SELENIUM_CDP_PATTERN.match(fullname)
+		internal_match = _INTERNAL_CDP_PATTERN.match(fullname)
+		
+		if not (selenium_match or internal_match):
+			return None
+		
+		match = selenium_match or internal_match
+		version_part = int(match.group(1))
+		submodule_part = match.group(2)
+		
+		user_cdp_path = self._user_cdp_paths.get(version_part, None)
+		if user_cdp_path is not None:
+			root = (user_cdp_path / "legacy") if selenium_match else user_cdp_path
+			return _get_external_spec(fullname=fullname, root_path=root, submodule_part=submodule_part)
+		
+		spec = None
+		
+		if selenium_match:
+			target_name = f"osn_selenium_cdp_v{version_part}.legacy{submodule_part}"
+			spec = importlib.util.find_spec(target_name, path)
+		
+		if internal_match:
+			target_name = f"osn_selenium_cdp_v{version_part}{submodule_part}"
+			spec = self._find_spec_bypassing_self(target_name, path)
+		
+		try:
+			if spec:
+				return importlib.util.spec_from_file_location(
+						name=fullname,
+						location=spec.origin,
+						submodule_search_locations=spec.submodule_search_locations,
+				)
+		except ModuleNotFoundError:
+			if self._ignore_package_missing:
+				return None
+		
+			raise _build_cdp_package_error(version=version_part)
+		
+		return None
+
+
+def install_cdp_hook(
+		cdp_paths: Optional[Mapping[int, PATH_TYPEHINT]] = None,
+		ignore_package_missing: bool = True,
+) -> None:
+	"""
+	Installs the CDP meta path finder into sys.meta_path.
+
+	Args:
+		cdp_paths (Optional[Mapping[int, PATH_TYPEHINT]]): Mapping of versions to custom local paths.
+		ignore_package_missing (bool): Whether to ignore missing package errors.
+	"""
+	
+	for finder in sys.meta_path:
+		if isinstance(finder, _CdpMetaPathFinder):
+			finder._user_cdp_paths.update({k: pathlib.Path(v).resolve() for k, v in (cdp_paths or {}).items()})
+			finder._ignore_package_missing = ignore_package_missing
+	
+			return
+	
+	sys.meta_path.insert(
+			0,
+			_CdpMetaPathFinder(cdp_paths=cdp_paths, ignore_package_missing=ignore_package_missing)
+	)
+
+
+def check_cdp_version_exists_on_github(version: Union[int, str]) -> bool:
+	"""
+	Checks if a specific CDP version exists in the remote repository.
+
+	Args:
+		version (Union[int, str]): The version of package.
+
+	Returns:
+		bool: True if the version exists, False otherwise.
+	"""
+	
+	branch_name = version if isinstance(version, str) else f"v{version}"
+	
+	cached_answer = _GITHUB_VERSIONS_CACHE.get(branch_name, None)
+	if cached_answer and datetime.now() - cached_answer[1] < timedelta(hours=12):
+		return cached_answer[0]
+	
+	repo_url = f"https://api.github.com/repos/oddshellnick/osn-selenium-cdp/branches/{branch_name}"
+	
+	try:
+		request = urllib.request.Request(url=repo_url, headers={"User-Agent": "osn-selenium"})
+		request.get_method = lambda: "HEAD"
+	
+		with urllib.request.urlopen(url=request, timeout=5.0) as response:
+			existing = response.status == 200
+			_GITHUB_VERSIONS_CACHE[branch_name] = (existing, datetime.now())
+	
+			return existing
+	except (Exception,):
+		_GITHUB_VERSIONS_CACHE[branch_name] = (False, datetime.now())
+		return False

osn_selenium/abstract/executors/cdp.py

@@ -0,0 +1,63 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+
+__all__ = ["AbstractCDPExecutor"]
+
+if TYPE_CHECKING:
+	from osn_selenium_cdp_v140.executors.abstract import AbstractCDP140Executor
+	from osn_selenium_cdp_v141.executors.abstract import AbstractCDP141Executor
+	from osn_selenium_cdp_v142.executors.abstract import AbstractCDP142Executor
+	from osn_selenium_cdp_v143.executors.abstract import AbstractCDP143Executor
+	from osn_selenium_cdp_v144.executors.abstract import AbstractCDP144Executor
+
+
+class AbstractCDPExecutor(ABC):
+	"""
+	Global abstract interface for accessing different versions of CDP.
+	"""
+
+	@property
+	@abstractmethod
+	def v140(self) -> "AbstractCDP140Executor":
+		"""
+		Access CDP version 140 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v141(self) -> "AbstractCDP141Executor":
+		"""
+		Access CDP version 141 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v142(self) -> "AbstractCDP142Executor":
+		"""
+		Access CDP version 142 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v143(self) -> "AbstractCDP143Executor":
+		"""
+		Access CDP version 143 interface.
+		"""
+
+		...
+
+	@property
+	@abstractmethod
+	def v144(self) -> "AbstractCDP144Executor":
+		"""
+		Access CDP version 144 interface.
+		"""
+
+		...

osn_selenium/browsers_handler/models.py

@@ -1,5 +1,5 @@
 import pathlib
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 
 
 __all__ = ["Browser"]

osn_selenium/dev_tools/_decorators.py

@@ -10,7 +10,8 @@ from typing import (
 	Callable,
 	ParamSpec,
 	TYPE_CHECKING,
-	TypeVar
+	TypeVar,
+	Union
 )
 
 
@@ -19,6 +20,7 @@ __all__ = ["background_task_decorator", "log_on_error", "warn_if_active"]
 if TYPE_CHECKING:
 	from osn_selenium.dev_tools.manager import DevTools
 	from osn_selenium.dev_tools.target.base import BaseMixin
+	from osn_selenium.dev_tools.target import DevToolsTarget
 	from osn_selenium.dev_tools._typehints import DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT
 
 _METHOD_INPUT = ParamSpec("_METHOD_INPUT")
@@ -74,7 +76,7 @@ def warn_if_active(func: _METHOD) -> _METHOD:
 	raise NotExpectedTypeError(expected_type=["coroutine function", "function"], received_instance=func)
 
 
-def log_on_error(func: Callable[_METHOD_INPUT, _METHOD_OUTPUT]) -> Callable[_METHOD_INPUT, _METHOD_OUTPUT]:
+def log_on_error(func: _METHOD) -> _METHOD:
 	"""
 	Decorator that logs any `BaseException` raised by the decorated async function.
 
@@ -115,26 +117,33 @@ def log_on_error(func: Callable[_METHOD_INPUT, _METHOD_OUTPUT]) -> Callable[_MET
 
 def background_task_decorator(func: "DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT") -> "DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT":
 	"""
-	Decorator for BaseTargetMixin background tasks to manage their lifecycle.
+	Decorator for target background tasks to manage their lifecycle.
 
 	This decorator wraps a target's background task function. It ensures that
 	`target.background_task_ended` event is set when the function completes,
 	allowing the `BaseTargetMixin` to track the task's termination.
 
 	Args:
-		func ("devtools_background_func_type"): The asynchronous background task function
-											  to be wrapped. It should accept a `BaseTargetMixin` instance.
+		func ("DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT"): The asynchronous background task function
+		to be wrapped. It should accept a target instance.
 
 	Returns:
-		"devtools_background_func_type": The wrapped function.
+		"DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT": The wrapped function.
 	"""
 	
 	@functools.wraps(func)
-	async def wrapper(target: "BaseMixin") -> Any:
-		target.background_task_ended = trio.Event()
+	async def wrapper(target: Union["BaseMixin", "DevToolsTarget"]) -> Any:
+		if not target.about_to_stop_event.is_set():
+			with trio.CancelScope() as cancel_scope:
+				target.cancel_scopes["background_task"] = cancel_scope
 		
-		await func(target)
+				try:
+					target.background_task_ended = trio.Event()
 		
-		target.background_task_ended.set()
+					await func(target)
+		
+					target.background_task_ended.set()
+				finally:
+					target.cancel_scopes.pop("background_task")
 	
 	return wrapper

osn_selenium/dev_tools/_typehints.py

@@ -3,7 +3,8 @@ from typing import (
 	Callable,
 	Coroutine,
 	Literal,
-	TYPE_CHECKING
+	TYPE_CHECKING,
+	Union
 )
 
 
@@ -15,10 +16,12 @@ __all__ = [
 
 if TYPE_CHECKING:
 	from osn_selenium.dev_tools.target.base import BaseMixin as BaseTargetMixin
+	from osn_selenium.dev_tools.target import DevToolsTarget
 else:
 	BaseTargetMixin = Any
+	DevToolsTarget = Any
 
-DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT = Callable[[BaseTargetMixin], Coroutine[Any, Any, None]]
+DEVTOOLS_BACKGROUND_FUNCTION_TYPEHINT = Callable[[Union[BaseTargetMixin, DevToolsTarget]], Coroutine[Any, Any, None]]
 
 CDP_LOG_LEVELS_TYPEHINT = Literal[
 	"INFO",

osn_selenium/dev_tools/_wrappers.py

@@ -46,9 +46,6 @@ def _yield_package_item_way(name: Union[str, Iterable[str]]) -> Generator[str, A
 class DevToolsPackage:
 	"""
 	Wrapper around the DevTools module to safely retrieve nested attributes/classes.
-
-	Attributes:
-		_package (ModuleType): The root DevTools module package.
 	"""
 	
 	def __init__(self, package: ModuleType):

osn_selenium/dev_tools/domains/__init__.py

@@ -1,4 +1,4 @@
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import ExtraDictModel
 from typing import (
 	Literal,
 	Optional,
@@ -10,7 +10,7 @@ from osn_selenium.dev_tools.domains.fetch import FetchSettings
 __all__ = ["DomainsSettings", "domains_classes_type", "domains_type"]
 
 
-class DomainsSettings(DictModel):
+class DomainsSettings(ExtraDictModel):
 	"""
 	A dataclass container for configuration settings across different DevTools domains.
 

osn_selenium/dev_tools/domains/abstract.py

@@ -1,5 +1,5 @@
 import trio
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 from typing import (
 	Any,
 	Callable,

osn_selenium/dev_tools/domains/fetch.py

@@ -1,6 +1,6 @@
 import trio
 from pydantic import Field
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 from osn_selenium.dev_tools._functions import execute_cdp_command
 from osn_selenium.exceptions.devtools import (
 	CDPEndExceptions,

osn_selenium/dev_tools/domains_default/fetch.py

@@ -1,6 +1,6 @@
 import trio
 from datetime import datetime
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 from osn_selenium.dev_tools._exception_helpers import log_exception
 from typing import (
 	Any,

osn_selenium/dev_tools/filters.py

@@ -1,6 +1,6 @@
 from pydantic import Field
 from typing import List, Optional
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 
 
 __all__ = ["TargetFilter", "TargetsFilters"]

osn_selenium/dev_tools/logger/main.py

@@ -25,18 +25,6 @@ class MainLogger:
 
 	This logger is responsible for writing aggregated statistics about all active
 	logging channels and target types to a designated file.
-
-	Attributes:
-		_nursery_object (trio.Nursery): The Trio nursery for managing concurrent tasks.
-		_cdp_receive_channel (Optional[trio.MemoryReceiveChannel[CDPMainLogEntry]]):
-			The receive channel for CDP main log entries.
-		_fingerprint_receive_channel (Optional[trio.MemoryReceiveChannel[FingerprintMainLogEntry]]):
-			The receive channel for fingerprint main log entries.
-		_cdp_file_writing_stopped (Optional[trio.Event]): An event set when the CDP file writing task stops.
-		_fingerprint_file_writing_stopped (Optional[trio.Event]): An event set when the fingerprint file writing task stops.
-		_is_active (bool): Flag indicating if the main logger is active.
-		_cdp_file_path (Optional[Path]): The path to the CDP main log file.
-		_fingerprint_file_path (Optional[Path]): The path to the fingerprint main log file.
 	"""
 	
 	def __init__(

osn_selenium/dev_tools/logger/models.py

@@ -1,6 +1,6 @@
 from pydantic import Field
 from datetime import datetime
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
 from osn_selenium.dev_tools.models import TargetData
 from typing import (
 	Any,

osn_selenium/dev_tools/logger/target.py

@@ -1,5 +1,10 @@
 import trio
-from typing import Optional, Tuple
+import pathlib
+from typing import (
+	Callable,
+	Optional,
+	Tuple
+)
 from osn_selenium.dev_tools.models import TargetData
 from osn_selenium.dev_tools.settings import LoggerSettings
 from osn_selenium.exceptions.devtools import TrioEndExceptions
@@ -20,15 +25,6 @@ class TargetLogger:
 
 	Each `TargetLogger` instance is responsible for writing log entries
 	related to its associated `TargetData` to a dedicated file.
-
-	Attributes:
-		_target_data (TargetData): The data of the browser target this logger is associated with.
-		_nursery_object (trio.Nursery): The Trio nursery for managing concurrent tasks.
-		_cdp_log_level_filter (Optional[Callable[[Any], bool]]): Filter function for CDP log levels.
-		_cdp_target_type_filter (Optional[Callable[[Any], bool]]): Filter function for CDP target types.
-		_cdp_file_writing_stopped (Optional[trio.Event]): An event set when CDP file writing task stops.
-		_cdp_file_path (Optional[Path]): The path to the target-specific CDP log file.
-		_is_active (bool): Flag indicating if the target logger is active.
 	"""
 	
 	def __init__(
@@ -59,12 +55,12 @@ class TargetLogger:
 		self._nursery_object = nursery_object
 		self._cdp_receive_channel = cdp_receive_channel
 		self._fingerprint_receive_channel = fingerprint_receive_channel
-		self._cdp_file_path = None
-		self._cdp_log_level_filter = None
-		self._cdp_target_type_filter = None
-		self._fingerprint_file_path = None
-		self._fingerprint_log_level_filter = None
-		self._fingerprint_target_type_filter = None
+		self._cdp_file_path: Optional[pathlib.Path] = None
+		self._cdp_log_level_filter: Optional[Callable[[str], bool]] = None
+		self._cdp_target_type_filter: Optional[Callable[[str], bool]] = None
+		self._fingerprint_file_path: Optional[pathlib.Path] = None
+		self._fingerprint_log_level_filter: Optional[Callable[[str], bool]] = None
+		self._fingerprint_target_type_filter: Optional[Callable[[str], bool]] = None
 		
 		if logger_settings.dir_path is None:
 			if logger_settings.cdp_settings:
@@ -106,6 +102,32 @@ class TargetLogger:
 		self._fingerprint_file_writing_stopped: Optional[trio.Event] = None
 		self._is_active = False
 	
+	def filter_cdp_log(self, log_entry: CDPTargetLogEntry) -> bool:
+		"""
+		Applies configured filters to a CDP log entry.
+
+		Args:
+			log_entry (CDPTargetLogEntry): The log entry to check.
+
+		Returns:
+			bool: True if the log entry passes filters, False otherwise.
+		"""
+		
+		return self._cdp_log_level_filter(log_entry.level) and self._cdp_target_type_filter(log_entry.target_data.type_)
+	
+	def filter_fingerprint_log(self, log_entry: FingerprintTargetLogEntry) -> bool:
+		"""
+		Applies configured filters to a fingerprint log entry.
+
+		Args:
+			log_entry (FingerprintTargetLogEntry): The log entry to check.
+
+		Returns:
+			bool: True if the log entry passes filters, False otherwise.
+		"""
+		
+		return self._fingerprint_log_level_filter(log_entry.level) and self._fingerprint_category_filter(log_entry.api)
+	
 	@property
 	def is_active(self) -> bool:
 		"""
@@ -153,9 +175,8 @@ class TargetLogger:
 		
 			async with await trio.open_file(self._fingerprint_file_path, "a+", encoding="utf-8") as file:
 				async for log_entry in self._fingerprint_receive_channel:
-					if self._fingerprint_log_level_filter(log_entry.level) and self._fingerprint_category_filter(log_entry.api):
-						await file.write(log_entry.model_dump_json(indent=4) + end_of_entry)
-						await file.flush()
+					await file.write(log_entry.model_dump_json(indent=4) + end_of_entry)
+					await file.flush()
 		except* TrioEndExceptions:
 			pass
 		except* BaseException as error:
@@ -179,9 +200,8 @@ class TargetLogger:
 		
 			async with await trio.open_file(self._cdp_file_path, "a+", encoding="utf-8") as file:
 				async for log_entry in self._cdp_receive_channel:
-					if self._cdp_log_level_filter(log_entry.level) and self._cdp_target_type_filter(log_entry.target_data.type_):
-						await file.write(log_entry.model_dump_json(indent=4) + end_of_entry)
-						await file.flush()
+					await file.write(log_entry.model_dump_json(indent=4) + end_of_entry)
+					await file.flush()
 		except* TrioEndExceptions:
 			pass
 		except* BaseException as error:

osn_selenium/dev_tools/manager/base.py

@@ -41,31 +41,8 @@ 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__(