python-cq 0.21.1__py3-none-any.whl → 0.22.0__py3-none-any.whl

cq/_core/cq.py

@@ -10,7 +10,6 @@ from cq._core.handler import (
     SingleHandlerRegistry,
 )
 from cq._core.message import Command, Event, Query
-from cq._core.middlewares.scope import CommandDispatchScopeMiddleware
 
 
 class CQ:
@@ -57,8 +56,7 @@ class CQ:
 
     def new_command_bus(self) -> Bus[Command, Any]:
         bus = SimpleBus(self.__command_registry)
-        command_middleware = CommandDispatchScopeMiddleware(self.__di)
-        bus.add_middlewares(command_middleware)
+        bus.add_middlewares(self.__di.command_scope())
         return bus
 
     def new_event_bus(self) -> Bus[Event, None]:

cq/_core/di.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 from abc import abstractmethod
 from collections.abc import Awaitable, Callable
 from contextlib import nullcontext
-from typing import TYPE_CHECKING, Any, AsyncContextManager, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+from cq.middlewares.contextlib import AsyncContextManagerMiddleware
 
 if TYPE_CHECKING:  # pragma: no cover
-    from cq import CommandBus, EventBus, QueryBus
+    from cq import Command, CommandBus, EventBus, Middleware, QueryBus
 
 
 @runtime_checkable
@@ -22,30 +24,19 @@ class DIAdapter(Protocol):
     __slots__ = ()
 
     @abstractmethod
-    def command_scope(self) -> AsyncContextManager[None]:
+    def command_scope(self) -> Middleware[[Command], Any]:
         """
-        Return an async context manager that delimits the lifetime of a
-        command dispatch.
+        Return a middleware that wraps each command dispatch.
 
         **Responsibilities**
 
-        The scope must at minimum manage the lifecycle of a ``RelatedEvents``
-        instance and register it so that it is resolvable via injection for
-        the duration of the scope.
-
-        **Nested calls**
-
-        ``command_scope`` is entered in two distinct situations:
-
-        1. Around a standard command dispatch (via
-           ``CommandDispatchScopeMiddleware``).
-        2. Around each step of a ``ContextCommandPipeline``, which itself
-           wraps a command dispatch.
+        The middleware must at minimum manage the lifecycle of a
+        ``RelatedEvents`` instance and register it so that it is resolvable
+        via injection for the duration of the dispatch.
 
-        This means two nested calls can occur for a single logical command.
-        Implementations must detect re-entrant activation (e.g. a scope
-        already active on the current task) and silently ignore the inner
-        call instead of opening a second, conflicting scope.
+        If you already have an async context manager for the scope, wrap it
+        with ``cq.middlewares.contextlib.AsyncContextManagerMiddleware``
+        instead of writing the middleware by hand.
         """
 
         raise NotImplementedError
@@ -97,8 +88,8 @@ class DIAdapter(Protocol):
 class NoDI(DIAdapter):
     __slots__ = ()
 
-    def command_scope(self) -> AsyncContextManager[None]:
-        return nullcontext()
+    def command_scope(self) -> Middleware[[Command], Any]:
+        return AsyncContextManagerMiddleware(nullcontext())
 
     def lazy[T](self, tp: type[T], /) -> Callable[[], Awaitable[T]]:
         tp_str = getattr(tp, "__name__", str(tp))

cq/_core/pipetools.py

@@ -11,7 +11,6 @@ from cq._core.dispatchers.pipe import (
     ConvertMethodSync,
 )
 from cq._core.message import Command, CommandBus, Query, QueryBus
-from cq._core.middlewares.scope import CommandDispatchScopeMiddleware
 
 
 class ContextCommandPipeline[C: Command](ContextPipeline[C]):
@@ -22,8 +21,6 @@ class ContextCommandPipeline[C: Command](ContextPipeline[C]):
     def __init__(self, di: DIAdapter) -> None:
         super().__init__(LazyDispatcher(CommandBus, di))
         self.__query_dispatcher = LazyDispatcher(QueryBus, di)
-        command_middleware = CommandDispatchScopeMiddleware(di)
-        self.add_middlewares(command_middleware)
 
     def add_static_query_step[Q: Query](self, query: Q, /) -> Self:
         return self.add_static_step(query, dispatcher=self.__query_dispatcher)

cq/ext/injection.py

@@ -1,15 +1,15 @@
 from collections.abc import AsyncIterator
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import AsyncExitStack
 from dataclasses import dataclass, field
 from enum import StrEnum
-from typing import Any, AsyncContextManager, Awaitable, Callable
+from typing import Any, Awaitable, Callable
 
 from injection import Module, adefine_scope, mod
 from injection.exceptions import ScopeAlreadyDefinedError
 
 from cq._core.di import DIAdapter
-from cq._core.message import CommandBus, EventBus, QueryBus
-from cq._core.middleware import MiddlewareResult
+from cq._core.message import Command, CommandBus, EventBus, QueryBus
+from cq._core.middleware import Middleware, MiddlewareResult
 from cq._core.related_events import AnyIORelatedEvents, RelatedEvents
 
 __all__ = ("CQScope", "InjectionAdapter", "InjectionScopeMiddleware")
@@ -24,12 +24,11 @@ class InjectionAdapter(DIAdapter):
     module: Module = field(default_factory=mod)
     threadsafe: bool | None = field(default=None)
 
-    def command_scope(self) -> AsyncContextManager[None]:
-        return InjectionScopeMiddleware(  # type: ignore[return-value]
+    def command_scope(self) -> Middleware[[Command], Any]:
+        return InjectionScopeMiddleware(
             CQScope.COMMAND_DISPATCH,
-            exist_ok=True,
             threadsafe=self.threadsafe,
-        )._cm
+        )
 
     def lazy[T](self, tp: type[T], /) -> Callable[[], Awaitable[T]]:
         awaitable = self.module.aget_lazy_instance(tp, threadsafe=self.threadsafe)
@@ -83,12 +82,6 @@ class InjectionScopeMiddleware:
     threadsafe: bool | None = field(default=None, kw_only=True)
 
     async def __call__(self, /, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
-        async with self._cm:  # type: ignore[attr-defined]
-            yield
-
-    @property
-    @asynccontextmanager
-    async def _cm(self) -> AsyncIterator[None]:
         async with AsyncExitStack() as stack:
             try:
                 await stack.enter_async_context(

cq/middlewares/contextlib.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, AsyncContextManager, ContextManager
+
+if TYPE_CHECKING:  # pragma: no cover
+    from cq import MiddlewareResult
+
+__all__ = ("AsyncContextManagerMiddleware", "ContextManagerMiddleware")
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class AsyncContextManagerMiddleware:
+    context: AsyncContextManager[Any]
+
+    async def __call__(self, /, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
+        async with self.context:
+            yield
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class ContextManagerMiddleware:
+    context: ContextManager[Any]
+
+    async def __call__(self, /, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
+        with self.context:
+            yield

{python_cq-0.21.1.dist-info → python_cq-0.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.21.1
+Version: 0.22.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.21.1.dist-info → python_cq-0.22.0.dist-info}/RECORD

@@ -2,12 +2,12 @@ cq/__init__.py,sha256=efZeCSuvUsBJ00dVLEs3DcNd1fdPhgYhH4xkCQVpO9Y,1963
 cq/exceptions.py,sha256=lmIpWDbPPwdS9bAAKxUvampA1KKmB706wWaB2mKZyPc,111
 cq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cq/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cq/_core/cq.py,sha256=2D7zaovflEyGrrN6cOd4MqEllqzl_fFY4QgKsXETzp4,2438
-cq/_core/di.py,sha256=_LXnfCNemZMweInOA6IVjjnhc9z8F5A3cLImF8hT58Y,3681
+cq/_core/cq.py,sha256=YDYcLMHAIlyCJ1NSm0sR_JnsVJ0wYZ1ndkUE0sArzic,2304
+cq/_core/di.py,sha256=vqHvDTvXNRH8C_we1fKMicvQ6SuGM8aedHQaMrP6Llo,3369
 cq/_core/handler.py,sha256=2lc5B1WS3NOm_lJakOF9aTlto5Hh9cvJl6dppYknWzs,7276
 cq/_core/message.py,sha256=HpoYHstxRTWoUw_FuqDkytzyvK0Mb0U96Bz15ZEBd70,278
 cq/_core/middleware.py,sha256=RX_bLoqBL2p_dyCQs-jeozGVe6s7L9O4hDiwFxEprDY,3686
-cq/_core/pipetools.py,sha256=HGKWctffJliE6qdR9ER3BXiplpt98En_B-MQFd6aqEo,1766
+cq/_core/pipetools.py,sha256=o2FqEfnIaoFwfY0maxI2rg6bK4vlBJK3KdHvQL4vPk0,1583
 cq/_core/pump.py,sha256=Kxrmdex1Yf2YhbA45e7n7Whwdp9fAi_npaAND8_cSrc,1749
 cq/_core/related_events.py,sha256=vPltQdmQjnfb3eOB2lO6dxqjJEsGOjOyCNj7_2ehNAk,1389
 cq/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,17 +17,16 @@ cq/_core/dispatchers/abc.py,sha256=E_amQ95TvcmicNRcUzftvRcqI0-Un-qqpm4XcepLyg0,1
 cq/_core/dispatchers/bus.py,sha256=eOhZXZxBOFS5Emx4h7a5ulgT5hWtyQtwxTIU5RqHRGw,3305
 cq/_core/dispatchers/lazy.py,sha256=byvwDZBBoTpnd40MCSTWNQ2ubyK_ib-pjxYoumqfSaY,715
 cq/_core/dispatchers/pipe.py,sha256=gdq0ihPlBgcAVSQrR0ovcFVdQhUB6Ejj6Lg5K76L2Rg,9723
-cq/_core/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cq/_core/middlewares/scope.py,sha256=4LFH8uccow6LJa-1Eu8HiSjbz69D_T0dQJ7SpdPhLUA,405
 cq/_core/queues/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cq/_core/queues/abc.py,sha256=zXb9Nre9gaKPCbQbkUErnJGRn14UP1K7GpR_N7DFhkE,690
 cq/_core/queues/memory.py,sha256=VIZN3jIcnE7ij4NKhCJu6jEfvSgk5_EadtQejsxR2Lo,1811
 cq/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cq/ext/injection.py,sha256=Lhrzy2hY7ZJG1lrvc3OHVTab3CfyRC-sz5xLPXfvfHA,3359
+cq/ext/injection.py,sha256=6up8NqcUYwMjbGdxV653Ai4Bb49OckF6vIhocwz_bjk,3113
 cq/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cq/middlewares/contextlib.py,sha256=8fXNI6Y3pOjLbDz8JRHb1KXU8cbPWksUV6qhcRCvd5s,821
 cq/middlewares/exc.py,sha256=ecAMoksj6B4osySSZ9g_cBR35_tiABQdpII-Drxkz44,1604
 cq/middlewares/retry.py,sha256=L6X_Wa2TZ0IYNXmi8oexTXQyM_lkjJt5Ew4D-2VzwBY,957
-python_cq-0.21.1.dist-info/METADATA,sha256=XzdL2djlbFj8hthtkHPlsYBbD3qs9cU9LX9KcjtBkDs,4507
-python_cq-0.21.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-python_cq-0.21.1.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
-python_cq-0.21.1.dist-info/RECORD,,
+python_cq-0.22.0.dist-info/METADATA,sha256=XtA7nmM9n-qTSqojG1-YVSA3mGY87YTjC0ykeiYNQ90,4507
+python_cq-0.22.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+python_cq-0.22.0.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
+python_cq-0.22.0.dist-info/RECORD,,

cq/_core/middlewares/scope.py

@@ -1,14 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from cq._core.di import DIAdapter
-from cq._core.middleware import MiddlewareResult
-
-
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class CommandDispatchScopeMiddleware:
-    di: DIAdapter
-
-    async def __call__(self, /, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
-        async with self.di.command_scope():
-            yield