ez-a-sync 0.22.14__py3-none-any.whl → 0.22.16__py3-none-any.whl

a_sync/iter.py

@@ -1,4 +1,3 @@
-
 import asyncio
 import functools
 import inspect
@@ -22,6 +21,7 @@ else:
     SortKey = SyncFn[[T], bool]
     ViewFn = AnyFn[[T], bool]
 
+
 class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
     """
     A mixin class defining logic for making an AsyncIterable awaitable.
@@ -30,24 +30,23 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
 
     Example:
         You must subclass this mixin class and define your own `__aiter__` method as shown below.
-        ```
+
         >>> class MyAwaitableAIterable(_AwaitableAsyncIterableMixin):
-        ...    def __aiter__(self):
+        ...    async def __aiter__(self):
         ...        for i in range(4):
         ...            yield i
-        ... 
+
         >>> aiterable = MyAwaitableAIterable()
         >>> await aiterable
-        [0, 1, 2, 3, 4]
-
-        ```
+        [0, 1, 2, 3]
     """
+
     __wrapped__: AsyncIterable[T]
-    
+
     def __await__(self) -> Generator[Any, Any, List[T]]:
         """
         Asynchronously iterate through the {cls} and return all objects.
-        
+
         Returns:
             A list of the objects yielded by the {cls}.
         """
@@ -57,13 +56,15 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
     def materialized(self) -> List[T]:
         """
         Synchronously iterate through the {cls} and return all objects.
-        
+
         Returns:
             A list of the objects yielded by the {cls}.
         """
         return _helpers._await(self._materialized)
 
-    def sort(self, *, key: SortKey[T] = None, reverse: bool = False) -> "ASyncSorter[T]":
+    def sort(
+        self, *, key: SortKey[T] = None, reverse: bool = False
+    ) -> "ASyncSorter[T]":
         """
         Sort the contents of the {cls}.
 
@@ -92,7 +93,7 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
     async def _materialized(self) -> List[T]:
         """
         Asynchronously iterate through the {cls} and return all objects.
-        
+
         Returns:
             A list of the objects yielded by the {cls}.
         """
@@ -106,7 +107,7 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
             cls.__doc__ = new
         else:
             cls.__doc__ += f"\n\n{new}"
-    
+
         # format the member docstrings
         for attr_name in dir(cls):
             attr = getattr(cls, attr_name, None)
@@ -115,27 +116,52 @@ class _AwaitableAsyncIterableMixin(AsyncIterable[T]):
 
         return super().__init_subclass__(**kwargs)
 
-    __slots__ = '__async_property__', 
-    
+    __slots__ = ("__async_property__",)
+
+
 class ASyncIterable(_AwaitableAsyncIterableMixin[T], Iterable[T]):
     """
     A hybrid Iterable/AsyncIterable implementation designed to offer dual compatibility with both synchronous and asynchronous iteration protocols.
-    
+
     This class allows objects to be iterated over using either a standard `for` loop or an `async for` loop, making it versatile in scenarios where the mode of iteration (synchronous or asynchronous) needs to be flexible or is determined at runtime.
 
-    The class achieves this by implementing both `__iter__` and `__aiter__` methods, enabling it to return appropriate iterator objects that can handle synchronous and asynchronous iteration, respectively. This dual functionality is particularly useful in codebases that are transitioning between synchronous and asynchronous code, or in libraries that aim to support both synchronous and asynchronous usage patterns without requiring the user to manage different types of iterable objects.
+    The class achieves this by implementing both `__iter__` and `__aiter__` methods, enabling it to return appropriate iterator objects that can handle synchronous and asynchronous iteration, respectively. However, note that synchronous iteration relies on the :class:`ASyncIterator` class, which uses `asyncio.get_event_loop().run_until_complete` to fetch items. This can raise a `RuntimeError` if the event loop is already running, resulting in a :class:`SyncModeInAsyncContextError`.
+
+    Example:
+        >>> async_iterable = ASyncIterable(some_async_iterable)
+        >>> async for item in async_iterable:
+        ...     print(item)
+        >>> for item in async_iterable:
+        ...     print(item)
+
+    See Also:
+        - :class:`ASyncIterator`
+        - :class:`ASyncFilter`
+        - :class:`ASyncSorter`
     """
+
     @classmethod
     def wrap(cls, wrapped: AsyncIterable[T]) -> "ASyncIterable[T]":
         "Class method to wrap an AsyncIterable for backward compatibility."
-        logger.warning("ASyncIterable.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterable(wrapped)`")
+        logger.warning(
+            "ASyncIterable.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterable(wrapped)`"
+        )
         return cls(wrapped)
+
     def __init__(self, async_iterable: AsyncIterable[T]):
-        "Initializes the ASyncIterable with an async iterable."
+        """
+        Initializes the ASyncIterable with an async iterable.
+
+        Args:
+            async_iterable: The async iterable to wrap.
+        """
         if not isinstance(async_iterable, AsyncIterable):
-            raise TypeError(f"`async_iterable` must be an AsyncIterable. You passed {async_iterable}")
+            raise TypeError(
+                f"`async_iterable` must be an AsyncIterable. You passed {async_iterable}"
+            )
         self.__wrapped__ = async_iterable
         "The wrapped async iterable object."
+
     def __repr__(self) -> str:
         start = f"<{type(self).__name__}"
         if wrapped := getattr(self, "__wrapped__", None):
@@ -151,23 +177,39 @@ class ASyncIterable(_AwaitableAsyncIterableMixin[T], Iterable[T]):
     def __iter__(self) -> Iterator[T]:
         "Return an iterator that yields :obj:`T` objects from the {cls}."
         yield from ASyncIterator(self.__aiter__())
-    __slots__ = "__wrapped__", 
+
+    __slots__ = ("__wrapped__",)
+
 
 AsyncGenFunc = Callable[P, Union[AsyncGenerator[T, None], AsyncIterator[T]]]
 
+
 class ASyncIterator(_AwaitableAsyncIterableMixin[T], Iterator[T]):
     """
     A hybrid Iterator/AsyncIterator implementation that bridges the gap between synchronous and asynchronous iteration. This class provides a unified interface for iteration that can seamlessly operate in both synchronous (`for` loop) and asynchronous (`async for` loop) contexts. It allows the wrapping of asynchronous iterable objects or async generator functions, making them usable in synchronous code without explicitly managing event loops or asynchronous context switches.
 
     By implementing both `__next__` and `__anext__` methods, ASyncIterator enables objects to be iterated using standard iteration protocols while internally managing the complexities of asynchronous iteration. This design simplifies the use of asynchronous iterables in environments or frameworks that are not inherently asynchronous, such as standard synchronous functions or older codebases being gradually migrated to asynchronous IO.
 
-    This class is particularly useful for library developers seeking to provide a consistent iteration interface across synchronous and asynchronous code, reducing the cognitive load on users and promoting code reusability and simplicity.
+    Note:
+        Synchronous iteration with `ASyncIterator` uses `asyncio.get_event_loop().run_until_complete`, which can raise a `RuntimeError` if the event loop is already running. In such cases, a :class:`SyncModeInAsyncContextError` is raised, indicating that synchronous iteration is not possible in an already running event loop.
+
+    Example:
+        >>> async_iterator = ASyncIterator(some_async_iterator)
+        >>> async for item in async_iterator:
+        ...     print(item)
+        >>> for item in async_iterator:
+        ...     print(item)
+
+    See Also:
+        - :class:`ASyncIterable`
+        - :class:`ASyncFilter`
+        - :class:`ASyncSorter`
     """
-    
+
     def __next__(self) -> T:
         """
         Synchronously fetch the next item from the {cls}.
-        
+
         Raises:
             :class:`StopIteration`: Once all items have been fetched from the {cls}.
         """
@@ -177,34 +219,61 @@ class ASyncIterator(_AwaitableAsyncIterableMixin[T], Iterator[T]):
             raise StopIteration from e
         except RuntimeError as e:
             if str(e) == "This event loop is already running":
-                raise SyncModeInAsyncContextError("The event loop is already running. Try iterating using `async for` instead of `for`.") from e
+                raise SyncModeInAsyncContextError(
+                    "The event loop is already running. Try iterating using `async for` instead of `for`."
+                ) from e
             raise
 
     @overload
-    def wrap(cls, aiterator: AsyncIterator[T]) -> "ASyncIterator[T]":...
+    def wrap(cls, aiterator: AsyncIterator[T]) -> "ASyncIterator[T]":
+        """
+        Wraps an AsyncIterator in an ASyncIterator.
+
+        Args:
+            aiterator: The AsyncIterator to wrap.
+        """
+
     @overload
-    def wrap(cls, async_gen_func: AsyncGenFunc[P, T]) -> "ASyncGeneratorFunction[P, T]":...
+    def wrap(cls, async_gen_func: AsyncGenFunc[P, T]) -> "ASyncGeneratorFunction[P, T]":
+        """
+        Wraps an async generator function in an ASyncGeneratorFunction.
+
+        Args:
+            async_gen_func: The async generator function to wrap.
+        """
+
     @classmethod
     def wrap(cls, wrapped):
         "Class method to wrap either an AsyncIterator or an async generator function."
         if isinstance(wrapped, AsyncIterator):
-            logger.warning("This use case for ASyncIterator.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterator(wrapped)`")
+            logger.warning(
+                "This use case for ASyncIterator.wrap will be removed soon. Please replace uses with simple instantiation ie `ASyncIterator(wrapped)`"
+            )
             return cls(wrapped)
         elif inspect.isasyncgenfunction(wrapped):
             return ASyncGeneratorFunction(wrapped)
-        raise TypeError(f"`wrapped` must be an AsyncIterator or an async generator function. You passed {wrapped}")
+        raise TypeError(
+            f"`wrapped` must be an AsyncIterator or an async generator function. You passed {wrapped}"
+        )
 
     def __init__(self, async_iterator: AsyncIterator[T]):
-        "Initializes the ASyncIterator with an async iterator."
+        """
+        Initializes the ASyncIterator with an async iterator.
+
+        Args:
+            async_iterator: The async iterator to wrap.
+        """
         if not isinstance(async_iterator, AsyncIterator):
-            raise TypeError(f"`async_iterator` must be an AsyncIterator. You passed {async_iterator}")
+            raise TypeError(
+                f"`async_iterator` must be an AsyncIterator. You passed {async_iterator}"
+            )
         self.__wrapped__ = async_iterator
         "The wrapped :class:`AsyncIterator`."
 
     async def __anext__(self) -> T:
         """
         Asynchronously fetch the next item from the {cls}.
-        
+
         Raises:
             :class:`StopAsyncIteration`: Once all items have been fetched from the {cls}.
         """
@@ -218,6 +287,7 @@ class ASyncIterator(_AwaitableAsyncIterableMixin[T], Iterator[T]):
         "Return the {cls} for aiteration."
         return self
 
+
 class ASyncGeneratorFunction(Generic[P, T]):
     """
     Encapsulates an asynchronous generator function, providing a mechanism to use it as an asynchronous iterator with enhanced capabilities. This class wraps an async generator function, allowing it to be called with parameters and return an :class:`~ASyncIterator` object. It is particularly useful for situations where an async generator function needs to be used in a manner that is consistent with both synchronous and asynchronous execution contexts.
@@ -225,6 +295,18 @@ class ASyncGeneratorFunction(Generic[P, T]):
     The ASyncGeneratorFunction class supports dynamic binding to instances, enabling it to be used as a method on class instances. When accessed as a descriptor, it automatically handles the binding to the instance, thereby allowing the wrapped async generator function to be invoked with instance context ('self') automatically provided. This feature is invaluable for designing classes that need to expose asynchronous generators as part of their interface while maintaining the ease of use and calling semantics similar to regular methods.
 
     By providing a unified interface to asynchronous generator functions, this class facilitates the creation of APIs that are flexible and easy to use in a wide range of asynchronous programming scenarios. It abstracts away the complexities involved in managing asynchronous generator lifecycles and invocation semantics, making it easier for developers to integrate asynchronous iteration patterns into their applications.
+
+    Example:
+        >>> async def my_async_gen():
+        ...     yield 1
+        ...     yield 2
+        >>> async_gen_func = ASyncGeneratorFunction(my_async_gen)
+        >>> for item in async_gen_func():
+        ...     print(item)
+
+    See Also:
+        - :class:`ASyncIterator`
+        - :class:`ASyncIterable`
     """
 
     _cache_handle: asyncio.TimerHandle
@@ -233,7 +315,9 @@ class ASyncGeneratorFunction(Generic[P, T]):
     __weakself__: "weakref.ref[object]" = None
     "A weak reference to the instance the function is bound to, if any."
 
-    def __init__(self, async_gen_func: AsyncGenFunc[P, T], instance: Any = None) -> None:
+    def __init__(
+        self, async_gen_func: AsyncGenFunc[P, T], instance: Any = None
+    ) -> None:
         """
         Initializes the ASyncGeneratorFunction with the given async generator function and optionally an instance.
 
@@ -241,7 +325,7 @@ class ASyncGeneratorFunction(Generic[P, T]):
             async_gen_func: The async generator function to wrap.
             instance (optional): The object to bind to the function, if applicable.
         """
-        
+
         self.field_name = async_gen_func.__name__
         "The name of the async generator function."
 
@@ -263,9 +347,6 @@ class ASyncGeneratorFunction(Generic[P, T]):
         Args:
             *args: Positional arguments for the function.
             **kwargs: Keyword arguments for the function.
-    
-        Returns:
-            An :class:`ASyncIterator` wrapping the :class:`AsyncIterator` returned from the wrapped function call.
         """
         if self.__weakself__ is None:
             return ASyncIterator(self.__wrapped__(*args, **kwargs))
@@ -296,11 +377,14 @@ class ASyncGeneratorFunction(Generic[P, T]):
 
     def __get_cache_handle(self, instance: object) -> asyncio.TimerHandle:
         # NOTE: we create a strong reference to instance here. I'm not sure if this is good or not but its necessary for now.
-        return asyncio.get_event_loop().call_later(300, delattr, instance, self.field_name)
+        return asyncio.get_event_loop().call_later(
+            300, delattr, instance, self.field_name
+        )
 
     def __cancel_cache_handle(self, instance: object) -> None:
         self._cache_handle.cancel()
 
+
 class _ASyncView(ASyncIterator[T]):
     """
     Internal mixin class containing logic for creating specialized views for :class:`~ASyncIterable` objects.
@@ -313,8 +397,8 @@ class _ASyncView(ASyncIterator[T]):
     """An optional iterator. If None, :attr:`~_ASyncView.__aiterator__` will have a value."""
 
     def __init__(
-        self, 
-        function: ViewFn[T], 
+        self,
+        function: ViewFn[T],
         iterable: AnyIterable[T],
     ) -> None:
         """
@@ -331,18 +415,33 @@ class _ASyncView(ASyncIterator[T]):
         elif isinstance(iterable, Iterable):
             self.__iterator__ = iterable.__iter__()
         else:
-            raise TypeError(f"`iterable` must be AsyncIterable or Iterable, you passed {iterable}")
+            raise TypeError(
+                f"`iterable` must be AsyncIterable or Iterable, you passed {iterable}"
+            )
 
-@final  
+
+@final
 class ASyncFilter(_ASyncView[T]):
     """
-    An async filter class that filters items of an async iterable based on a provided function. 
-    
+    An async filter class that filters items of an async iterable based on a provided function.
+
     This class inherits from :class:`~_ASyncView` and provides the functionality to asynchronously
     iterate over items, applying the filter function to each item to determine if it should be
-    included in the result.
+    included in the result. The filter function can be either synchronous or asynchronous.
+
+    Example:
+        >>> async def is_even(x):
+        ...     return x % 2 == 0
+        >>> filtered_iterable = ASyncFilter(is_even, some_async_iterable)
+        >>> async for item in filtered_iterable:
+        ...     print(item)
+
+    See Also:
+        - :class:`ASyncIterable`
+        - :class:`ASyncIterator`
+        - :class:`ASyncSorter`
     """
-    
+
     def __repr__(self) -> str:
         return f"<ASyncFilter for iterator={self.__wrapped__} function={self._function.__name__} at {hex(id(self))}>"
 
@@ -382,28 +481,38 @@ def _key_if_no_key(obj: T) -> T:
 
     Args:
         obj: The object to return.
-
-    Returns:
-        The object itself.
     """
     return obj
 
+
 @final
 class ASyncSorter(_ASyncView[T]):
     """
-    An async sorter class that sorts items of an async iterable based on a provided key function. 
-    
+    An async sorter class that sorts items of an async iterable based on a provided key function.
+
     This class inherits from :class:`~_ASyncView` and provides the functionality to asynchronously
-    iterate over items, applying the key function to each item for sorting.
+    iterate over items, applying the key function to each item for sorting. The key function can be
+    either synchronous or asynchronous. Note that the ASyncSorter instance can only be consumed once.
+
+    Example:
+        >>> sorted_iterable = ASyncSorter(some_async_iterable, key=lambda x: x.value)
+        >>> async for item in sorted_iterable:
+        ...     print(item)
+
+    See Also:
+        - :class:`ASyncIterable`
+        - :class:`ASyncIterator`
+        - :class:`ASyncFilter`
     """
+
     reversed: bool = False
     _consumed: bool = False
 
     def __init__(
-        self, 
+        self,
         iterable: AsyncIterable[T],
         *,
-        key: SortKey[T] = None, 
+        key: SortKey[T] = None,
         reverse: bool = False,
     ) -> None:
         """
@@ -467,7 +576,9 @@ class ASyncSorter(_ASyncView[T]):
                 for obj in self.__iterator__:
                     items.append(obj)
                     sort_tasks.append(asyncio.create_task(self._function(obj)))
-                for sort_value, obj in sorted(zip(await asyncio.gather(*sort_tasks), items), reverse=reverse):
+                for sort_value, obj in sorted(
+                    zip(await asyncio.gather(*sort_tasks), items), reverse=reverse
+                ):
                     yield obj
         else:
             if self.__aiterator__:
@@ -480,4 +591,10 @@ class ASyncSorter(_ASyncView[T]):
         self._consumed = True
 
 
-__all__ = ["ASyncIterable", "ASyncIterator", "ASyncFilter", "ASyncSorter", "ASyncGeneratorFunction"]
+__all__ = [
+    "ASyncIterable",
+    "ASyncIterator",
+    "ASyncFilter",
+    "ASyncSorter",
+    "ASyncGeneratorFunction",
+]

a_sync/primitives/__init__.py

@@ -1,6 +1,18 @@
-
 """
-While not the focus of this lib, this module includes some new primitives and some modified versions of standard asyncio primitives.
+This module includes both new primitives and modified versions of standard asyncio primitives.
+
+The primitives provided in this module are:
+
+- Semaphore
+- ThreadsafeSemaphore
+- PrioritySemaphore
+- CounterLock
+- Event
+- Queue
+- ProcessingQueue
+- SmartProcessingQueue
+
+These primitives extend or modify the functionality of standard asyncio primitives to provide additional features or improved performance for specific use cases.
 """
 
 from a_sync.primitives.locks import *

a_sync/primitives/_debug.py

@@ -1,7 +1,7 @@
 """
-This module provides a mixin class used to provide helpful information to developers during the debugging process.
+This module provides a mixin class used to facilitate the creation of debugging daemons in subclasses.
 
-The mixin ensures that rich debug logs are automagically emitted from subclass instances whenever debug logging is enabled.
+The mixin provides a framework for managing a debug daemon task, which can be used to emit rich debug logs from subclass instances whenever debug logging is enabled. Subclasses must implement the specific logging behavior.
 """
 
 import abc
@@ -13,55 +13,96 @@ from a_sync.primitives._loggable import _LoggerMixin
 
 class _DebugDaemonMixin(_LoggerMixin, metaclass=abc.ABCMeta):
     """
-    A mixin class that provides debugging capabilities using a daemon task.
-    
-    This mixin ensures that rich debug logs are automagically emitted from subclass instances whenever debug logging is enabled.
+    A mixin class that provides a framework for debugging capabilities using a daemon task.
+
+    This mixin sets up the structure for managing a debug daemon task. Subclasses are responsible for implementing the specific behavior of the daemon, including any logging functionality.
+
+    See Also:
+        :class:`_LoggerMixin` for logging capabilities.
     """
-    
-    __slots__ = "_daemon",
+
+    __slots__ = ("_daemon",)
 
     @abc.abstractmethod
     async def _debug_daemon(self, fut: asyncio.Future, fn, *args, **kwargs) -> None:
         """
         Abstract method to define the debug daemon's behavior.
-        
+
+        Subclasses must implement this method to specify what the debug daemon should do, including any logging or monitoring tasks.
+
         Args:
             fut: The future associated with the daemon.
             fn: The function to be debugged.
             *args: Positional arguments for the function.
             **kwargs: Keyword arguments for the function.
+
+        Examples:
+            Implementing a simple debug daemon in a subclass:
+
+            .. code-block:: python
+
+                class MyDebugClass(_DebugDaemonMixin):
+                    async def _debug_daemon(self, fut, fn, *args, **kwargs):
+                        while not fut.done():
+                            self.logger.debug("Debugging...")
+                            await asyncio.sleep(1)
         """
 
     def _start_debug_daemon(self, *args, **kwargs) -> "asyncio.Future[None]":
         """
         Starts the debug daemon task if debug logging is enabled and the event loop is running.
-        
+
+        This method checks if debug logging is enabled and if the event loop is running. If both conditions are met, it starts the debug daemon task.
+
         Args:
             *args: Positional arguments for the debug daemon.
             **kwargs: Keyword arguments for the debug daemon.
-        
+
         Returns:
-            The debug daemon task, or a dummy future if debug logs are not enabled or if the daemon cannot be created.
+            The debug daemon task as an asyncio.Task, or a dummy future if debug logs are not enabled or if the daemon cannot be created.
+
+        Examples:
+            Starting the debug daemon:
+
+            .. code-block:: python
+
+                my_instance = MyDebugClass()
+                my_instance._start_debug_daemon()
+
+        See Also:
+            :meth:`_ensure_debug_daemon` for ensuring the daemon is running.
         """
         if self.debug_logs_enabled and asyncio.get_event_loop().is_running():
             return asyncio.create_task(self._debug_daemon(*args, **kwargs))
-        # else we return a blank Future since we shouldn't or can't create the daemon
         return asyncio.get_event_loop().create_future()
 
     def _ensure_debug_daemon(self, *args, **kwargs) -> "asyncio.Future[None]":
         """
         Ensures that the debug daemon task is running.
-        
+
+        This method checks if the debug daemon is already running and starts it if necessary. It will only start the daemon if it is not already running.
+
         Args:
             *args: Positional arguments for the debug daemon.
             **kwargs: Keyword arguments for the debug daemon.
-        
+
         Returns:
             Either the debug daemon task or a dummy future if debug logging is not enabled.
+
+        Examples:
+            Ensuring the debug daemon is running:
+
+            .. code-block:: python
+
+                my_instance = MyDebugClass()
+                my_instance._ensure_debug_daemon()
+
+        See Also:
+            :meth:`_start_debug_daemon` for starting the daemon.
         """
         if not self.debug_logs_enabled:
             self._daemon = asyncio.get_event_loop().create_future()
-        if not hasattr(self, '_daemon') or self._daemon is None:
+        if not hasattr(self, "_daemon") or self._daemon is None:
             self._daemon = self._start_debug_daemon(*args, **kwargs)
             self._daemon.add_done_callback(self._stop_debug_daemon)
         return self._daemon
@@ -69,12 +110,25 @@ class _DebugDaemonMixin(_LoggerMixin, metaclass=abc.ABCMeta):
     def _stop_debug_daemon(self, t: Optional[asyncio.Task] = None) -> None:
         """
         Stops the debug daemon task.
-        
+
+        This method cancels the debug daemon task if it is running. Raises a ValueError if the task to be stopped is not the current daemon.
+
         Args:
-            t (optional): The task to be stopped, if any. 
-        
+            t (optional): The task to be stopped, if any.
+
         Raises:
             ValueError: If `t` is not the current daemon.
+
+        Examples:
+            Stopping the debug daemon:
+
+            .. code-block:: python
+
+                my_instance = MyDebugClass()
+                my_instance._stop_debug_daemon()
+
+        See Also:
+            :meth:`_ensure_debug_daemon` for ensuring the daemon is running.
         """
         if t and t != self._daemon:
             raise ValueError(f"{t} is not {self._daemon}")