feat: ✨️ Add make_async_factory method

Author: remimd

injection/__init__.pyi

@@ -10,6 +10,7 @@ from ._core.common.type import InputType as _InputType
 from ._core.common.type import TypeInfo as _TypeInfo
 from ._core.module import InjectableFactory as _InjectableFactory
 from ._core.module import ModeStr, PriorityStr
+from ._core.module import Recipe as _Recipe
 
 __MODULE: Final[Module] = ...
 
@@ -91,7 +92,7 @@ class Module:
 
     def injectable[**P, T](
         self,
-        wrapped: Callable[P, T] | Callable[P, Awaitable[T]] = ...,
+        wrapped: _Recipe[P, T] = ...,
         /,
         *,
         cls: _InjectableFactory[T] = ...,
@@ -107,7 +108,7 @@ class Module:
 
     def singleton[**P, T](
         self,
-        wrapped: Callable[P, T] | Callable[P, Awaitable[T]] = ...,
+        wrapped: _Recipe[P, T] = ...,
         /,
         *,
         inject: bool = ...,
@@ -176,6 +177,12 @@ class Module:
         /,
         threadsafe: bool = ...,
     ) -> Callable[P, T]: ...
+    def make_async_factory[T](
+        self,
+        wrapped: type[T],
+        /,
+        threadsafe: bool = ...,
+    ) -> Callable[..., Awaitable[T]]: ...
     async def afind_instance[T](self, cls: _InputType[T]) -> T: ...
     def find_instance[T](self, cls: _InputType[T]) -> T:
         """

injection/_core/hook.py

@@ -1,5 +1,4 @@
 import itertools
-from collections import deque
 from collections.abc import Callable, Generator, Iterator
 from dataclasses import dataclass, field
 from inspect import isclass, isgeneratorfunction
@@ -14,8 +13,8 @@
 
 @dataclass(eq=False, frozen=True, slots=True)
 class Hook[**P, T]:
-    __functions: deque[HookFunction[P, T]] = field(
-        default_factory=deque,
+    __functions: list[HookFunction[P, T]] = field(
+        default_factory=list,
         init=False,
         repr=False,
     )
@@ -36,7 +35,7 @@ def __stack(self) -> Iterator[HookFunction[P, T]]:
         return iter(self.__functions)
 
     def add(self, *functions: HookFunction[P, T]) -> Self:
-        self.__functions.extendleft(functions)
+        self.__functions.extend(reversed(functions))
         return self
 
     @classmethod
@@ -65,7 +64,6 @@ def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
                     hook.throw(exc)
                 else:
                     hook.send(value)
-                    return value
 
             except StopIteration as stop:
                 return stop.value

injection/_core/module.py

@@ -3,10 +3,12 @@
 from abc import ABC, abstractmethod
 from collections import OrderedDict, deque
 from collections.abc import (
+    AsyncGenerator,
     AsyncIterator,
     Awaitable,
     Callable,
     Collection,
+    Generator,
     Iterable,
     Iterator,
     Mapping,
@@ -360,6 +362,14 @@ def get_default(cls) -> Priority:
 
 type PriorityStr = Literal["low", "high"]
 
+type ContextManagerLikeRecipe[**P, T] = (
+    Callable[P, ContextManager[T]] | Callable[P, AsyncContextManager[T]]
+)
+type GeneratorRecipe[**P, T] = (
+    Callable[P, Generator[T, Any, Any]] | Callable[P, AsyncGenerator[T, Any]]
+)
+type Recipe[**P, T] = Callable[P, T] | Callable[P, Awaitable[T]]
+
 
 @dataclass(eq=False, frozen=True, slots=True)
 class Module(Broker, EventListener):
@@ -411,7 +421,7 @@ def __brokers(self) -> Iterator[Broker]:
 
     def injectable[**P, T](
         self,
-        wrapped: Callable[P, T] | Callable[P, Awaitable[T]] | None = None,
+        wrapped: Recipe[P, T] | None = None,
         /,
         *,
         cls: InjectableFactory[T] = SimpleInjectable,
@@ -420,9 +430,7 @@ def injectable[**P, T](
         on: TypeInfo[T] = (),
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Any:
-        def decorator(
-            wp: Callable[P, T] | Callable[P, Awaitable[T]],
-        ) -> Callable[P, T] | Callable[P, Awaitable[T]]:
+        def decorator(wp: Recipe[P, T]) -> Recipe[P, T]:
             factory = extract_caller(self.make_injected_function(wp) if inject else wp)
             hints = on if ignore_type_hint else (wp, on)
             updater = Updater(
@@ -447,23 +455,10 @@ def scoped[**P, T](
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Any:
         def decorator(
-            wrapped: Callable[P, T]
-            | Callable[P, Awaitable[T]]
-            | Callable[P, Iterator[T]]
-            | Callable[P, AsyncIterator[T]],
-        ) -> (
-            Callable[P, T]
-            | Callable[P, Awaitable[T]]
-            | Callable[P, Iterator[T]]
-            | Callable[P, AsyncIterator[T]]
-        ):
+            wrapped: Recipe[P, T] | GeneratorRecipe[P, T],
+        ) -> Recipe[P, T] | GeneratorRecipe[P, T]:
             injectable_class: Callable[[Caller[P, Any], str], Injectable[T]]
-            wrapper: (
-                Callable[P, T]
-                | Callable[P, Awaitable[T]]
-                | Callable[P, ContextManager[T]]
-                | Callable[P, AsyncContextManager[T]]
-            )
+            wrapper: Recipe[P, T] | ContextManagerLikeRecipe[P, T]
 
             if isasyncgenfunction(wrapped):
                 hint = get_yield_hint(wrapped)
@@ -588,6 +583,18 @@ def listen() -> None:
 
         return SyncInjectedFunction(metadata)
 
+    def make_async_factory[T](
+        self,
+        wrapped: type[T],
+        /,
+        threadsafe: bool = False,
+    ) -> Callable[..., Awaitable[T]]:
+        factory: InjectedFunction[..., T] = self.make_injected_function(
+            wrapped,
+            threadsafe,
+        )
+        return factory.__inject_metadata__.acall
+
     async def afind_instance[T](self, cls: InputType[T]) -> T:
         injectable = self[cls]
         return await injectable.aget_instance()

tests/core/test_module.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterator
+from dataclasses import dataclass
 from typing import Annotated
 
 import pytest
@@ -55,6 +56,27 @@ async def t_recipe() -> T:
         instance = module.get_instance(T)
         assert isinstance(instance, T)
 
+    """
+    make_async_factory
+    """
+
+    async def test_make_async_factory_with_success(self, module):
+        class Dependency: ...
+
+        @module.injectable
+        async def dependency_recipe() -> Dependency:
+            return Dependency()
+
+        @dataclass
+        class InnerClass:
+            dependency: Dependency
+
+        async_factory = module.make_async_factory(InnerClass)
+        instance = await async_factory()
+
+        assert isinstance(instance, InnerClass)
+        assert isinstance(instance.dependency, Dependency)
+
     """
     aget_instance
     """