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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.18.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.18.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.18.0 → python_cq-0.20.0}/cq/_core/dispatchers/abc.py

@@ -29,7 +29,7 @@ class BaseDispatcher[I, O](Dispatcher[I, O], ABC):
         self.__middleware_group.add(*middlewares)
         return self
 
-    async def _invoke_with_middlewares(
+    async def _invoke(
         self,
         handler: Callable[[I], Awaitable[O]],
         message: I,

{python_cq-0.18.0 → python_cq-0.20.0}/cq/_core/dispatchers/bus.py

@@ -83,11 +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._invoke_with_middlewares(
-                handler,
-                message,
-                handler.fail_silently,
-            )
+            return await self._invoke(handler, message, handler.fail_silently)
 
         return NotImplemented
 
@@ -104,7 +100,7 @@ class TaskBus[I](BaseBus[I, None]):
 
             for handler in self._handlers_from(type(message)):
                 task_group.start_soon(
-                    self._invoke_with_middlewares,
+                    self._invoke,
                     handler,
                     message,
                     handler.fail_silently,

{python_cq-0.18.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._invoke_with_middlewares(self.__steps.execute, message)
+        return await self._invoke(self.__steps.execute, message)
 
 
 class ContextPipeline[I]:

python_cq-0.20.0/cq/_core/pump.py

@@ -0,0 +1,56 @@
+from collections.abc import AsyncIterator, Awaitable, Callable
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from typing import Any, Self
+
+import anyio
+
+from cq._core.middleware import Middleware, MiddlewareGroup
+from cq._core.queues.abc import Consumer
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class Pump[T]:
+    consumer: Consumer[T]
+    dispatcher: Callable[[T], Awaitable[Any]]
+    fail_silently: bool = field(default=False)
+    __middleware_group: MiddlewareGroup[[T], Any] = field(
+        default_factory=MiddlewareGroup,
+        init=False,
+    )
+
+    def add_middlewares(self, *middlewares: Middleware[[T], Any]) -> Self:
+        self.__middleware_group.add(*middlewares)
+        return self
+
+    async def drain(self) -> None:
+        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(
+        self,
+        /,
+        *,
+        concurrency: int | None = None,
+        graceful: bool = False,
+    ) -> AsyncIterator[None]:
+        if concurrency is None:
+            concurrency = 1
+        elif concurrency < 1:
+            raise ValueError(f"`concurrency` must be at least 1, got {concurrency}.")
+
+        async with anyio.create_task_group() as task_group:
+            for _ in range(concurrency):
+                task_group.start_soon(self.drain)
+
+            try:
+                yield
+            finally:
+                if not graceful:
+                    task_group.cancel_scope.cancel()

{python_cq-0.18.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.20.0/cq/_core/queues/memory.py

@@ -0,0 +1,60 @@
+from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
+from contextlib import asynccontextmanager, nullcontext
+from types import TracebackType
+from typing import Any, Self
+
+import anyio
+from anyio.abc import ObjectReceiveStream, ObjectSendStream
+
+from cq._core.middleware import Middleware
+from cq._core.pump import Pump
+from cq._core.queues.abc import Delivery, Queue
+
+
+class MemoryQueue[T](Queue[T]):
+    __slots__ = ("__consumer", "__producer")
+
+    __consumer: ObjectReceiveStream[T]
+    __producer: ObjectSendStream[T]
+
+    def __init__(self, maxsize: int = 0) -> None:
+        self.__producer, self.__consumer = anyio.create_memory_object_stream(maxsize)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    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()
+
+    @asynccontextmanager
+    async def draining(
+        self,
+        dispatcher: Callable[[T], Awaitable[Any]],
+        /,
+        *,
+        concurrency: int | None = None,
+        fail_silently: bool = False,
+        middlewares: Sequence[Middleware[[T], Any]] = (),
+    ) -> AsyncIterator[Self]:
+        async with (
+            Pump(self, dispatcher, fail_silently)
+            .add_middlewares(*middlewares)
+            .draining(concurrency=concurrency, graceful=True)
+        ):
+            async with self:
+                yield self
+
+    async def send(self, message: T, /) -> None:
+        await self.__producer.send(message)

python_cq-0.20.0/cq/middlewares/exc.py

@@ -0,0 +1,56 @@
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Any, Concatenate, Self
+
+from cq import MiddlewareResult
+
+__all__ = ("CaptureExceptionMiddleware",)
+
+
+class CaptureExceptionMiddleware[**P, Exc: BaseException]:
+    __slots__ = ("__exceptions", "__on_error", "__reraise")
+
+    __exceptions: tuple[type[Exc], ...]
+    __on_error: Callable[Concatenate[Exc, P], Awaitable[Any]]
+    __reraise: bool
+
+    def __init__(
+        self,
+        on_error: Callable[Concatenate[Exc, P], Awaitable[Any]],
+        /,
+        exceptions: Sequence[type[Exc]] | None = None,
+        reraise: bool = False,
+    ) -> None:
+        self.__exceptions = (Exception,) if exceptions is None else tuple(exceptions)  # type: ignore[assignment]
+        self.__on_error = on_error
+        self.__reraise = reraise
+
+    async def __call__(
+        self,
+        /,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> MiddlewareResult[Any]:
+        try:
+            yield
+        except self.__exceptions as exc:
+            await self.__on_error(exc, *args, **kwargs)
+            if self.__reraise:
+                raise
+
+    @classmethod
+    def sync(
+        cls,
+        on_error: Callable[Concatenate[Exc, P], Any],
+        /,
+        exceptions: Sequence[type[Exc]] | None = None,
+        reraise: bool = False,
+    ) -> Self:
+        async def async_on_error(
+            exception: Exc,
+            /,
+            *args: P.args,
+            **kwargs: P.kwargs,
+        ) -> Any:
+            return on_error(exception, *args, **kwargs)
+
+        return cls(async_on_error, exceptions, reraise)

{python_cq-0.18.0 → python_cq-0.20.0}/pyproject.toml

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

python_cq-0.18.0/cq/_core/pump.py

@@ -1,34 +0,0 @@
-from collections.abc import AsyncIterator, Awaitable, Callable
-from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
-from typing import Any
-
-import anyio
-
-from cq._core.queues.abc import Consumer
-
-
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class Pump[T]:
-    consumer: Consumer[T]
-    dispatcher: Callable[[T], Awaitable[Any]]
-    fail_silently: bool = field(default=False)
-
-    async def drain(self) -> None:
-        async for message in self.consumer:
-            try:
-                await self.dispatcher(message)
-            except Exception:
-                if not self.fail_silently:
-                    raise
-
-    @asynccontextmanager
-    async def draining(self, /, *, graceful: bool = False) -> AsyncIterator[None]:
-        async with anyio.create_task_group() as task_group:
-            task_group.start_soon(self.drain)
-
-            try:
-                yield
-            finally:
-                if not graceful:
-                    task_group.cancel_scope.cancel()

python_cq-0.18.0/cq/_core/queues/memory.py

@@ -1,42 +0,0 @@
-from collections.abc import AsyncIterator, Awaitable, Callable
-from contextlib import asynccontextmanager
-from typing import Any, Self
-
-import anyio
-from anyio.abc import ObjectReceiveStream, ObjectSendStream
-
-from cq._core.pump import Pump
-from cq._core.queues.abc import Queue
-
-
-class MemoryQueue[T](Queue[T]):
-    __slots__ = ("__consumer", "__producer")
-
-    __consumer: ObjectReceiveStream[T]
-    __producer: ObjectSendStream[T]
-
-    def __init__(self, maxsize: int = 0) -> None:
-        self.__producer, self.__consumer = anyio.create_memory_object_stream(maxsize)
-
-    def __aiter__(self) -> AsyncIterator[T]:
-        return aiter(self.__consumer)
-
-    async def close(self) -> None:
-        await self.__producer.aclose()
-
-    @asynccontextmanager
-    async def draining(
-        self,
-        dispatcher: Callable[[T], Awaitable[Any]],
-        /,
-        *,
-        fail_silently: bool = False,
-    ) -> AsyncIterator[Self]:
-        async with Pump(self, dispatcher, fail_silently).draining(graceful=True):
-            try:
-                yield self
-            finally:
-                await self.close()
-
-    async def send(self, message: T, /) -> None:
-        await self.__producer.send(message)