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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.18.0
+Version: 0.19.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.19.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
+from cq._core.middleware import Middleware, MiddlewareGroup, deliver_message
 
 
 @runtime_checkable
@@ -29,17 +29,16 @@ class BaseDispatcher[I, O](Dispatcher[I, O], ABC):
         self.__middleware_group.add(*middlewares)
         return self
 
-    async def _invoke_with_middlewares(
+    async def _deliver(
         self,
-        handler: Callable[[I], Awaitable[O]],
         message: I,
+        handler: Callable[[I], Awaitable[O]],
         /,
         fail_silently: bool = False,
     ) -> O:
-        try:
-            return await self.__middleware_group.invoke(handler, message)
-        except Exception:
-            if fail_silently:
-                return NotImplemented
-
-            raise
+        return await deliver_message(
+            message,
+            handler,
+            self.__middleware_group,
+            fail_silently,
+        )

{python_cq-0.18.0 → python_cq-0.19.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._deliver(message, handler, handler.fail_silently)
 
         return NotImplemented
 
@@ -104,8 +100,8 @@ class TaskBus[I](BaseBus[I, None]):
 
             for handler in self._handlers_from(type(message)):
                 task_group.start_soon(
-                    self._invoke_with_middlewares,
-                    handler,
+                    self._deliver,
                     message,
+                    handler,
                     handler.fail_silently,
                 )

{python_cq-0.18.0 → python_cq-0.19.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._deliver(message, self.__steps.execute)
 
 
 class ContextPipeline[I]:

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

@@ -115,6 +115,21 @@ 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/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, deliver_message
+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 message in self.consumer:
+            await deliver_message(
+                message,
+                self.dispatcher,
+                self.__middleware_group,
+                self.fail_silently,
+            )
+
+    @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.19.0}/cq/_core/queues/memory.py

@@ -1,10 +1,12 @@
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
 from contextlib import asynccontextmanager
+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 Queue
 
@@ -18,6 +20,17 @@ class MemoryQueue[T](Queue[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()
+
     def __aiter__(self) -> AsyncIterator[T]:
         return aiter(self.__consumer)
 
@@ -30,13 +43,17 @@ class MemoryQueue[T](Queue[T]):
         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).draining(graceful=True):
-            try:
+        async with (
+            Pump(self, dispatcher, fail_silently)
+            .add_middlewares(*middlewares)
+            .draining(concurrency=concurrency, graceful=True)
+        ):
+            async with self:
                 yield self
-            finally:
-                await self.close()
 
     async def send(self, message: T, /) -> None:
         await self.__producer.send(message)

python_cq-0.19.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.19.0}/pyproject.toml

@@ -20,7 +20,7 @@ test = [
 
 [project]
 name = "python-cq"
-version = "0.18.0"
+version = "0.19.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()