feat: ✨ Support for async dependencies

Author: remimd

Makefile

@@ -1,17 +1,18 @@
-before_commit: check lint mypy pytest
-
-check:
-	poetry check
+before_commit: lint mypy pytest
 
 install:
-	poetry install --sync
+	uv sync
+
+upgrade:
+	uv lock --upgrade
+	uv sync
 
 lint:
-	ruff format
-	ruff check --fix
+	uv run ruff format
+	uv run ruff check --fix
 
 mypy:
-	mypy ./
+	uv run mypy ./
 
 pytest:
-	pytest
+	uv run pytest

cq/_core/dispatcher/bus.py

@@ -12,7 +12,7 @@
 from cq._core.dispatcher.base import BaseDispatcher, Dispatcher
 
 type HandlerType[**P, T] = type[Handler[P, T]]
-type HandlerFactory[**P, T] = Callable[..., Handler[P, T]]
+type HandlerFactory[**P, T] = Callable[..., Awaitable[Handler[P, T]]]
 
 type Listener[T] = Callable[[T], Awaitable[Any]]
 
@@ -46,24 +46,27 @@ class SubscriberDecorator[I, O]:
     bus_type: BusType[I, O] | TypeAliasType | GenericAlias
     injection_module: injection.Module = field(default_factory=injection.mod)
 
-    def __call__(self, first_input_type: type[I], /, *input_types: type[I]):  # type: ignore[no-untyped-def]
-        def decorator(wrapped):  # type: ignore[no-untyped-def]
+    def __call__(self, first_input_type: type[I], /, *input_types: type[I]) -> Any:
+        def decorator(wrapped: type[Handler[[I], O]]) -> type[Handler[[I], O]]:
             if not isclass(wrapped) or not issubclass(wrapped, Handler):
                 raise TypeError(f"`{wrapped}` isn't a valid handler.")
 
-            bus = self.__find_bus()
-            factory = self.injection_module.make_injected_function(wrapped)
+            bus = self.injection_module.find_instance(self.bus_type)
+            lazy_instance = self.injection_module.aget_lazy_instance(
+                wrapped,
+                default=NotImplemented,
+            )
+
+            async def getter() -> Handler[[I], O]:
+                return await lazy_instance
 
             for input_type in (first_input_type, *input_types):
-                bus.subscribe(input_type, factory)
+                bus.subscribe(input_type, getter)
 
-            return wrapped
+            return self.injection_module.injectable(wrapped)
 
         return decorator
 
-    def __find_bus(self) -> Bus[I, O]:
-        return self.injection_module.find_instance(self.bus_type)
-
 
 class BaseBus[I, O](BaseDispatcher[I, O], Bus[I, O], ABC):
     __slots__ = ("__listeners",)
@@ -100,10 +103,8 @@ async def dispatch(self, input_value: I, /) -> O:
         except KeyError:
             return NotImplemented
 
-        return await self._invoke_with_middlewares(
-            handler_factory().handle,
-            input_value,
-        )
+        handler = await handler_factory()
+        return await self._invoke_with_middlewares(handler.handle, input_value)
 
     def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
         if input_type in self.__handlers:
@@ -132,13 +133,13 @@ async def dispatch(self, input_value: I, /) -> None:
             return
 
         await asyncio.gather(
-            *(
+            *[
                 self._invoke_with_middlewares(
-                    handler_factory().handle,
+                    (await handler_factory()).handle,
                     input_value,
                 )
                 for handler_factory in handler_factories
-            )
+            ]
         )
 
     def subscribe(

tests/core/dispatcher/test_bus.py

@@ -1,5 +1,5 @@
 from asyncio import all_tasks, get_running_loop
-from typing import Any
+from typing import Any, Self
 
 import pytest
 from injection import Module as InjectionModule
@@ -19,22 +19,22 @@ async def middleware(input_value: Any, /) -> MiddlewareResult[Any]:
         assert bus.add_middlewares(middleware) is bus
 
     def test_subscribe_with_success_return_self(self, bus: SimpleBus[Any, Any]) -> None:
-        assert bus.subscribe(str, _SomeHandler) is bus
+        assert bus.subscribe(str, _SomeHandler.async_factory) is bus
 
     def test_subscribe_with_already_subscribed_raise_runtime_error(
         self,
         bus: SimpleBus[Any, Any],
     ) -> None:
-        assert bus.subscribe(str, _SomeHandler) is bus
+        assert bus.subscribe(str, _SomeHandler.async_factory) is bus
 
         with pytest.raises(RuntimeError):
-            bus.subscribe(str, _SomeHandler)
+            bus.subscribe(str, _SomeHandler.async_factory)
 
     async def test_dispatch_with_success_return_any(
         self,
         bus: SimpleBus[Any, str],
     ) -> None:
-        bus.subscribe(str, _SomeHandler)
+        bus.subscribe(str, _SomeHandler.async_factory)
         input_value = "hello"
         assert await bus.dispatch(input_value) == f"|{input_value}|"
 
@@ -107,15 +107,15 @@ def task_bus(self) -> TaskBus[Any]:
         return TaskBus()
 
     def test_subscribe_with_success_return_self(self, task_bus: TaskBus[Any]) -> None:
-        assert task_bus.subscribe(str, _SomeTaskHandler) is task_bus
+        assert task_bus.subscribe(str, _SomeTaskHandler.async_factory) is task_bus
         # Checks whether several handlers can be subscribed for the same input type
-        assert task_bus.subscribe(str, _SomeTaskHandler) is task_bus
+        assert task_bus.subscribe(str, _SomeTaskHandler.async_factory) is task_bus
 
     async def test_dispatch_with_success_return_none(
         self,
         task_bus: TaskBus[Any],
     ) -> None:
-        task_bus.subscribe(str, _SomeTaskHandler)
+        task_bus.subscribe(str, _SomeTaskHandler.async_factory)
 
         with pytest.raises(NotImplementedError):
             await task_bus.dispatch("hello")
@@ -132,7 +132,15 @@ class _SomeHandler:
     async def handle(self, input_value: str, /) -> str:
         return f"|{input_value}|"
 
+    @classmethod
+    async def async_factory(cls) -> Self:
+        return cls()
+
 
 class _SomeTaskHandler:
     async def handle(self, input_value: Any, /) -> None:
         raise NotImplementedError
+
+    @classmethod
+    async def async_factory(cls) -> Self:
+        return cls()

tests/core/dispatcher/test_pipe.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Self
 
 from cq import Bus, Pipe
 from cq._core.dispatcher.bus import SimpleBus
@@ -10,19 +10,31 @@ class StringLengthHandler:
             async def handle(self, input_value: str) -> int:
                 return len(input_value)
 
+            @classmethod
+            async def async_factory(cls) -> Self:
+                return cls()
+
         class UniformStringHandler:
             def __init__(self, char: str) -> None:
                 self.char = char
 
             async def handle(self, input_value: int) -> str:
                 return self.char * input_value
 
+            @classmethod
+            async def async_factory(cls, char: str) -> Self:
+                return cls(char)
+
         class ToTupleHandler:
             async def handle(self, input_value: str) -> tuple[str, ...]:
                 return tuple(input_value)
 
-        bus.subscribe(str, StringLengthHandler)
-        bus.subscribe(int, lambda: UniformStringHandler("*"))
+            @classmethod
+            async def async_factory(cls) -> Self:
+                return cls()
+
+        bus.subscribe(str, StringLengthHandler.async_factory)
+        bus.subscribe(int, lambda: UniformStringHandler.async_factory("*"))
 
         pipe: Pipe[str, str | tuple[str, ...]] = Pipe(bus)
 
@@ -35,7 +47,7 @@ async def step_converter_1(length: int) -> int:
         # Custom dispatcher
         other_bus: Bus[Any, Any] = SimpleBus()
 
-        other_bus.subscribe(str, ToTupleHandler)
+        other_bus.subscribe(str, ToTupleHandler.async_factory)
 
         @pipe.step(dispatcher=other_bus)
         async def step_converter_2(hidden_string: str) -> str:

tests/middlewares/test_retry.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Self
 
 import pytest
 
@@ -17,8 +17,12 @@ class SomeHandler:
             async def handle(self, input_value: str) -> str:
                 return input_value
 
+            @classmethod
+            async def async_factory(cls) -> Self:
+                return cls()
+
         bus.add_middlewares(RetryMiddleware(3), history)
-        bus.subscribe(str, SomeHandler)
+        bus.subscribe(str, SomeHandler.async_factory)
 
         await bus.dispatch("Hello world!")
         assert len(history.records) == 1
@@ -32,9 +36,13 @@ class SomeHandler:
             async def handle(self, input_value: str) -> None:
                 raise ValueError(input_value)
 
+            @classmethod
+            async def async_factory(cls) -> Self:
+                return cls()
+
         retry = 3
         bus.add_middlewares(RetryMiddleware(retry), history)
-        bus.subscribe(str, SomeHandler)
+        bus.subscribe(str, SomeHandler.async_factory)
 
         with pytest.raises(ValueError):
             await bus.dispatch("Hello world!")