python-cq 0.15.0__tar.gz → 0.15.2__tar.gz

{python_cq-0.15.0 → python_cq-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.15.0
+Version: 0.15.2
 Summary: CQRS library for async Python projects.
 Project-URL: Documentation, https://python-cq.remimd.dev
 Project-URL: Repository, https://github.com/100nm/python-cq

{python_cq-0.15.0 → python_cq-0.15.2}/cq/__init__.py

@@ -17,7 +17,7 @@ from ._core.message import (
     new_query_bus,
     query_handler,
 )
-from ._core.middleware import Middleware, MiddlewareResult
+from ._core.middleware import Middleware, MiddlewareResult, resolve_handler_source
 from ._core.pipetools import ContextCommandPipeline
 from ._core.related_events import RelatedEvents
 from ._core.scope import CQScope
@@ -47,4 +47,5 @@ __all__ = (
     "new_event_bus",
     "new_query_bus",
     "query_handler",
+    "resolve_handler_source",
 )

{python_cq-0.15.0 → python_cq-0.15.2}/cq/_core/dispatcher/bus.py

@@ -31,7 +31,12 @@ class Bus[I, O](Dispatcher[I, O], Protocol):
         raise NotImplementedError
 
     @abstractmethod
-    def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
+    def subscribe(
+        self,
+        input_type: type[I],
+        factory: HandlerFactory[[I], O],
+        fail_silently: bool = ...,
+    ) -> Self:
         raise NotImplementedError
 
 
@@ -50,8 +55,13 @@ class BaseBus[I, O](BaseDispatcher[I, O], Bus[I, O], ABC):
         self.__listeners.extend(listeners)
         return self
 
-    def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
-        self.__registry.subscribe(input_type, factory)
+    def subscribe(
+        self,
+        input_type: type[I],
+        factory: HandlerFactory[[I], O],
+        fail_silently: bool = False,
+    ) -> Self:
+        self.__registry.subscribe(input_type, factory, fail_silently=fail_silently)
         return self
 
     def _handlers_from(self, input_type: type[I]) -> Iterator[HandleFunction[[I], O]]:

{python_cq-0.15.0 → python_cq-0.15.2}/cq/_core/dispatcher/pipe.py

@@ -152,25 +152,30 @@ class ContextPipeline[I]:
     if TYPE_CHECKING:  # pragma: no cover
 
         @overload
-        def __get__[O](self, instance: None, owner: type[O], /) -> Dispatcher[I, O]: ...
+        def __get__[Context](
+            self,
+            instance: None,
+            owner: type[Context],
+            /,
+        ) -> Dispatcher[I, Context]: ...
 
         @overload
-        def __get__[O](
+        def __get__[Context](
             self,
-            instance: O,
-            owner: type[O] | None = ...,
+            instance: Context,
+            owner: type[Context] | None = ...,
             /,
-        ) -> Dispatcher[I, O]: ...
+        ) -> Dispatcher[I, Context]: ...
 
         @overload
         def __get__(self, instance: None = ..., owner: None = ..., /) -> Self: ...
 
-    def __get__[O](
+    def __get__[Context](
         self,
-        instance: O | None = None,
-        owner: type[O] | None = None,
+        instance: Context | None = None,
+        owner: type[Context] | None = None,
         /,
-    ) -> Self | Dispatcher[I, O]:
+    ) -> Self | Dispatcher[I, Context]:
         if instance is None:
             if owner is None:
                 return self
@@ -231,19 +236,19 @@ class ContextPipeline[I]:
 
         return decorator(wrapped) if wrapped else decorator
 
-    async def __execute[O](
+    async def __execute[Context](
         self,
         input_value: I,
         /,
         *,
-        context: O,
-        context_type: type[O] | None,
-    ) -> O:
-        await self.__middleware_group.invoke(
-            lambda i: self.__steps.execute(i, context, context_type),
-            input_value,
-        )
-        return context
+        context: Context,
+        context_type: type[Context] | None,
+    ) -> Context:
+        async def handler(i: I, /) -> Context:
+            await self.__steps.execute(i, context, context_type)
+            return context
+
+        return await self.__middleware_group.invoke(handler, input_value)
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

{python_cq-0.15.0 → python_cq-0.15.2}/cq/_core/handler.py

@@ -3,7 +3,7 @@ from collections import defaultdict
 from collections.abc import Awaitable, Callable, Iterator
 from dataclasses import dataclass, field
 from functools import partial
-from inspect import Parameter, isclass
+from inspect import Parameter, isclass, unwrap
 from inspect import signature as inspect_signature
 from typing import TYPE_CHECKING, Any, Protocol, Self, overload, runtime_checkable
 
@@ -27,14 +27,23 @@ class Handler[**P, T](Protocol):
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class HandleFunction[**P, T]:
-    handler_factory: HandlerFactory[P, T]
-    handler_type: HandlerType[P, T] | None = field(default=None)
-    fail_silently: bool = field(default=False)
+    factory: HandlerFactory[P, T]
+    source: HandlerType[P, T] | Any
+    fail_silently: bool
 
     async def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        handler = await self.handler_factory()
+        handler = await self.factory()
         return await handler.handle(*args, **kwargs)
 
+    @classmethod
+    def create(
+        cls,
+        factory: HandlerFactory[P, T],
+        source: HandlerType[P, T] | None = None,
+        fail_silently: bool = False,
+    ) -> Self:
+        return cls(factory, source or unwrap(factory), fail_silently)
+
 
 @runtime_checkable
 class HandlerRegistry[I, O](Protocol):
@@ -73,7 +82,7 @@ class MultipleHandlerRegistry[I, O](HandlerRegistry[I, O]):
         handler_type: HandlerType[[I], O] | None = None,
         fail_silently: bool = False,
     ) -> Self:
-        function = HandleFunction(handler_factory, handler_type, fail_silently)
+        function = HandleFunction.create(handler_factory, handler_type, fail_silently)
 
         for key_type in _build_key_types(input_type):
             self.__values[key_type].append(function)
@@ -101,7 +110,7 @@ class SingleHandlerRegistry[I, O](HandlerRegistry[I, O]):
         handler_type: HandlerType[[I], O] | None = None,
         fail_silently: bool = False,
     ) -> Self:
-        function = HandleFunction(handler_factory, handler_type, fail_silently)
+        function = HandleFunction.create(handler_factory, handler_type, fail_silently)
         entries = {key_type: function for key_type in _build_key_types(input_type)}
 
         for key_type in entries:

{python_cq-0.15.0 → python_cq-0.15.2}/cq/_core/middleware.py

@@ -1,8 +1,9 @@
 from collections.abc import AsyncGenerator, Awaitable, Callable
 from dataclasses import dataclass, field
 from inspect import isasyncgenfunction
-from typing import Concatenate, Self, TypeGuard
+from typing import Any, Concatenate, Self, TypeGuard
 
+from cq._core.handler import HandleFunction, HandlerType
 from cq.exceptions import MiddlewareError
 
 type MiddlewareResult[T] = AsyncGenerator[None, T]
@@ -63,6 +64,19 @@ class _BoundMiddleware[**P, T]:
         return await self.middleware(self.call_next, *args, **kwargs)
 
 
+def resolve_handler_source[**P, T](
+    call_next: Callable[P, Awaitable[T]]
+    | _BoundMiddleware[P, T]
+    | HandleFunction[P, T],
+    /,
+) -> HandlerType[P, T] | Any:
+    while True:
+        try:
+            call_next = call_next.call_next  # type: ignore[union-attr]
+        except AttributeError:
+            return call_next.source  # type: ignore[union-attr]
+
+
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class _GeneratorMiddleware[**P, T]:
     middleware: GeneratorMiddleware[P, T]

{python_cq-0.15.0 → python_cq-0.15.2}/pyproject.toml

@@ -22,7 +22,7 @@ test = [
 
 [project]
 name = "python-cq"
-version = "0.15.0"
+version = "0.15.2"
 description = "CQRS library for async Python projects."
 license = "MIT"
 license-files = ["LICENSE"]