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

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

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

@@ -16,7 +16,7 @@ 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
 
@@ -30,6 +30,7 @@ __all__ = (
     "Consumer",
     "ContextCommandPipeline",
     "ContextPipeline",
+    "Delivery",
     "DIAdapter",
     "Dispatcher",
     "Event",

{python_cq-0.19.0 → python_cq-0.20.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.20.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.20.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.20.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.20.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.20.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.20.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.20.0}/pyproject.toml

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