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

osn_selenium/abstract/webdriver/core/lifecycle.py

@@ -16,14 +16,6 @@ __all__ = ["AbstractCoreLifecycleMixin"]
 class AbstractCoreLifecycleMixin(ABC):
 	"""Mixin responsible for driver lifecycle, creation, session, and connection management."""
 	
-	@abstractmethod
-	def close_webdriver(self) -> None:
-		"""
-		Closes the WebDriver instance and all associated windows.
-		"""
-		
-		...
-	
 	@abstractmethod
 	def quit(self) -> None:
 		"""
@@ -101,3 +93,11 @@ class AbstractCoreLifecycleMixin(ABC):
 		"""
 		
 		...
+	
+	@abstractmethod
+	def stop_webdriver(self) -> None:
+		"""
+		Stops the WebDriver instance and all associated windows.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/script.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from typing import Any, List, Optional
+from selenium.webdriver.remote.script_key import ScriptKey
 from osn_selenium.abstract.instances.script import AbstractScript
 
 
@@ -51,7 +52,7 @@ class AbstractCoreScriptMixin(ABC):
 		...
 	
 	@abstractmethod
-	def pin_script(self, script: str, script_key: Optional[Any] = None) -> Any:
+	def pin_script(self, script: str, script_key: Optional[Any] = None) -> ScriptKey:
 		"""
 		Pins a script to the browser for faster execution.
 
@@ -60,7 +61,7 @@ class AbstractCoreScriptMixin(ABC):
 			script_key (Optional[Any]): An optional key to identify the script.
 
 		Returns:
-			Any: The key associated with the pinned script.
+			ScriptKey: The key associated with the pinned script.
 		"""
 		
 		...
@@ -77,12 +78,12 @@ class AbstractCoreScriptMixin(ABC):
 		...
 	
 	@abstractmethod
-	def unpin(self, script_key: Any) -> None:
+	def unpin(self, script_key: ScriptKey) -> None:
 		"""
 		Unpins a previously pinned script.
 
 		Args:
-			script_key (Any): The key of the script to unpin.
+			script_key (ScriptKey): The key of the script to unpin.
 		"""
 		
 		...

osn_selenium/abstract/webdriver/core/window.py

@@ -66,6 +66,17 @@ class AbstractCoreWindowMixin(ABC):
 		
 		...
 	
+	@abstractmethod
+	def get_orientation(self) -> Literal["LANDSCAPE", "PORTRAIT"]:
+		"""
+		Gets the current orientation of the browser.
+
+		Returns:
+			Literal["LANDSCAPE", "PORTRAIT"]: The current orientation.
+		"""
+		
+		...
+	
 	@abstractmethod
 	def get_window_handle(self, window: Optional[Union[str, int]] = None) -> str:
 		"""
@@ -140,17 +151,6 @@ class AbstractCoreWindowMixin(ABC):
 		
 		...
 	
-	@abstractmethod
-	def orientation(self) -> Literal["LANDSCAPE", "PORTRAIT"]:
-		"""
-		Gets the current orientation of the browser.
-
-		Returns:
-			Literal["LANDSCAPE", "PORTRAIT"]: The current orientation.
-		"""
-		
-		...
-	
 	@abstractmethod
 	def set_orientation(self, value: Literal["LANDSCAPE", "PORTRAIT"]) -> None:
 		"""

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

@@ -2,23 +2,23 @@ import trio
 import inspect
 import warnings
 import functools
-from osn_selenium.exceptions.devtools import ExceptionThrown
 from osn_selenium.exceptions.instance import NotExpectedTypeError
-from osn_selenium.dev_tools._exception_helpers import log_exception
 from typing import (
 	Any,
 	Callable,
 	ParamSpec,
 	TYPE_CHECKING,
-	TypeVar
+	TypeVar,
+	Union
 )
 
 
-__all__ = ["background_task_decorator", "log_on_error", "warn_if_active"]
+__all__ = ["background_task_decorator", "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,67 +74,35 @@ 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]:
-	"""
-	Decorator that logs any `BaseException` raised by the decorated async function.
-
-	If an exception occurs, it is logged using `log_exception`, and an `ExceptionThrown`
-	object wrapping the exception is returned instead of re-raising it.
-
-	Args:
-		func (_METHOD): The asynchronous function to be wrapped.
-
-	Returns:
-		_METHOD: The wrapped asynchronous function.
-	"""
-	
-	@functools.wraps(func)
-	def sync_wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
-		try:
-			return func(*args, **kwargs)
-		except BaseException as exception:
-			log_exception(exception)
-			return ExceptionThrown(exception)
-	
-	@functools.wraps(func)
-	async def async_wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
-		try:
-			return await func(*args, **kwargs)
-		except BaseException as exception:
-			log_exception(exception)
-			return ExceptionThrown(exception)
-	
-	if inspect.iscoroutinefunction(func):
-		return async_wrapper
-	
-	if inspect.isfunction(func):
-		return sync_wrapper
-	
-	raise NotExpectedTypeError(expected_type=["coroutine function", "function"], received_instance=func)
-
-
 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
+		
+				try:
+					target.background_task_ended = trio.Event()
 		
-		await func(target)
+					await func(target)
 		
-		target.background_task_ended.set()
+					target.background_task_ended.set()
+				finally:
+					target.cancel_scopes.pop("background_task")
 	
 	return wrapper

osn_selenium/dev_tools/_functions.py

@@ -1,5 +1,7 @@
 import trio
 import random
+from osn_selenium.exceptions.base import ExceptionThrown
+from osn_selenium.exceptions.devtools import CDPEndExceptions
 from typing import (
 	Any,
 	Callable,
@@ -10,10 +12,6 @@ from typing import (
 from osn_selenium.exceptions.configuration import (
 	NotExpectedValueError
 )
-from osn_selenium.exceptions.devtools import (
-	CDPEndExceptions,
-	ExceptionThrown
-)
 
 
 __all__ = ["cdp_command_error", "execute_cdp_command", "wait_one"]

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,16 +1,16 @@
-from osn_selenium.models import DictModel
 from typing import (
 	Literal,
 	Optional,
 	Union
 )
+from osn_selenium._base_models import ExtraDictModel
 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,11 +1,9 @@
 import trio
 from pydantic import Field
-from osn_selenium.models import DictModel
+from osn_selenium._base_models import DictModel
+from osn_selenium.exceptions.base import ExceptionThrown
+from osn_selenium.exceptions.devtools import CDPEndExceptions
 from osn_selenium.dev_tools._functions import execute_cdp_command
-from osn_selenium.exceptions.devtools import (
-	CDPEndExceptions,
-	ExceptionThrown
-)
 from typing import (
 	Any,
 	Callable,
@@ -134,7 +132,7 @@ async def _build_kwargs_from_handlers_func(self: DevToolsTarget, handlers: DictM
 				kwargs_ready_event = trio.Event()
 				kwargs_ready_events.append(kwargs_ready_event)
 	
-				self._nursery_object.start_soon(
+				self._nursery.start_soon(
 						handler_settings.func,
 						self,
 						kwargs_ready_event,
@@ -243,7 +241,7 @@ async def _handle_auth_required(
 				)
 	
 				if response_handle_func is not None:
-					self._nursery_object.start_soon(response_handle_func, self, response)
+					self._nursery.start_soon(response_handle_func, self, response)
 			except* CDPEndExceptions:
 				pass
 			except* BaseException as error:
@@ -505,7 +503,7 @@ async def _handle_request_paused(
 				)
 	
 				if response_handle_func is not None:
-					self._nursery_object.start_soon(response_handle_func, self, response)
+					self._nursery.start_soon(response_handle_func, self, response)
 			except* CDPEndExceptions:
 				pass
 			except* BaseException as error:

osn_selenium/dev_tools/domains_default/fetch.py

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

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

@@ -4,8 +4,8 @@ from typing import (
 	TYPE_CHECKING,
 	Tuple
 )
+from osn_selenium._exception_helpers import log_exception
 from osn_selenium.exceptions.devtools import TrioEndExceptions
-from osn_selenium.dev_tools._exception_helpers import log_exception
 from osn_selenium.exceptions.configuration import ConfigurationError
 from osn_selenium.dev_tools.logger.models import (
 	CDPMainLogEntry,
@@ -25,24 +25,12 @@ 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__(
 			self,
 			logger_settings: "LoggerSettings",
-			nursery_object: trio.Nursery,
+			nursery: trio.Nursery,
 			cdp_receive_channel: Optional[trio.MemoryReceiveChannel[CDPMainLogEntry]],
 			fingerprint_receive_channel: Optional[trio.MemoryReceiveChannel[FingerprintMainLogEntry]]
 	):
@@ -51,7 +39,7 @@ class MainLogger:
 
 		Args:
 			logger_settings ("LoggerSettings"): The settings for logging, including log directory.
-			nursery_object (trio.Nursery): The Trio nursery to spawn background tasks.
+			nursery (trio.Nursery): The Trio nursery to spawn background tasks.
 			cdp_receive_channel (Optional[trio.MemoryReceiveChannel[CDPMainLogEntry]]):
 				The channel from which CDP main log entries are received.
 			fingerprint_receive_channel (Optional[trio.MemoryReceiveChannel[FingerprintMainLogEntry]]):
@@ -61,7 +49,7 @@ class MainLogger:
 			ValueError: If settings require logging but `dir_path` is not set.
 		"""
 		
-		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 = None
@@ -174,12 +162,12 @@ class MainLogger:
 				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:
@@ -189,7 +177,7 @@ class MainLogger:
 			await self.close()
 
 
-def build_main_logger(nursery_object: trio.Nursery, logger_settings: "LoggerSettings") -> Tuple[
+def build_main_logger(nursery: trio.Nursery, logger_settings: "LoggerSettings") -> Tuple[
 	Optional[trio.MemorySendChannel[CDPMainLogEntry]],
 	Optional[trio.MemorySendChannel[FingerprintMainLogEntry]],
 	MainLogger
@@ -198,7 +186,7 @@ def build_main_logger(nursery_object: trio.Nursery, logger_settings: "LoggerSett
 	Builds and initializes a `MainLogger` instance along with its send channels.
 
 	Args:
-		nursery_object (trio.Nursery): The Trio nursery to associate with the logger for background tasks.
+		nursery (trio.Nursery): The Trio nursery to associate with the logger for background tasks.
 		logger_settings ("LoggerSettings"): The logger configuration settings.
 
 	Returns:
@@ -218,7 +206,7 @@ def build_main_logger(nursery_object: trio.Nursery, logger_settings: "LoggerSett
 	
 	target_logger = MainLogger(
 			logger_settings=logger_settings,
-			nursery_object=nursery_object,
+			nursery=nursery,
 			cdp_receive_channel=cdp_recv,
 			fingerprint_receive_channel=fp_recv,
 	)

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,10 +1,15 @@
 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._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
@@ -20,21 +25,12 @@ 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__(
 			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]],
@@ -44,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.
@@ -56,15 +52,15 @@ 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 = 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:
@@ -200,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:
@@ -249,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,