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

osn_selenium/_decorators.py

@@ -0,0 +1,57 @@
+import inspect
+import functools
+from osn_selenium.exceptions.base import ExceptionThrown
+from osn_selenium._exception_helpers import log_exception
+from typing import (
+	Any,
+	Callable,
+	ParamSpec,
+	TypeVar
+)
+from osn_selenium.exceptions.instance import NotExpectedTypeError
+
+
+__all__ = ["log_on_error"]
+
+_METHOD_INPUT = ParamSpec("_METHOD_INPUT")
+_METHOD_OUTPUT = TypeVar("_METHOD_OUTPUT")
+_METHOD = TypeVar("_METHOD", bound=Callable[..., Any])
+
+
+def log_on_error(func: _METHOD) -> _METHOD:
+	"""
+	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)

osn_selenium/_trio_threads_helpers.py

@@ -0,0 +1,157 @@
+import sys
+import trio
+import contextvars
+from contextlib import asynccontextmanager
+from typing import (
+	Any,
+	AsyncContextManager,
+	AsyncIterator,
+	Callable,
+	ContextManager,
+	Coroutine,
+	ParamSpec,
+	Tuple,
+	TypeVar
+)
+
+
+__all__ = ["sync_to_trio", "sync_to_trio_context"]
+
+_METHOD_INPUT = ParamSpec("_METHOD_INPUT")
+_METHOD_OUTPUT = TypeVar("_METHOD_OUTPUT")
+
+
+def sync_to_trio_context(
+		context_manager_factory: Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]],
+		lock_object: trio.Lock,
+		capacity_limiter_object: trio.CapacityLimiter,
+		lock: bool,
+		exchange_context: bool,
+) -> Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]:
+	"""
+	Converts a synchronous context manager factory to an asynchronous Trio-compatible context manager.
+
+	Args:
+		context_manager_factory (Callable[_METHOD_INPUT, ContextManager[_METHOD_OUTPUT]]): Factory function returning a context manager.
+		lock_object (trio.Lock): Trio lock for synchronization.
+		capacity_limiter_object (trio.CapacityLimiter): Trio capacity limiter.
+		lock (bool): Whether to use the internal lock for synchronization.
+		exchange_context (bool): Whether to synchronize context variables between threads.
+
+	Returns:
+		Callable[_METHOD_INPUT, AsyncContextManager[_METHOD_OUTPUT]]: An async function returning an async context manager.
+	"""
+	
+	@asynccontextmanager
+	async def wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> AsyncIterator[_METHOD_OUTPUT]:
+		"""
+		Internal async context manager wrapper.
+
+		Args:
+			*args (_METHOD_INPUT.args): Positional arguments for the factory.
+			**kwargs (_METHOD_INPUT.kwargs): Keyword arguments for the factory.
+
+		Returns:
+			AsyncIterator[_METHOD_OUTPUT]: An async iterator yielding the context resource.
+		"""
+		
+		sync_context_manager = await sync_to_trio(
+				sync_function=context_manager_factory,
+				lock_object=lock_object,
+				capacity_limiter_object=capacity_limiter_object,
+				lock=lock,
+				exchange_context=exchange_context,
+		)(*args, **kwargs)
+		
+		enter_ = sync_to_trio(
+				sync_function=sync_context_manager.__enter__,
+				lock_object=lock_object,
+				capacity_limiter_object=capacity_limiter_object,
+				lock=lock,
+				exchange_context=exchange_context,
+		)
+		exit_ = sync_to_trio(
+				sync_function=sync_context_manager.__exit__,
+				lock_object=lock_object,
+				capacity_limiter_object=capacity_limiter_object,
+				lock=lock,
+				exchange_context=exchange_context,
+		)
+		
+		try:
+			result = await enter_()
+		
+			yield result
+		except Exception as e:
+			exc_type, exc_val, exc_tb = sys.exc_info()
+		
+			if not await exit_(exc_type, exc_val, exc_tb):
+				raise e
+		else:
+			await exit_(None, None, None)
+	
+	return wrapper
+
+
+def sync_to_trio(
+		sync_function: Callable[_METHOD_INPUT, _METHOD_OUTPUT],
+		lock_object: trio.Lock,
+		capacity_limiter_object: trio.CapacityLimiter,
+		lock: bool,
+		exchange_context: bool,
+) -> Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]:
+	"""
+	Wraps a synchronous function to run within a Trio thread pool using a lock and limiter.
+
+	Args:
+		sync_function (Callable[_METHOD_INPUT, _METHOD_OUTPUT]): The synchronous function to wrap.
+		lock_object (trio.Lock): Trio lock for synchronization.
+		capacity_limiter_object (trio.CapacityLimiter): Trio capacity limiter.
+		lock (bool): Whether to use the provided lock.
+		exchange_context (bool): Whether to synchronize context variables between threads.
+
+	Returns:
+		Callable[_METHOD_INPUT, Coroutine[Any, Any, _METHOD_OUTPUT]]: An async wrapper for the sync function.
+	"""
+	
+	async def wrapper(*args: _METHOD_INPUT.args, **kwargs: _METHOD_INPUT.kwargs) -> _METHOD_OUTPUT:
+		"""
+	Internal async wrapper for the synchronous function.
+
+	Args:
+		*args (_METHOD_INPUT.args): Positional arguments for the sync function.
+		**kwargs (_METHOD_INPUT.kwargs): Keyword arguments for the sync function.
+
+	Returns:
+		_METHOD_OUTPUT: The result of the synchronous function execution.
+	"""
+		
+		def function_with_kwargs(*args_) -> Tuple[_METHOD_OUTPUT, contextvars.Context]:
+			"""
+		Helper to pass keyword arguments to trio.to_thread.run_sync.
+
+		Args:
+			*args_: Positional arguments passed from the outer scope.
+
+		Returns:
+			Tuple[_METHOD_OUTPUT, contextvars.Context]: Result of original sync function and the thread context.
+		"""
+			
+			sync_result = sync_function(*args_, **kwargs)
+			context_vars = contextvars.copy_context()
+			
+			return sync_result, context_vars
+		
+		if lock:
+			async with lock_object:
+				result, child_context_vars = await trio.to_thread.run_sync(function_with_kwargs, *args, limiter=capacity_limiter_object)
+		else:
+			result, child_context_vars = await trio.to_thread.run_sync(function_with_kwargs, *args, limiter=capacity_limiter_object)
+		
+		if exchange_context:
+			for var, value in child_context_vars.items():
+				var.set(value)
+		
+		return result
+	
+	return wrapper

osn_selenium/_typehints.py

@@ -14,6 +14,6 @@ __all__ = [
 ]
 
 DEVICES_TYPEHINT = Union[PointerInput, KeyInput, WheelInput]
-ARCHITECTURES_TYPEHINT = Literal["sync", "trio_threads"]
+ARCHITECTURES_TYPEHINT = Literal["sync", "trio_threads", "trio_bidi"]
 PATH_TYPEHINT = Union[str, bytes, pathlib.Path, os.PathLike]
 TYPES_FOR_FLATTENING_TYPEHINT = Union[str, Type]

osn_selenium/abstract/webdriver/blink/base.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from selenium import webdriver
 from typing import Optional, Union
 from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.abstract.executors.cdp import AbstractCDPExecutor
 from osn_selenium.abstract.webdriver.core.base import (
 	AbstractCoreBaseMixin
 )
@@ -31,6 +32,19 @@ class AbstractBlinkBaseMixin(AbstractCoreBaseMixin):
 		
 		...
 	
+	@property
+	@abstractmethod
+	def cdp(self) -> AbstractCDPExecutor:
+		"""
+		Returns the CDP (Chrome DevTools Protocol) executor.
+
+		Returns:
+			AbstractCDPExecutor: The CDP executor instance used for sending
+			commands directly to the browser via the DevTools protocol.
+		"""
+		
+		...
+	
 	@property
 	@abstractmethod
 	def debugging_ip(self) -> Optional[str]:

osn_selenium/abstract/webdriver/blink/lifecycle.py

@@ -19,14 +19,6 @@ class AbstractBlinkLifecycleMixin(AbstractCoreLifecycleMixin):
 	and the associated browser process.
 	"""
 	
-	@abstractmethod
-	async def close_webdriver(self) -> None:
-		"""
-		Closes the WebDriver connection and terminates the browser process.
-		"""
-		
-		...
-	
 	@abstractmethod
 	async def restart_webdriver(
 			self,
@@ -74,3 +66,11 @@ class AbstractBlinkLifecycleMixin(AbstractCoreLifecycleMixin):
 		"""
 		
 		...
+	
+	@abstractmethod
+	async def stop_webdriver(self) -> None:
+		"""
+		Stops the WebDriver connection and terminates the browser process.
+		"""
+		
+		...

osn_selenium/abstract/webdriver/core/base.py

@@ -11,7 +11,6 @@ from osn_selenium._typehints import (
 	ARCHITECTURES_TYPEHINT
 )
 from selenium.webdriver.remote.errorhandler import ErrorHandler
-from osn_selenium.abstract.executors.cdp import AbstractCDPExecutor
 from selenium.webdriver.remote.locator_converter import LocatorConverter
 from selenium.webdriver.remote.remote_connection import RemoteConnection
 from osn_selenium.abstract.executors.javascript import AbstractJSExecutor
@@ -90,19 +89,6 @@ class AbstractCoreBaseMixin(ABC):
 		
 		...
 	
-	@property
-	@abstractmethod
-	def cdp(self) -> AbstractCDPExecutor:
-		"""
-		Returns the CDP (Chrome DevTools Protocol) executor.
-
-		Returns:
-			AbstractCDPExecutor: The CDP executor instance used for sending
-			commands directly to the browser via the DevTools protocol.
-		"""
-		
-		...
-	
 	@property
 	@abstractmethod
 	def command_executor(self) -> RemoteConnection:

osn_selenium/abstract/webdriver/core/capture.py

@@ -1,5 +1,6 @@
-from typing import Any, Optional
+from typing import Optional
 from abc import ABC, abstractmethod
+from selenium.webdriver.common.print_page_options import PrintOptions
 
 
 __all__ = ["AbstractCoreCaptureMixin"]
@@ -56,12 +57,12 @@ class AbstractCoreCaptureMixin(ABC):
 		...
 	
 	@abstractmethod
-	def print_page(self, print_options: Optional[Any] = None) -> str:
+	def print_page(self, print_options: Optional[PrintOptions] = None) -> str:
 		"""
 		Prints the current page to a PDF.
 
 		Args:
-			print_options (Optional[Any]): Options for printing the page.
+			print_options (Optional[PrintOptions]): Options for printing the page.
 
 		Returns:
 			str: A base64-encoded string of the PDF.

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/dev_tools/_decorators.py

@@ -2,9 +2,7 @@ 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,
@@ -15,7 +13,7 @@ from typing import (
 )
 
 
-__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
@@ -76,45 +74,6 @@ def warn_if_active(func: _METHOD) -> _METHOD:
 	raise NotExpectedTypeError(expected_type=["coroutine function", "function"], received_instance=func)
 
 
-def log_on_error(func: _METHOD) -> _METHOD:
-	"""
-	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 target background tasks to manage their lifecycle.

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/domains/__init__.py

@@ -1,9 +1,9 @@
-from osn_selenium._base_models import ExtraDictModel
 from typing import (
 	Literal,
 	Optional,
 	Union
 )
+from osn_selenium._base_models import ExtraDictModel
 from osn_selenium.dev_tools.domains.fetch import FetchSettings
 
 

osn_selenium/dev_tools/domains/fetch.py

@@ -1,11 +1,9 @@
 import trio
 from pydantic import Field
 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._base_models import DictModel
-from osn_selenium.dev_tools._exception_helpers import log_exception
+from osn_selenium._exception_helpers import log_exception
 from typing import (
 	Any,
 	Dict,

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,
@@ -30,7 +30,7 @@ class MainLogger:
 	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]]
 	):
@@ -39,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]]):
@@ -49,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
@@ -162,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:
@@ -177,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
@@ -186,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:
@@ -206,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,
 	)