feat: ✨ Add threadsafe parameter in handler decorators

Author: remimd

cq/_core/handler.py

@@ -94,45 +94,57 @@ def __call__(
         self,
         input_or_handler_type: type[I],
         /,
+        *,
+        threadsafe: bool | None = ...,
     ) -> Callable[[HandlerType[[I], O]], HandlerType[[I], O]]: ...
 
     @overload
     def __call__(
         self,
         input_or_handler_type: HandlerType[[I], O],
         /,
+        *,
+        threadsafe: bool | None = ...,
     ) -> HandlerType[[I], O]: ...
 
     @overload
     def __call__(
         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

cq/middlewares/scope.py

@@ -17,16 +17,15 @@
 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:
+            context_manager = adefine_scope(self.scope_name, threadsafe=self.threadsafe)
             try:
-                await stack.enter_async_context(
-                    adefine_scope(self.scope_name),
-                )
-
+                await stack.enter_async_context(context_manager)
             except ScopeAlreadyDefinedError:
                 if not self.exist_ok:
                     raise
-
+            del context_manager
             yield

pyproject.toml

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