python-cq 0.7.2__tar.gz → 0.7.4__tar.gz

{python_cq-0.7.2 → python_cq-0.7.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.7.2
-Summary: Lightweight CQRS library.
+Version: 0.7.4
+Summary: Lightweight CQRS library for async Python projects.
 Project-URL: Repository, https://github.com/100nm/python-cq
 Author: remimd
 License-Expression: MIT

{python_cq-0.7.2 → python_cq-0.7.4}/cq/_core/handler.py

@@ -94,6 +94,8 @@ class HandlerDecorator[I, O]:
         self,
         input_or_handler_type: type[I],
         /,
+        *,
+        threadsafe: bool | None = ...,
     ) -> Callable[[HandlerType[[I], O]], HandlerType[[I], O]]: ...
 
     @overload
@@ -101,6 +103,8 @@ class HandlerDecorator[I, O]:
         self,
         input_or_handler_type: HandlerType[[I], O],
         /,
+        *,
+        threadsafe: bool | None = ...,
     ) -> HandlerType[[I], O]: ...
 
     @overload
@@ -108,31 +112,39 @@ class HandlerDecorator[I, O]:
         self,
         input_or_handler_type: None = ...,
         /,
+        *,
+        threadsafe: bool | None = ...,
     ) -> Callable[[HandlerType[[I], O]], HandlerType[[I], O]]: ...
 
     def __call__(
         self,
         input_or_handler_type: type[I] | HandlerType[[I], O] | None = None,
         /,
+        *,
+        threadsafe: bool | None = None,
     ) -> Any:
-        if input_or_handler_type is None:
-            return self.__decorator
-
-        elif isclass(input_or_handler_type) and issubclass(
-            input_or_handler_type,
-            Handler,
+        if (
+            input_or_handler_type is not None
+            and isclass(input_or_handler_type)
+            and issubclass(input_or_handler_type, Handler)
         ):
-            return self.__decorator(input_or_handler_type)
+            return self.__decorator(input_or_handler_type, threadsafe=threadsafe)
 
-        return partial(self.__decorator, input_type=input_or_handler_type)  # type: ignore[arg-type]
+        return partial(
+            self.__decorator,
+            input_type=input_or_handler_type,  # type: ignore[arg-type]
+            threadsafe=threadsafe,
+        )
 
     def __decorator(
         self,
         wrapped: HandlerType[[I], O],
+        /,
         *,
         input_type: type[I] | None = None,
+        threadsafe: bool | None = None,
     ) -> HandlerType[[I], O]:
-        factory = self.injection_module.make_async_factory(wrapped)
+        factory = self.injection_module.make_async_factory(wrapped, threadsafe)
         input_type = input_type or _resolve_input_type(wrapped)
         self.manager.subscribe(input_type, factory)
         return wrapped

{python_cq-0.7.2 → python_cq-0.7.4}/cq/_core/message.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Final
 
 import injection
 
@@ -22,23 +22,24 @@ type QueryBus[T] = Bus[Query, T]
 AnyCommandBus = CommandBus[Any]
 
 
-command_handler: HandlerDecorator[Command, Any] = HandlerDecorator(
+command_handler: Final[HandlerDecorator[Command, Any]] = HandlerDecorator(
     SingleHandlerManager(),
 )
-event_handler: HandlerDecorator[Event, None] = HandlerDecorator(
+event_handler: Final[HandlerDecorator[Event, None]] = HandlerDecorator(
     MultipleHandlerManager(),
 )
-query_handler: HandlerDecorator[Query, Any] = HandlerDecorator(
+query_handler: Final[HandlerDecorator[Query, Any]] = HandlerDecorator(
     SingleHandlerManager(),
 )
 
 
 @injection.injectable(inject=False, mode="fallback")
-def new_command_bus() -> CommandBus:  # type: ignore[type-arg]
+def new_command_bus(*, threadsafe: bool | None = None) -> CommandBus:  # type: ignore[type-arg]
     bus = SimpleBus(command_handler.manager)
     transaction_scope_middleware = InjectionScopeMiddleware(
         CQScope.TRANSACTION,
         exist_ok=True,
+        threadsafe=threadsafe,
     )
     bus.add_middlewares(transaction_scope_middleware)
     return bus

{python_cq-0.7.2 → python_cq-0.7.4}/cq/middlewares/scope.py

@@ -17,16 +17,17 @@ __all__ = ("InjectionScopeMiddleware",)
 class InjectionScopeMiddleware:
     scope_name: str
     exist_ok: bool = field(default=False, kw_only=True)
+    threadsafe: bool | None = field(default=None, kw_only=True)
 
     async def __call__(self, *args: Any, **kwargs: Any) -> MiddlewareResult[Any]:
         async with AsyncExitStack() as stack:
+            cm = adefine_scope(self.scope_name, threadsafe=self.threadsafe)
             try:
-                await stack.enter_async_context(
-                    adefine_scope(self.scope_name),
-                )
+                await stack.enter_async_context(cm)
 
             except ScopeAlreadyDefinedError:
                 if not self.exist_ok:
                     raise
 
+            del cm
             yield

{python_cq-0.7.2 → python_cq-0.7.4}/pyproject.toml

@@ -21,8 +21,8 @@ test = [
 
 [project]
 name = "python-cq"
-version = "0.7.2"
-description = "Lightweight CQRS library."
+version = "0.7.4"
+description = "Lightweight CQRS library for async Python projects."
 license = "MIT"
 license-files = ["LICENSE"]
 readme = "README.md"