python-cq 0.14.1__tar.gz → 0.15.1__tar.gz

{python_cq-0.14.1 → python_cq-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.14.1
+Version: 0.15.1
 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.14.1 → python_cq-0.15.1}/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.14.1 → python_cq-0.15.1}/cq/_core/dispatcher/base.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
+from contextlib import AsyncExitStack, suppress
 from typing import Protocol, Self, runtime_checkable
 
 from cq._core.middleware import Middleware, MiddlewareGroup
@@ -40,5 +41,12 @@ class BaseDispatcher[I, O](Dispatcher[I, O], ABC):
         handler: Callable[[I], Awaitable[O]],
         input_value: I,
         /,
+        fail_silently: bool = False,
     ) -> O:
-        return await self.__middleware_group.invoke(handler, input_value)
+        async with AsyncExitStack() as stack:
+            if fail_silently:
+                stack.enter_context(suppress(Exception))
+
+            return await self.__middleware_group.invoke(handler, input_value)
+
+        return NotImplemented

{python_cq-0.14.1 → python_cq-0.15.1}/cq/_core/dispatcher/bus.py

@@ -7,6 +7,7 @@ from anyio.abc import TaskGroup
 
 from cq._core.dispatcher.base import BaseDispatcher, Dispatcher
 from cq._core.handler import (
+    HandleFunction,
     HandlerFactory,
     HandlerRegistry,
     MultipleHandlerRegistry,
@@ -30,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
 
 
@@ -49,14 +55,16 @@ 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)
-        return self
-
-    def _handlers_from(
+    def subscribe(
         self,
         input_type: type[I],
-    ) -> Iterator[Callable[[I], Awaitable[O]]]:
+        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]]:
         return self.__registry.handlers_from(input_type)
 
     def _trigger_listeners(self, input_value: I, /, task_group: TaskGroup) -> None:
@@ -75,7 +83,11 @@ class SimpleBus[I, O](BaseBus[I, O]):
             self._trigger_listeners(input_value, task_group)
 
         for handler in self._handlers_from(type(input_value)):
-            return await self._invoke_with_middlewares(handler, input_value)
+            return await self._invoke_with_middlewares(
+                handler,
+                input_value,
+                handler.fail_silently,
+            )
 
         return NotImplemented
 
@@ -95,4 +107,5 @@ class TaskBus[I](BaseBus[I, None]):
                     self._invoke_with_middlewares,
                     handler,
                     input_value,
+                    handler.fail_silently,
                 )

{python_cq-0.14.1 → python_cq-0.15.1}/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
 
@@ -21,74 +21,105 @@ class Handler[**P, T](Protocol):
     __slots__ = ()
 
     @abstractmethod
-    async def handle(self, *args: P.args, **kwargs: P.kwargs) -> T:
+    async def handle(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
         raise NotImplementedError
 
 
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class HandleFunction[**P, T]:
+    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.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):
     __slots__ = ()
 
     @abstractmethod
-    def handlers_from(
-        self,
-        input_type: type[I],
-    ) -> Iterator[Callable[[I], Awaitable[O]]]:
+    def handlers_from(self, input_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
         raise NotImplementedError
 
     @abstractmethod
-    def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
+    def subscribe(
+        self,
+        input_type: type[I],
+        handler_factory: HandlerFactory[[I], O],
+        handler_type: HandlerType[[I], O] | None = ...,
+        fail_silently: bool = ...,
+    ) -> Self:
         raise NotImplementedError
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class MultipleHandlerRegistry[I, O](HandlerRegistry[I, O]):
-    __factories: dict[type[I], list[HandlerFactory[[I], O]]] = field(
+    __values: dict[type[I], list[HandleFunction[[I], O]]] = field(
         default_factory=partial(defaultdict, list),
         init=False,
     )
 
-    def handlers_from(
+    def handlers_from(self, input_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
+        for key_type in _iter_key_types(input_type):
+            yield from self.__values.get(key_type, ())
+
+    def subscribe(
         self,
         input_type: type[I],
-    ) -> Iterator[Callable[[I], Awaitable[O]]]:
-        for key_type in _iter_key_types(input_type):
-            for factory in self.__factories.get(key_type, ()):
-                yield _make_handle_function(factory)
+        handler_factory: HandlerFactory[[I], O],
+        handler_type: HandlerType[[I], O] | None = None,
+        fail_silently: bool = False,
+    ) -> Self:
+        function = HandleFunction.create(handler_factory, handler_type, fail_silently)
 
-    def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
         for key_type in _build_key_types(input_type):
-            self.__factories[key_type].append(factory)
+            self.__values[key_type].append(function)
 
         return self
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class SingleHandlerRegistry[I, O](HandlerRegistry[I, O]):
-    __factories: dict[type[I], HandlerFactory[[I], O]] = field(
+    __values: dict[type[I], HandleFunction[[I], O]] = field(
         default_factory=dict,
         init=False,
     )
 
-    def handlers_from(
-        self,
-        input_type: type[I],
-    ) -> Iterator[Callable[[I], Awaitable[O]]]:
+    def handlers_from(self, input_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
         for key_type in _iter_key_types(input_type):
-            factory = self.__factories.get(key_type, None)
-            if factory is not None:
-                yield _make_handle_function(factory)
+            function = self.__values.get(key_type, None)
+            if function is not None:
+                yield function
 
-    def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
-        entries = {key_type: factory for key_type in _build_key_types(input_type)}
+    def subscribe(
+        self,
+        input_type: type[I],
+        handler_factory: HandlerFactory[[I], O],
+        handler_type: HandlerType[[I], O] | None = None,
+        fail_silently: bool = False,
+    ) -> Self:
+        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:
-            if key_type in self.__factories:
+            if key_type in self.__values:
                 raise RuntimeError(
                     f"A handler is already registered for the input type: `{key_type}`."
                 )
 
-        self.__factories.update(entries)
+        self.__values.update(entries)
         return self
 
 
@@ -105,6 +136,7 @@ class HandlerDecorator[I, O]:
             input_or_handler_type: type[I],
             /,
             *,
+            fail_silently: bool = ...,
             threadsafe: bool | None = ...,
         ) -> Decorator: ...
 
@@ -114,6 +146,7 @@ class HandlerDecorator[I, O]:
             input_or_handler_type: T,
             /,
             *,
+            fail_silently: bool = ...,
             threadsafe: bool | None = ...,
         ) -> T: ...
 
@@ -123,6 +156,7 @@ class HandlerDecorator[I, O]:
             input_or_handler_type: None = ...,
             /,
             *,
+            fail_silently: bool = ...,
             threadsafe: bool | None = ...,
         ) -> Decorator: ...
 
@@ -131,6 +165,7 @@ class HandlerDecorator[I, O]:
         input_or_handler_type: type[I] | T | None = None,
         /,
         *,
+        fail_silently: bool = False,
         threadsafe: bool | None = None,
     ) -> Any:
         if (
@@ -138,11 +173,16 @@ class HandlerDecorator[I, O]:
             and isclass(input_or_handler_type)
             and issubclass(input_or_handler_type, Handler)
         ):
-            return self.__decorator(input_or_handler_type, threadsafe=threadsafe)
+            return self.__decorator(
+                input_or_handler_type,
+                fail_silently=fail_silently,
+                threadsafe=threadsafe,
+            )
 
         return partial(
             self.__decorator,
             input_type=input_or_handler_type,  # type: ignore[arg-type]
+            fail_silently=fail_silently,
             threadsafe=threadsafe,
         )
 
@@ -152,11 +192,12 @@ class HandlerDecorator[I, O]:
         /,
         *,
         input_type: type[I] | None = None,
+        fail_silently: bool = False,
         threadsafe: bool | None = None,
     ) -> HandlerType[[I], O]:
         factory = self.injection_module.make_async_factory(wrapped, threadsafe)
         input_type = input_type or _resolve_input_type(wrapped)
-        self.registry.subscribe(input_type, factory)
+        self.registry.subscribe(input_type, factory, wrapped, fail_silently)
         return wrapped
 
 
@@ -190,14 +231,3 @@ def _resolve_input_type[I, O](handler_type: HandlerType[[I], O]) -> type[I]:
         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](
-    factory: HandlerFactory[[I], O],
-) -> Callable[[I], Awaitable[O]]:
-    return partial(__handle, factory=factory)
-
-
-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.14.1 → python_cq-0.15.1}/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.14.1 → python_cq-0.15.1}/cq/middlewares/retry.py

@@ -25,7 +25,7 @@ class RetryMiddleware:
         self.__exceptions = tuple(exceptions)
         self.__retry = retry
 
-    async def __call__(self, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
+    async def __call__(self, /, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
         retry = self.__retry
 
         for attempt in range(1, retry + 1):

{python_cq-0.14.1 → python_cq-0.15.1}/cq/middlewares/scope.py

@@ -19,7 +19,7 @@ class InjectionScopeMiddleware:
     exist_ok: bool = field(default=False, kw_only=True)
     threadsafe: bool | None = field(default=None, kw_only=True)
 
-    async def __call__(self, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
+    async def __call__(self, /, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
         async with AsyncExitStack() as stack:
             try:
                 await stack.enter_async_context(

{python_cq-0.14.1 → python_cq-0.15.1}/pyproject.toml

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