python-cq 0.6.0__tar.gz → 0.7.0__tar.gz

{python_cq-0.6.0 → python_cq-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.6.0
+Version: 0.7.0
 Summary: Lightweight CQRS library.
 Project-URL: Repository, https://github.com/100nm/python-cq
 Author: remimd

{python_cq-0.6.0 → python_cq-0.7.0}/cq/_core/handler.py

@@ -3,7 +3,8 @@ from collections import defaultdict
 from collections.abc import Awaitable, Callable, Iterator
 from dataclasses import dataclass, field
 from functools import partial
-from inspect import getmro, isclass
+from inspect import Parameter, getmro, isclass
+from inspect import signature as inspect_signature
 from typing import Any, Protocol, Self, runtime_checkable
 
 import injection
@@ -88,16 +89,50 @@ class HandlerDecorator[I, O]:
     manager: HandlerManager[I, O]
     injection_module: injection.Module = field(default_factory=injection.mod)
 
-    def __call__(self, input_type: 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.")
+    def __call__(
+        self,
+        input_or_handler_type: type[I] | HandlerType[[I], O] | None = None,
+        /,
+    ) -> Any:
+        if input_or_handler_type is None:
+            return self.__decorator
+
+        elif isclass(input_or_handler_type) and issubclass(
+            input_or_handler_type,
+            Handler,
+        ):
+            return self.__decorator(input_or_handler_type)
+
+        return partial(self.__decorator, input_type=input_or_handler_type)  # type: ignore[arg-type]
+
+    def __decorator(
+        self,
+        wrapped: HandlerType[[I], O],
+        *,
+        input_type: type[I] | None = None,
+    ) -> HandlerType[[I], O]:
+        factory = self.injection_module.make_async_factory(wrapped)
+        input_type = input_type or _resolve_input_type(wrapped)
+        self.manager.subscribe(input_type, factory)
+        return wrapped
 
-            factory = self.injection_module.make_async_factory(wrapped)
-            self.manager.subscribe(input_type, factory)
-            return wrapped
 
-        return decorator
+def _resolve_input_type[I, O](handler_type: HandlerType[[I], O]) -> type[I]:
+    fake_handle_method = handler_type.handle.__get__(NotImplemented)
+    signature = inspect_signature(fake_handle_method, eval_str=True)
+
+    for parameter in signature.parameters.values():
+        input_type = parameter.annotation
+
+        if input_type is Parameter.empty:
+            break
+
+        return input_type
+
+    raise TypeError(
+        f"Unable to resolve input type for handler `{handler_type}`, "
+        "`handle` method must have a type annotation for its first parameter."
+    )
 
 
 def _make_handle_function[I, O](
@@ -106,6 +141,6 @@ def _make_handle_function[I, O](
     return partial(__handle, factory=factory)
 
 
-async def __handle[I, O](input_value: I, factory: HandlerFactory[[I], O]) -> O:
+async def __handle[I, O](input_value: I, *, factory: HandlerFactory[[I], O]) -> O:
     handler = await factory()
     return await handler.handle(input_value)

{python_cq-0.6.0 → python_cq-0.7.0}/cq/_core/message.py

@@ -33,31 +33,22 @@ query_handler: HandlerDecorator[Query, Any] = HandlerDecorator(
 )
 
 
-@injection.singleton(
-    on=CommandBus,
-    ignore_type_hint=True,  # type: ignore[call-arg]
-    inject=False,
-    mode="fallback",
-)
-def new_command_bus[T]() -> CommandBus[T]:
+@injection.singleton(inject=False, mode="fallback")
+def new_command_bus() -> CommandBus:  # type: ignore[type-arg]
     bus = SimpleBus(command_handler.manager)
-    bus.add_middlewares(InjectionScopeMiddleware(CQScope.ON_COMMAND))
+    transaction_scope_middleware = InjectionScopeMiddleware(
+        CQScope.TRANSACTION,
+        exist_ok=True,
+    )
+    bus.add_middlewares(transaction_scope_middleware)
     return bus
 
 
-@injection.singleton(
-    inject=False,
-    mode="fallback",
-)
+@injection.singleton(inject=False, mode="fallback")
 def new_event_bus() -> EventBus:
     return TaskBus(event_handler.manager)
 
 
-@injection.singleton(
-    on=QueryBus,
-    ignore_type_hint=True,  # type: ignore[call-arg]
-    inject=False,
-    mode="fallback",
-)
-def new_query_bus[T]() -> QueryBus[T]:
+@injection.singleton(inject=False, mode="fallback")
+def new_query_bus() -> QueryBus:  # type: ignore[type-arg]
     return SimpleBus(query_handler.manager)

{python_cq-0.6.0 → python_cq-0.7.0}/cq/_core/related_events.py

@@ -23,18 +23,20 @@ class RelatedEvents(Protocol):
 class SimpleRelatedEvents(RelatedEvents):
     items: list[Event] = field(default_factory=list)
 
+    def __bool__(self) -> bool:
+        return bool(self.items)
+
     def add(self, *events: Event) -> None:
         self.items.extend(events)
 
 
-@injection.scoped(CQScope.ON_COMMAND, mode="fallback")
+@injection.scoped(CQScope.TRANSACTION, mode="fallback")
 async def related_events_recipe(event_bus: EventBus) -> AsyncIterator[RelatedEvents]:
     yield (instance := SimpleRelatedEvents())
-    events = instance.items
 
-    if not events:
+    if not instance:
         return
 
     async with anyio.create_task_group() as task_group:
-        for event in events:
+        for event in instance.items:
             task_group.start_soon(event_bus.dispatch, event)

{python_cq-0.6.0 → python_cq-0.7.0}/cq/_core/scope.py

@@ -2,4 +2,4 @@ from enum import StrEnum, auto
 
 
 class CQScope(StrEnum):
-    ON_COMMAND = auto()
+    TRANSACTION = auto()

{python_cq-0.6.0 → python_cq-0.7.0}/cq/middlewares/retry.py

@@ -1,4 +1,4 @@
-from collections.abc import Iterable
+from collections.abc import Sequence
 from typing import Any
 
 import anyio
@@ -19,7 +19,7 @@ class RetryMiddleware:
         self,
         retry: int,
         delay: float = 0,
-        exceptions: Iterable[type[BaseException]] = (Exception,),
+        exceptions: Sequence[type[BaseException]] = (Exception,),
     ) -> None:
         self.__delay = delay
         self.__exceptions = tuple(exceptions)
@@ -32,9 +32,9 @@ class RetryMiddleware:
             try:
                 yield
 
-            except self.__exceptions as exc:
+            except self.__exceptions:
                 if attempt == retry:
-                    raise exc
+                    raise
 
             else:
                 break

python_cq-0.7.0/cq/middlewares/scope.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from contextlib import AsyncExitStack
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from injection import adefine_scope
+from injection.exceptions import ScopeAlreadyDefinedError
+
+if TYPE_CHECKING:  # pragma: no cover
+    from cq import MiddlewareResult
+
+__all__ = ("InjectionScopeMiddleware",)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class InjectionScopeMiddleware:
+    scope_name: str
+    exist_ok: bool = field(default=False, kw_only=True)
+
+    async def __call__(self, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
+        async with AsyncExitStack() as stack:
+            try:
+                await stack.enter_async_context(
+                    adefine_scope(self.scope_name),
+                )
+
+            except ScopeAlreadyDefinedError:
+                if not self.exist_ok:
+                    raise
+
+            yield

{python_cq-0.6.0 → python_cq-0.7.0}/pyproject.toml

@@ -11,6 +11,7 @@ dev = [
 example = [
     "fastapi",
     "msgspec",
+    "pydantic",
 ]
 test = [
     "pytest",
@@ -20,7 +21,7 @@ test = [
 
 [project]
 name = "python-cq"
-version = "0.6.0"
+version = "0.7.0"
 description = "Lightweight CQRS library."
 license = { text = "MIT" }
 readme = "README.md"

python_cq-0.6.0/cq/middlewares/scope.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from injection import adefine_scope
-
-if TYPE_CHECKING:  # pragma: no cover
-    from cq import MiddlewareResult
-
-__all__ = ("InjectionScopeMiddleware",)
-
-
-class InjectionScopeMiddleware:
-    __slots__ = ("__scope_name",)
-
-    __scope_name: str
-
-    def __init__(self, scope_name: str) -> None:
-        self.__scope_name = scope_name
-
-    async def __call__(self, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
-        async with adefine_scope(self.__scope_name):
-            yield