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

a_sync/a_sync/function.py

@@ -30,9 +30,15 @@ class _ModifiedMixin:
     `ASyncFunctionAsyncDefault` and `ASyncFunctionSyncDefault`, to handle the application
     of async and sync modifiers to functions. Modifiers can alter the behavior of functions,
     such as converting sync functions to async, applying caching, or rate limiting.
+
+    See Also:
+        - :class:`~ASyncFunction`
+        - :class:`~ModifierManager`
     """
 
+    # TODO: give me a docstring
     modifiers: ModifierManager
+
     __slots__ = "modifiers", "wrapped"
 
     def _asyncify(self, func: SyncFn[P, T]) -> CoroFn[P, T]:
@@ -44,6 +50,10 @@ class _ModifiedMixin:
 
         Returns:
             The asynchronous version of the function with applied modifiers.
+
+        See Also:
+            - :func:`_helpers._asyncify`
+            - :meth:`ModifierManager.apply_async_modifiers`
         """
         coro_fn = _helpers._asyncify(func, self.modifiers.executor)
         return self.modifiers.apply_async_modifiers(coro_fn)
@@ -55,6 +65,10 @@ class _ModifiedMixin:
 
         Returns:
             The modified _await function.
+
+        See Also:
+            - :func:`_helpers._await`
+            - :meth:`ModifierManager.apply_sync_modifiers`
         """
         return self.modifiers.apply_sync_modifiers(_helpers._await)
 
@@ -65,6 +79,9 @@ class _ModifiedMixin:
 
         Returns:
             The default execution mode.
+
+        See Also:
+            - :attr:`ModifierManager.default`
         """
         return self.modifiers.default
 
@@ -78,6 +95,9 @@ def _validate_wrapped_fn(fn: Callable) -> None:
     Raises:
         TypeError: If the input is not callable.
         RuntimeError: If the function has arguments with names that conflict with viable flags.
+
+    See Also:
+        - :func:`_check_not_genfunc`
     """
     if isinstance(fn, (AsyncPropertyDescriptor, AsyncCachedPropertyDescriptor)):
         return  # These are always valid
@@ -105,6 +125,11 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
     The class supports various modifiers that can alter the behavior of the function,
     such as caching, rate limiting, and execution in specific contexts (e.g., thread pools).
 
+    Note:
+        The logic for determining whether to execute the function synchronously or asynchronously
+        is handled by the `_run_sync` method, which checks for flags in the `kwargs` and defers
+        to the default execution mode if no flags are specified.
+
     Example:
         async def my_coroutine(x: int) -> str:
             return str(x)
@@ -116,19 +141,45 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         # Asynchronous call
         result = await func(5)  # returns "5"
+
+    See Also:
+        - :class:`_ModifiedMixin`
+        - :class:`ModifierManager`
     """
 
     # NOTE: We can't use __slots__ here because it breaks functools.update_wrapper
 
     @overload
     def __init__(self, fn: CoroFn[P, T], **modifiers: Unpack[ModifierKwargs]) -> None:
-        ...
-        # TODO write specific docs for this overload
+        """
+        Initializes an ASyncFunction instance for a coroutine function.
+
+        Args:
+            fn: The coroutine function to wrap.
+            **modifiers: Keyword arguments for function modifiers.
+
+        Example:
+            async def my_coroutine(x: int) -> str:
+                return str(x)
+
+            func = ASyncFunction(my_coroutine, cache_type='memory')
+        """
 
     @overload
     def __init__(self, fn: SyncFn[P, T], **modifiers: Unpack[ModifierKwargs]) -> None:
-        ...
-        # TODO write specific docs for this overload
+        """
+        Initializes an ASyncFunction instance for a synchronous function.
+
+        Args:
+            fn: The synchronous function to wrap.
+            **modifiers: Keyword arguments for function modifiers.
+
+        Example:
+            def my_function(x: int) -> str:
+                return str(x)
+
+            func = ASyncFunction(my_function, runs_per_minute=60)
+        """
 
     def __init__(self, fn: AnyFn[P, T], **modifiers: Unpack[ModifierKwargs]) -> None:
         """
@@ -137,6 +188,10 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
         Args:
             fn: The function to wrap.
             **modifiers: Keyword arguments for function modifiers.
+
+        See Also:
+            - :func:`_validate_wrapped_fn`
+            - :class:`ModifierManager`
         """
         _validate_wrapped_fn(fn)
 
@@ -156,34 +211,78 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
     @overload
     def __call__(self, *args: P.args, sync: Literal[True], **kwargs: P.kwargs) -> T:
-        ...
-        # TODO write specific docs for this overload
+        """
+        Calls the wrapped function synchronously.
+
+        Args:
+            *args: Positional arguments to pass to the wrapped function.
+            sync: Must be True to indicate synchronous execution.
+            **kwargs: Keyword arguments to pass to the wrapped function.
+
+        Example:
+            result = func(5, sync=True)
+        """
 
     @overload
     def __call__(
         self, *args: P.args, sync: Literal[False], **kwargs: P.kwargs
     ) -> Coroutine[Any, Any, T]:
-        ...
-        # TODO write specific docs for this overload
+        """
+        Calls the wrapped function asynchronously.
+
+        Args:
+            *args: Positional arguments to pass to the wrapped function.
+            sync: Must be False to indicate asynchronous execution.
+            **kwargs: Keyword arguments to pass to the wrapped function.
+
+        Example:
+            result = await func(5, sync=False)
+        """
 
     @overload
     def __call__(
         self, *args: P.args, asynchronous: Literal[False], **kwargs: P.kwargs
     ) -> T:
-        ...
-        # TODO write specific docs for this overload
+        """
+        Calls the wrapped function synchronously.
+
+        Args:
+            *args: Positional arguments to pass to the wrapped function.
+            asynchronous: Must be False to indicate synchronous execution.
+            **kwargs: Keyword arguments to pass to the wrapped function.
+
+        Example:
+            result = func(5, asynchronous=False)
+        """
 
     @overload
     def __call__(
         self, *args: P.args, asynchronous: Literal[True], **kwargs: P.kwargs
     ) -> Coroutine[Any, Any, T]:
-        ...
-        # TODO write specific docs for this overload
+        """
+        Calls the wrapped function asynchronously.
+
+        Args:
+            *args: Positional arguments to pass to the wrapped function.
+            asynchronous: Must be True to indicate asynchronous execution.
+            **kwargs: Keyword arguments to pass to the wrapped function.
+
+        Example:
+            result = await func(5, asynchronous=True)
+        """
 
     @overload
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
-        ...
-        # TODO write specific docs for this overload
+        """
+        Calls the wrapped function using the default execution mode.
+
+        Args:
+            *args: Positional arguments to pass to the wrapped function.
+            **kwargs: Keyword arguments to pass to the wrapped function.
+
+        Example:
+            result = func(5)
+        """
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
         """
@@ -192,12 +291,21 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
         This method determines whether to execute the wrapped function synchronously
         or asynchronously based on the default mode and any provided flags.
 
+        Note:
+            The logic for determining the execution mode is handled by the
+            :meth:`_run_sync` method, which checks for flags in the kwargs and
+            defers to the default execution mode if no flags are specified.
+
         Args:
             *args: Positional arguments to pass to the wrapped function.
             **kwargs: Keyword arguments to pass to the wrapped function.
 
         Raises:
             Exception: Any exception that may be raised by the wrapped function.
+
+        See Also:
+            - :attr:`default`
+            - :meth:`_run_sync`
         """
         logger.debug(
             "calling %s fn: %s with args: %s kwargs: %s", self, self.fn, args, kwargs
@@ -208,14 +316,18 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
         return f"<{self.__class__.__name__} {self.__module__}.{self.__name__} at {hex(id(self))}>"
 
     @functools.cached_property
-    def fn(
-        self,
-    ):  # -> Union[SyncFn[[CoroFn[P, T]], MaybeAwaitable[T]], SyncFn[[SyncFn[P, T]], MaybeAwaitable[T]]]:
+    def fn(self):
+        # NOTE type hint doesnt work in py3.8 or py3.9, debug later
+        #  -> Union[SyncFn[[CoroFn[P, T]], MaybeAwaitable[T]], SyncFn[[SyncFn[P, T]], MaybeAwaitable[T]]]:
         """
         Returns the final wrapped version of :attr:`ASyncFunction._fn` decorated with all of the a_sync goodness.
 
         Returns:
             The final wrapped function.
+
+        See Also:
+            - :meth:`_async_wrap`
+            - :meth:`_sync_wrap`
         """
         return self._async_wrap if self._async_def else self._sync_wrap
 
@@ -239,6 +351,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 A TaskMapping object for managing concurrent execution.
+
+            See Also:
+                - :class:`TaskMapping`
             """
             from a_sync import TaskMapping
 
@@ -268,6 +383,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 True if any result is truthy, otherwise False.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -294,6 +412,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 True if all results are truthy, otherwise False.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -320,6 +441,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 The minimum result.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -346,6 +470,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 The maximum result.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -372,6 +499,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 The sum of the results.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -400,6 +530,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 A TaskMapping object for managing concurrent execution.
+
+            See Also:
+                - :class:`TaskMapping`
             """
             from a_sync import TaskMapping
 
@@ -429,6 +562,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 True if any result is truthy, otherwise False.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -455,6 +591,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 True if all results are truthy, otherwise False.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -481,6 +620,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 The minimum result.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -507,6 +649,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 The maximum result.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -533,6 +678,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
             Returns:
                 The sum of the results.
+
+            See Also:
+                - :meth:`map`
             """
             return await self.map(
                 *iterables,
@@ -551,6 +699,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         Returns:
             True if the default is sync, False if async.
+
+        See Also:
+            - :attr:`default`
         """
         return (
             True
@@ -565,6 +716,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         Returns:
             True if the function is asynchronous, otherwise False.
+
+        See Also:
+            - :func:`asyncio.iscoroutinefunction`
         """
         return asyncio.iscoroutinefunction(self.__wrapped__)
 
@@ -580,6 +734,10 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         Returns:
             True if the function should run synchronously, otherwise False.
+
+        See Also:
+            - :func:`_kwargs.get_flag_name`
+            - :func:`_kwargs.is_sync`
         """
         if flag := _kwargs.get_flag_name(kwargs):
             # If a flag was specified in the kwargs, we will defer to it.
@@ -598,6 +756,9 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         Returns:
             The asynchronous version of the wrapped function.
+
+        See Also:
+            - :meth:`_asyncify`
         """
         if self._async_def:
             raise TypeError(
@@ -615,6 +776,10 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         Returns:
             The modified function.
+
+        See Also:
+            - :meth:`ModifierManager.apply_async_modifiers`
+            - :meth:`ModifierManager.apply_sync_modifiers`
         """
         if self._async_def:
             return self.modifiers.apply_async_modifiers(self.__wrapped__)  # type: ignore [arg-type]
@@ -629,6 +794,10 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         Returns:
             The wrapped function with async handling.
+
+        See Also:
+            - :meth:`_run_sync`
+            - :meth:`_await`
         """
 
         @functools.wraps(self._modified_fn)
@@ -650,6 +819,10 @@ class ASyncFunction(_ModifiedMixin, Generic[P, T]):
 
         Returns:
             The wrapped function with sync handling.
+
+        See Also:
+            - :meth:`_run_sync`
+            - :meth:`_asyncified`
         """
 
         @functools.wraps(self._modified_fn)
@@ -679,6 +852,9 @@ class ASyncDecorator(_ModifiedMixin):
 
         Raises:
             ValueError: If 'default' is not 'sync', 'async', or None.
+
+        See Also:
+            - :class:`ModifierManager`
         """
         assert "default" in modifiers, modifiers
         self.modifiers = ModifierManager(modifiers)
@@ -690,6 +866,9 @@ class ASyncDecorator(_ModifiedMixin):
 
         Raises:
             ValueError: If 'default' is not 'sync', 'async', or None.
+
+        See Also:
+            - :attr:`ModifierManager.default`
         """
         if self.modifiers.default not in ["sync", "async", None]:
             raise ValueError(
@@ -698,11 +877,33 @@ class ASyncDecorator(_ModifiedMixin):
 
     @overload
     def __call__(self, func: AnyFn[Concatenate[B, P], T]) -> "ASyncBoundMethod[B, P, T]":  # type: ignore [override]
-        ...  # TODO write specific docs for this overload
+        """
+        Decorates a bound method with async or sync behavior based on the default modifier.
+
+        Args:
+            func: The bound method to decorate.
+
+        Returns:
+            An ASyncBoundMethod instance with the appropriate default behavior.
+
+        See Also:
+            - :class:`ASyncBoundMethod`
+        """
 
     @overload
     def __call__(self, func: AnyFn[P, T]) -> ASyncFunction[P, T]:  # type: ignore [override]
-        ...  # TODO write specific docs for this overload
+        """
+        Decorates a function with async or sync behavior based on the default modifier.
+
+        Args:
+            func: The function to decorate.
+
+        Returns:
+            An ASyncFunction instance with the appropriate default behavior.
+
+        See Also:
+            - :class:`ASyncFunction`
+        """
 
     def __call__(self, func: AnyFn[P, T]) -> ASyncFunction[P, T]:  # type: ignore [override]
         """
@@ -713,6 +914,9 @@ class ASyncDecorator(_ModifiedMixin):
 
         Returns:
             An ASyncFunction instance with the appropriate default behavior.
+
+        See Also:
+            - :class:`ASyncFunction`
         """
         if self.default == "async":
             return ASyncFunctionAsyncDefault(func, **self.modifiers)
@@ -732,6 +936,10 @@ def _check_not_genfunc(func: Callable) -> None:
 
     Raises:
         ValueError: If the function is a generator or async generator.
+
+    See Also:
+        - :func:`inspect.isasyncgenfunction`
+        - :func:`inspect.isgeneratorfunction`
     """
     if inspect.isasyncgenfunction(func) or inspect.isgeneratorfunction(func):
         raise ValueError("unable to decorate generator functions with this decorator")
@@ -763,25 +971,36 @@ class ASyncFunctionSyncDefault(ASyncFunction[P, T]):
     """
 
     @overload
-    def __call__(
-        self, *args: P.args, sync: Literal[True], **kwargs: P.kwargs
-    ) -> T: ...  # TODO write specific docs for this overload
+    def __call__(self, *args: P.args, sync: Literal[True], **kwargs: P.kwargs) -> T:
+        # TODO write specific docs for this overload
+        ...
+
     @overload
     def __call__(
         self, *args: P.args, sync: Literal[False], **kwargs: P.kwargs
-    ) -> Coroutine[Any, Any, T]: ...  # TODO write specific docs for this overload
+    ) -> Coroutine[Any, Any, T]:
+        # TODO write specific docs for this overload
+        ...
+
     @overload
     def __call__(
         self, *args: P.args, asynchronous: Literal[False], **kwargs: P.kwargs
-    ) -> T: ...  # TODO write specific docs for this overload
+    ) -> T:
+        # TODO write specific docs for this overload
+        ...
+
     @overload
     def __call__(
         self, *args: P.args, asynchronous: Literal[True], **kwargs: P.kwargs
-    ) -> Coroutine[Any, Any, T]: ...  # TODO write specific docs for this overload
+    ) -> Coroutine[Any, Any, T]:
+        # TODO write specific docs for this overload
+        ...
+
     @overload
-    def __call__(
-        self, *args: P.args, **kwargs: P.kwargs
-    ) -> T: ...  # TODO write specific docs for this overload
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        # TODO write specific docs for this overload
+        ...
+
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
         """Calls the wrapped function, defaulting to synchronous execution.
 
@@ -797,6 +1016,9 @@ class ASyncFunctionSyncDefault(ASyncFunction[P, T]):
 
         Returns:
             The result of the function call.
+
+        See Also:
+            - :meth:`ASyncFunction.__call__`
         """
         return self.fn(*args, **kwargs)
 
@@ -827,31 +1049,33 @@ class ASyncFunctionAsyncDefault(ASyncFunction[P, T]):
     """
 
     @overload
-    def __call__(self, *args: P.args, sync: Literal[True], **kwargs: P.kwargs) -> T: ...
+    def __call__(self, *args: P.args, sync: Literal[True], **kwargs: P.kwargs) -> T:
+        # TODO write specific docs for this overload
+        ...
 
-    # TODO write specific docs for this overload
     @overload
     def __call__(
         self, *args: P.args, sync: Literal[False], **kwargs: P.kwargs
-    ) -> Coroutine[Any, Any, T]: ...
+    ) -> Coroutine[Any, Any, T]:
+        # TODO write specific docs for this overload
+        ...
 
-    # TODO write specific docs for this overload
     @overload
     def __call__(
         self, *args: P.args, asynchronous: Literal[False], **kwargs: P.kwargs
-    ) -> T: ...
+    ) -> T:
+        # TODO write specific docs for this overload
+        ...
 
-    # TODO write specific docs for this overload
     @overload
     def __call__(
         self, *args: P.args, asynchronous: Literal[True], **kwargs: P.kwargs
-    ) -> Coroutine[Any, Any, T]: ...
+    ) -> Coroutine[Any, Any, T]:
+        # TODO write specific docs for this overload
+        ...
 
-    # TODO write specific docs for this overload
     @overload
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, T]: ...
-
-    # TODO write specific docs for this overload
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> MaybeCoro[T]:
         """Calls the wrapped function, defaulting to asynchronous execution.
 
@@ -867,6 +1091,9 @@ class ASyncFunctionAsyncDefault(ASyncFunction[P, T]):
 
         Returns:
             The result of the function call.
+
+        See Also:
+            - :meth:`ASyncFunction.__call__`
         """
         return self.fn(*args, **kwargs)
 
@@ -876,35 +1103,100 @@ class ASyncFunctionAsyncDefault(ASyncFunction[P, T]):
 class ASyncDecoratorSyncDefault(ASyncDecorator):
     @overload
     def __call__(self, func: AnyFn[Concatenate[B, P], T]) -> "ASyncBoundMethodSyncDefault[P, T]":  # type: ignore [override]
-        ...
-        # TODO write specific docs for this overload
+        """
+        Decorates a bound method with synchronous default behavior.
+
+        Args:
+            func: The bound method to decorate.
+
+        Returns:
+            An ASyncBoundMethodSyncDefault instance with synchronous default behavior.
+
+        See Also:
+            - :class:`ASyncBoundMethodSyncDefault`
+        """
 
     @overload
     def __call__(self, func: AnyBoundMethod[P, T]) -> ASyncFunctionSyncDefault[P, T]:  # type: ignore [override]
-        ...  # TODO write specific docs for this overload
+        """
+        Decorates a bound method with synchronous default behavior.
+
+        Args:
+            func: The bound method to decorate.
+
+        Returns:
+            An ASyncFunctionSyncDefault instance with synchronous default behavior.
+
+        See Also:
+            - :class:`ASyncFunctionSyncDefault`
+        """
 
     @overload
     def __call__(self, func: AnyFn[P, T]) -> ASyncFunctionSyncDefault[P, T]:  # type: ignore [override]
-        ...  # TODO write specific docs for this overload
+        """
+        Decorates a function with synchronous default behavior.
+
+        Args:
+            func: The function to decorate.
+
+        Returns:
+            An ASyncFunctionSyncDefault instance with synchronous default behavior.
+
+        See Also:
+            - :class:`ASyncFunctionSyncDefault`
+        """
 
     def __call__(self, func: AnyFn[P, T]) -> ASyncFunctionSyncDefault[P, T]:
-        ...  # TODO write specific docs for this overload
+        # TODO write specific docs for this implementation
         return ASyncFunctionSyncDefault(func, **self.modifiers)
 
 
 class ASyncDecoratorAsyncDefault(ASyncDecorator):
     @overload
     def __call__(self, func: AnyFn[Concatenate[B, P], T]) -> "ASyncBoundMethodAsyncDefault[P, T]":  # type: ignore [override]
-        ...  # TODO write specific docs for this overload
+        """
+        Decorates a bound method with asynchronous default behavior.
+
+        Args:
+            func: The bound method to decorate.
+
+        Returns:
+            An ASyncBoundMethodAsyncDefault instance with asynchronous default behavior.
+
+        See Also:
+            - :class:`ASyncBoundMethodAsyncDefault`
+        """
 
     @overload
     def __call__(self, func: AnyBoundMethod[P, T]) -> ASyncFunctionAsyncDefault[P, T]:  # type: ignore [override]
-        ...  # TODO write specific docs for this overload
+        """
+        Decorates a bound method with asynchronous default behavior.
+
+        Args:
+            func: The bound method to decorate.
+
+        Returns:
+            An ASyncFunctionAsyncDefault instance with asynchronous default behavior.
+
+        See Also:
+            - :class:`ASyncFunctionAsyncDefault`
+        """
 
     @overload
     def __call__(self, func: AnyFn[P, T]) -> ASyncFunctionAsyncDefault[P, T]:  # type: ignore [override]
-        ...  # TODO write specific docs for this overload
+        """
+        Decorates a function with asynchronous default behavior.
+
+        Args:
+            func: The function to decorate.
+
+        Returns:
+            An ASyncFunctionAsyncDefault instance with asynchronous default behavior.
+
+        See Also:
+            - :class:`ASyncFunctionAsyncDefault`
+        """
 
     def __call__(self, func: AnyFn[P, T]) -> ASyncFunctionAsyncDefault[P, T]:
-        # TODO write specific docs for this overload
+        # TODO write specific docs for this implementation
         return ASyncFunctionAsyncDefault(func, **self.modifiers)