python-cq 0.19.0__tar.gz → 0.21.0__tar.gz

{python_cq-0.19.0 → python_cq-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.19.0
+Version: 0.21.0
 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.19.0 → python_cq-0.21.0}/cq/__init__.py

@@ -16,11 +16,12 @@ from ._core.message import (
 from ._core.middleware import Middleware, MiddlewareResult, resolve_handler_source
 from ._core.pipetools import ContextCommandPipeline as _ContextCommandPipeline
 from ._core.pump import Pump
-from ._core.queues.abc import Consumer, Producer, Queue
+from ._core.queues.abc import Consumer, Delivery, Producer, Queue
 from ._core.queues.memory import MemoryQueue
 from ._core.related_events import AnyIORelatedEvents, RelatedEvents
 
 __all__ = (
+    "__cq__",
     "AnyCommandBus",
     "AnyIORelatedEvents",
     "Bus",
@@ -30,6 +31,7 @@ __all__ = (
     "Consumer",
     "ContextCommandPipeline",
     "ContextPipeline",
+    "Delivery",
     "DIAdapter",
     "Dispatcher",
     "Event",
@@ -54,30 +56,27 @@ __all__ = (
 )
 
 try:
-    from cq.ext.injection import InjectionAdapter as _InjectionAdapter
+    from .ext.injection import InjectionAdapter as _InjectionAdapter
 
 except ImportError:  # pragma: no cover
-    _default = CQ(_NoDI())
+    __cq__ = CQ(_NoDI())
 
 else:
-    _default = CQ(_InjectionAdapter())
+    __cq__ = CQ(_InjectionAdapter())
 
-_default.register_defaults()
+__cq__.register_defaults()
 
-command_handler = _default.command_handler
-event_handler = _default.event_handler
-query_handler = _default.query_handler
+command_handler = __cq__.command_handler
+event_handler = __cq__.event_handler
+query_handler = __cq__.query_handler
 
-new_command_bus = _default.new_command_bus
-new_event_bus = _default.new_event_bus
-new_query_bus = _default.new_query_bus
+new_command_bus = __cq__.new_command_bus
+new_event_bus = __cq__.new_event_bus
+new_query_bus = __cq__.new_query_bus
 
 
 class ContextCommandPipeline[C: Command](_ContextCommandPipeline[C]):
     __slots__ = ()
 
-    def __init__(self, di: DIAdapter = _default.di) -> None:
+    def __init__(self, di: DIAdapter = __cq__.di) -> None:
         super().__init__(di)
-
-
-del _default

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/cq.py

@@ -1,3 +1,4 @@
+from collections.abc import KeysView
 from typing import Any, Self
 
 from cq._core.di import DIAdapter
@@ -34,14 +35,26 @@ class CQ:
     def command_handler(self) -> HandlerDecorator[Command, Any]:
         return HandlerDecorator(self.__command_registry, self.__di)
 
+    @property
+    def command_types(self) -> KeysView[type[Command]]:
+        return self.__command_registry.message_types
+
     @property
     def event_handler(self) -> HandlerDecorator[Event, Any]:
         return HandlerDecorator(self.__event_registry, self.__di)
 
+    @property
+    def event_types(self) -> KeysView[type[Event]]:
+        return self.__event_registry.message_types
+
     @property
     def query_handler(self) -> HandlerDecorator[Query, Any]:
         return HandlerDecorator(self.__query_registry, self.__di)
 
+    @property
+    def query_types(self) -> KeysView[type[Query]]:
+        return self.__query_registry.message_types
+
     def new_command_bus(self) -> Bus[Command, Any]:
         bus = SimpleBus(self.__command_registry)
         command_middleware = CommandDispatchScopeMiddleware(self.__di)

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/dispatchers/abc.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from typing import Protocol, Self, runtime_checkable
 
-from cq._core.middleware import Middleware, MiddlewareGroup, deliver_message
+from cq._core.middleware import Middleware, MiddlewareGroup
 
 
 @runtime_checkable
@@ -29,16 +29,17 @@ class BaseDispatcher[I, O](Dispatcher[I, O], ABC):
         self.__middleware_group.add(*middlewares)
         return self
 
-    async def _deliver(
+    async def _invoke(
         self,
-        message: I,
         handler: Callable[[I], Awaitable[O]],
+        message: I,
         /,
         fail_silently: bool = False,
     ) -> O:
-        return await deliver_message(
-            message,
-            handler,
-            self.__middleware_group,
-            fail_silently,
-        )
+        try:
+            return await self.__middleware_group.invoke(handler, message)
+        except Exception:
+            if fail_silently:
+                return NotImplemented
+
+            raise

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/dispatchers/bus.py

@@ -83,7 +83,7 @@ class SimpleBus[I, O](BaseBus[I, O]):
             self._trigger_listeners(message, task_group)
 
         for handler in self._handlers_from(type(message)):
-            return await self._deliver(message, handler, handler.fail_silently)
+            return await self._invoke(handler, message, handler.fail_silently)
 
         return NotImplemented
 
@@ -100,8 +100,8 @@ class TaskBus[I](BaseBus[I, None]):
 
             for handler in self._handlers_from(type(message)):
                 task_group.start_soon(
-                    self._deliver,
-                    message,
+                    self._invoke,
                     handler,
+                    message,
                     handler.fail_silently,
                 )

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/dispatchers/pipe.py

@@ -140,7 +140,7 @@ class Pipe[I, O](BaseDispatcher[I, O]):
         return self
 
     async def dispatch(self, message: I, /) -> O:
-        return await self._deliver(message, self.__steps.execute)
+        return await self._invoke(self.__steps.execute, message)
 
 
 class ContextPipeline[I]:

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/handler.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 from collections import defaultdict
-from collections.abc import Awaitable, Callable, Iterator
+from collections.abc import Awaitable, Callable, Iterator, KeysView
 from dataclasses import dataclass, field
 from functools import partial
 from inspect import Parameter, isclass, unwrap
@@ -49,6 +49,11 @@ class HandleFunction[**P, T]:
 class HandlerRegistry[I, O](Protocol):
     __slots__ = ()
 
+    @property
+    @abstractmethod
+    def message_types(self) -> KeysView[type[I]]:
+        raise NotImplementedError
+
     @abstractmethod
     def handlers_from(self, message_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
         raise NotImplementedError
@@ -71,6 +76,10 @@ class MultipleHandlerRegistry[I, O](HandlerRegistry[I, O]):
         init=False,
     )
 
+    @property
+    def message_types(self) -> KeysView[type[I]]:
+        return self.__values.keys()
+
     def handlers_from(self, message_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
         for key_type in _iter_key_types(message_type):
             yield from self.__values.get(key_type, ())
@@ -97,6 +106,10 @@ class SingleHandlerRegistry[I, O](HandlerRegistry[I, O]):
         init=False,
     )
 
+    @property
+    def message_types(self) -> KeysView[type[I]]:
+        return self.__values.keys()
+
     def handlers_from(self, message_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
         for key_type in _iter_key_types(message_type):
             function = self.__values.get(key_type, None)

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/middleware.py

@@ -115,21 +115,6 @@ class _GeneratorMiddleware[**P, T]:
         return value
 
 
-async def deliver_message[I, O](
-    message: I,
-    handler: Callable[[I], Awaitable[O]],
-    middleware_group: MiddlewareGroup[[I], O],
-    fail_silently: bool = False,
-) -> O:
-    try:
-        return await middleware_group.invoke(handler, message)
-    except Exception:
-        if fail_silently:
-            return NotImplemented
-
-        raise
-
-
 def _is_gen_middleware[**P, T](
     middleware: Middleware[P, T],
 ) -> TypeGuard[GeneratorMiddleware[P, T]]:

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/pump.py

@@ -5,7 +5,7 @@ from typing import Any, Self
 
 import anyio
 
-from cq._core.middleware import Middleware, MiddlewareGroup, deliver_message
+from cq._core.middleware import Middleware, MiddlewareGroup
 from cq._core.queues.abc import Consumer
 
 
@@ -24,13 +24,13 @@ class Pump[T]:
         return self
 
     async def drain(self) -> None:
-        async for message in self.consumer:
-            await deliver_message(
-                message,
-                self.dispatcher,
-                self.__middleware_group,
-                self.fail_silently,
-            )
+        async for delivery in self.consumer:
+            try:
+                async with delivery as message:
+                    await self.__middleware_group.invoke(self.dispatcher, message)
+            except Exception:
+                if not self.fail_silently:
+                    raise
 
     @asynccontextmanager
     async def draining(

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/queues/abc.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
-from collections.abc import AsyncIterator
-from typing import Protocol, runtime_checkable
+from collections.abc import AsyncIterable
+from typing import AsyncContextManager, Protocol, runtime_checkable
 
 
 @runtime_checkable
@@ -16,12 +16,13 @@ class Producer[T](Protocol):
 
 
 @runtime_checkable
-class Consumer[T](Protocol):
+class Delivery[T](AsyncContextManager[T], Protocol):
     __slots__ = ()
 
-    @abstractmethod
-    def __aiter__(self) -> AsyncIterator[T]:
-        raise NotImplementedError
+
+@runtime_checkable
+class Consumer[T](AsyncIterable[Delivery[T]], Protocol):
+    __slots__ = ()
 
 
 @runtime_checkable

{python_cq-0.19.0 → python_cq-0.21.0}/cq/_core/queues/memory.py

@@ -1,5 +1,5 @@
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, nullcontext
 from types import TracebackType
 from typing import Any, Self
 
@@ -8,7 +8,7 @@ from anyio.abc import ObjectReceiveStream, ObjectSendStream
 
 from cq._core.middleware import Middleware
 from cq._core.pump import Pump
-from cq._core.queues.abc import Queue
+from cq._core.queues.abc import Delivery, Queue
 
 
 class MemoryQueue[T](Queue[T]):
@@ -31,8 +31,9 @@ class MemoryQueue[T](Queue[T]):
     ) -> None:
         await self.close()
 
-    def __aiter__(self) -> AsyncIterator[T]:
-        return aiter(self.__consumer)
+    async def __aiter__(self) -> AsyncIterator[Delivery[T]]:
+        async for message in self.__consumer:
+            yield nullcontext(message)
 
     async def close(self) -> None:
         await self.__producer.aclose()

{python_cq-0.19.0 → python_cq-0.21.0}/pyproject.toml

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