python-cq 0.14.0__tar.gz → 0.14.1__tar.gz

{python_cq-0.14.0 → python_cq-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.14.0
+Version: 0.14.1
 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.14.1/cq/_core/common/typing.py

@@ -0,0 +1,21 @@
+from collections.abc import Callable
+from typing import Any, Protocol, overload
+
+
+class Decorator(Protocol):
+    def __call__[T](self, wrapped: T, /) -> T: ...
+
+
+class Method[**P, T](Protocol):
+    @overload
+    def __call__(self, instance: Any, /, *args: P.args, **kwargs: P.kwargs) -> T: ...
+
+    @overload
+    def __call__(self, /, *args: Any, **kwargs: Any) -> T: ...
+
+    def __get__(
+        self,
+        instance: object,
+        owner: type | None = ...,
+        /,
+    ) -> Callable[P, T]: ...

python_cq-0.14.1/cq/_core/dispatcher/pipe.py

@@ -0,0 +1,312 @@
+from abc import abstractmethod
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from functools import partial
+from inspect import iscoroutinefunction
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Concatenate,
+    Protocol,
+    Self,
+    overload,
+    runtime_checkable,
+)
+
+from cq._core.common.typing import Decorator, Method
+from cq._core.dispatcher.base import BaseDispatcher, Dispatcher
+from cq._core.middleware import Middleware, MiddlewareGroup
+
+type ConvertAsync[**P, I, O] = Callable[Concatenate[O, P], Awaitable[I]]
+type ConvertSync[**P, I, O] = Callable[Concatenate[O, P], I]
+type Convert[**P, I, O] = ConvertAsync[P, I, O] | ConvertSync[P, I, O]
+
+type ConvertMethodAsync[I, O] = Method[[O], Awaitable[I]]
+type ConvertMethodSync[I, O] = Method[[O], I]
+type ConvertMethod[I, O] = ConvertMethodAsync[I, O] | ConvertMethodSync[I, O]
+
+
+@runtime_checkable
+class PipelineConverter[**P, I, O](Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    async def convert(self, output_value: O, /, *args: P.args, **kwargs: P.kwargs) -> I:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class PipelineStep[**P, I, O]:
+    converter: PipelineConverter[P, I, O]
+    dispatcher: Dispatcher[I, Any] | None = field(default=None)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class PipelineSteps[**P, I, O]:
+    default_dispatcher: Dispatcher[Any, Any]
+    __steps: list[PipelineStep[P, Any, Any]] = field(default_factory=list, init=False)
+
+    def add[T](
+        self,
+        converter: PipelineConverter[P, T, Any],
+        dispatcher: Dispatcher[T, Any] | None,
+    ) -> Self:
+        self.__steps.append(PipelineStep(converter, dispatcher))
+        return self
+
+    async def execute(self, input_value: I, /, *args: P.args, **kwargs: P.kwargs) -> O:
+        dispatcher = self.default_dispatcher
+
+        for step in self.__steps:
+            output_value = await dispatcher.dispatch(input_value)
+            input_value = await step.converter.convert(output_value, *args, **kwargs)
+
+            if input_value is None:
+                return NotImplemented
+
+            dispatcher = step.dispatcher or self.default_dispatcher
+
+        return await dispatcher.dispatch(input_value)
+
+
+class Pipe[I, O](BaseDispatcher[I, O]):
+    __slots__ = ("__steps",)
+
+    __steps: PipelineSteps[[], I, O]
+
+    def __init__(self, dispatcher: Dispatcher[Any, Any]) -> None:
+        super().__init__()
+        self.__steps = PipelineSteps(dispatcher)
+
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        def step[T](
+            self,
+            wrapped: ConvertAsync[[], T, Any],
+            /,
+            *,
+            dispatcher: Dispatcher[T, Any] | None = ...,
+        ) -> ConvertAsync[[], T, Any]: ...
+
+        @overload
+        def step[T](
+            self,
+            wrapped: ConvertSync[[], T, Any],
+            /,
+            *,
+            dispatcher: Dispatcher[T, Any] | None = ...,
+        ) -> ConvertSync[[], T, Any]: ...
+
+        @overload
+        def step(
+            self,
+            wrapped: None = ...,
+            /,
+            *,
+            dispatcher: Dispatcher[Any, Any] | None = ...,
+        ) -> Decorator: ...
+
+    def step[T](
+        self,
+        wrapped: Convert[[], T, Any] | None = None,
+        /,
+        *,
+        dispatcher: Dispatcher[T, Any] | None = None,
+    ) -> Any:
+        def decorator(wp: Convert[[], T, Any]) -> Convert[[], T, Any]:
+            converter = (
+                _AsyncPipelineConverter(wp)
+                if iscoroutinefunction(wp)
+                else _SyncPipelineConverter(wp)
+            )
+            self.__steps.add(converter, dispatcher)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
+    def add_static_step[T](
+        self,
+        input_value: T,
+        *,
+        dispatcher: Dispatcher[T, Any] | None = None,
+    ) -> Self:
+        converter = _StaticPipelineConverter(input_value)
+        self.__steps.add(converter, dispatcher)
+        return self
+
+    async def dispatch(self, input_value: I, /) -> O:
+        return await self._invoke_with_middlewares(self.__steps.execute, input_value)
+
+
+class ContextPipeline[I]:
+    __slots__ = ("__middleware_group", "__steps")
+
+    __middleware_group: MiddlewareGroup[[I], Any]
+    __steps: PipelineSteps[[object, type | None], I, Any]
+
+    def __init__(self, dispatcher: Dispatcher[Any, Any]) -> None:
+        self.__middleware_group = MiddlewareGroup()
+        self.__steps = PipelineSteps(dispatcher)
+
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        def __get__[O](self, instance: None, owner: type[O], /) -> Dispatcher[I, O]: ...
+
+        @overload
+        def __get__[O](
+            self,
+            instance: O,
+            owner: type[O] | None = ...,
+            /,
+        ) -> Dispatcher[I, O]: ...
+
+        @overload
+        def __get__(self, instance: None = ..., owner: None = ..., /) -> Self: ...
+
+    def __get__[O](
+        self,
+        instance: O | None = None,
+        owner: type[O] | None = None,
+        /,
+    ) -> Self | Dispatcher[I, O]:
+        if instance is None:
+            if owner is None:
+                return self
+
+            instance = owner()
+
+        dispatch_method = partial(self.__execute, context=instance, context_type=owner)
+        return BoundContextPipeline(dispatch_method)
+
+    def add_middlewares(self, *middlewares: Middleware[[I], Any]) -> Self:
+        self.__middleware_group.add(*middlewares)
+        return self
+
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        def step[T](
+            self,
+            wrapped: ConvertMethodAsync[T, Any],
+            /,
+            *,
+            dispatcher: Dispatcher[T, Any] | None = ...,
+        ) -> ConvertMethodAsync[T, Any]: ...
+
+        @overload
+        def step[T](
+            self,
+            wrapped: ConvertMethodSync[T, Any],
+            /,
+            *,
+            dispatcher: Dispatcher[T, Any] | None = ...,
+        ) -> ConvertMethodSync[T, Any]: ...
+
+        @overload
+        def step(
+            self,
+            wrapped: None = ...,
+            /,
+            *,
+            dispatcher: Dispatcher[Any, Any] | None = ...,
+        ) -> Decorator: ...
+
+    def step[T](
+        self,
+        wrapped: ConvertMethod[T, Any] | None = None,
+        /,
+        *,
+        dispatcher: Dispatcher[T, Any] | None = None,
+    ) -> Any:
+        def decorator(wp: ConvertMethod[T, Any]) -> ConvertMethod[T, Any]:
+            converter = (
+                _AsyncContextPipelineConverter(wp)
+                if iscoroutinefunction(wp)
+                else _SyncContextPipelineConverter(wp)
+            )
+            self.__steps.add(converter, dispatcher)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
+    async def __execute[O](
+        self,
+        input_value: I,
+        /,
+        *,
+        context: O,
+        context_type: type[O] | None,
+    ) -> O:
+        await self.__middleware_group.invoke(
+            lambda i: self.__steps.execute(i, context, context_type),
+            input_value,
+        )
+        return context
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class BoundContextPipeline[I, O](Dispatcher[I, O]):
+    dispatch_method: Callable[[I], Awaitable[O]]
+
+    async def dispatch(self, input_value: I, /) -> O:
+        return await self.dispatch_method(input_value)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class _AsyncPipelineConverter[**P, I, O](PipelineConverter[P, I, O]):
+    converter: ConvertAsync[P, I, O]
+
+    async def convert(self, output_value: O, /, *args: P.args, **kwargs: P.kwargs) -> I:
+        return await self.converter(output_value, *args, **kwargs)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class _SyncPipelineConverter[**P, I, O](PipelineConverter[P, I, O]):
+    converter: ConvertSync[P, I, O]
+
+    async def convert(self, output_value: O, /, *args: P.args, **kwargs: P.kwargs) -> I:
+        return self.converter(output_value, *args, **kwargs)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class _StaticPipelineConverter[I](PipelineConverter[..., I, Any]):
+    input_value: I
+
+    async def convert(self, output_value: Any, /, *args: Any, **kwargs: Any) -> I:
+        return self.input_value
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class _AsyncContextPipelineConverter[I, O](
+    PipelineConverter[[object, type | None], I, O],
+):
+    converter: ConvertMethodAsync[I, O]
+
+    async def convert(
+        self,
+        output_value: O,
+        /,
+        context: object,
+        context_type: type | None,
+    ) -> I:
+        method = self.converter.__get__(context, context_type)
+        return await method(output_value)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class _SyncContextPipelineConverter[I, O](
+    PipelineConverter[[object, type | None], I, O],
+):
+    converter: ConvertMethodSync[I, O]
+
+    async def convert(
+        self,
+        output_value: O,
+        /,
+        context: object,
+        context_type: type | None,
+    ) -> I:
+        method = self.converter.__get__(context, context_type)
+        return method(output_value)

{python_cq-0.14.0 → python_cq-0.14.1}/cq/_core/handler.py

@@ -10,6 +10,8 @@ from typing import TYPE_CHECKING, Any, Protocol, Self, overload, runtime_checkab
 import injection
 from type_analyzer import MatchingTypesConfig, iter_matching_types, matching_types
 
+from cq._core.common.typing import Decorator
+
 type HandlerType[**P, T] = type[Handler[P, T]]
 type HandlerFactory[**P, T] = Callable[..., Awaitable[Handler[P, T]]]
 
@@ -90,10 +92,6 @@ class SingleHandlerRegistry[I, O](HandlerRegistry[I, O]):
         return self
 
 
-class _Decorator(Protocol):
-    def __call__[T](self, wrapped: T, /) -> T: ...
-
-
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class HandlerDecorator[I, O]:
     registry: HandlerRegistry[I, O]
@@ -108,7 +106,7 @@ class HandlerDecorator[I, O]:
             /,
             *,
             threadsafe: bool | None = ...,
-        ) -> _Decorator: ...
+        ) -> Decorator: ...
 
         @overload
         def __call__[T](
@@ -126,7 +124,7 @@ class HandlerDecorator[I, O]:
             /,
             *,
             threadsafe: bool | None = ...,
-        ) -> _Decorator: ...
+        ) -> Decorator: ...
 
     def __call__[T](
         self,

{python_cq-0.14.0 → python_cq-0.14.1}/cq/_core/message.py

@@ -26,7 +26,7 @@ AnyCommandBus = CommandBus[Any]
 command_handler: Final[HandlerDecorator[Command, Any]] = HandlerDecorator(
     SingleHandlerRegistry(),
 )
-event_handler: Final[HandlerDecorator[Event, None]] = HandlerDecorator(
+event_handler: Final[HandlerDecorator[Event, Any]] = HandlerDecorator(
     MultipleHandlerRegistry(),
 )
 query_handler: Final[HandlerDecorator[Query, Any]] = HandlerDecorator(

{python_cq-0.14.0 → python_cq-0.14.1}/cq/_core/middleware.py

@@ -59,7 +59,7 @@ class _BoundMiddleware[**P, T]:
     call_next: Callable[P, Awaitable[T]]
     middleware: ClassicMiddleware[P, T]
 
-    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+    async def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
         return await self.middleware(self.call_next, *args, **kwargs)
 
 

{python_cq-0.14.0 → python_cq-0.14.1}/cq/_core/pipetools.py

@@ -1,10 +1,16 @@
-from typing import TYPE_CHECKING, Any, Callable, overload
+from typing import TYPE_CHECKING, Any, overload
 
 import injection
 
 from cq import Dispatcher
+from cq._core.common.typing import Decorator
 from cq._core.dispatcher.lazy import LazyDispatcher
-from cq._core.dispatcher.pipe import ContextPipeline, PipeConverterMethod
+from cq._core.dispatcher.pipe import (
+    ContextPipeline,
+    ConvertMethod,
+    ConvertMethodAsync,
+    ConvertMethodSync,
+)
 from cq._core.message import AnyCommandBus, Command, Query, QueryBus
 from cq._core.scope import CQScope
 from cq.middlewares.scope import InjectionScopeMiddleware
@@ -47,20 +53,23 @@ class ContextCommandPipeline[I: Command](ContextPipeline[I]):
         @overload
         def query_step[T: Query](
             self,
-            wrapped: PipeConverterMethod[T, Any],
+            wrapped: ConvertMethodAsync[T, Any],
             /,
-        ) -> PipeConverterMethod[T, Any]: ...
+        ) -> ConvertMethodAsync[T, Any]: ...
 
         @overload
         def query_step[T: Query](
             self,
-            wrapped: None = ...,
+            wrapped: ConvertMethodSync[T, Any],
             /,
-        ) -> Callable[[PipeConverterMethod[T, Any]], PipeConverterMethod[T, Any]]: ...
+        ) -> ConvertMethodSync[T, Any]: ...
 
-    def query_step[T: Query](
+        @overload
+        def query_step(self, wrapped: None = ..., /) -> Decorator: ...
+
+    def query_step[T: Query](  # type: ignore[misc]
         self,
-        wrapped: PipeConverterMethod[T, Any] | None = None,
+        wrapped: ConvertMethod[T, Any] | None = None,
         /,
     ) -> Any:
         return self.step(wrapped, dispatcher=self.__query_dispatcher)

{python_cq-0.14.0 → python_cq-0.14.1}/pyproject.toml

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

python_cq-0.14.0/cq/_core/dispatcher/pipe.py

@@ -1,210 +0,0 @@
-from collections import deque
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Protocol, Self, overload
-
-from cq._core.dispatcher.base import BaseDispatcher, Dispatcher
-from cq._core.middleware import Middleware
-
-type PipeConverter[I, O] = Callable[[O], Awaitable[I]]
-
-
-class PipeConverterMethod[I, O](Protocol):
-    def __get__(
-        self,
-        instance: object,
-        owner: type | None = ...,
-    ) -> PipeConverter[I, O]: ...
-
-
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class PipeStep[I, O]:
-    converter: PipeConverter[I, O]
-    dispatcher: Dispatcher[I, Any] | None = field(default=None)
-
-
-class Pipe[I, O](BaseDispatcher[I, O]):
-    __slots__ = ("__dispatcher", "__steps")
-
-    __dispatcher: Dispatcher[Any, Any]
-    __steps: list[PipeStep[Any, Any]]
-
-    def __init__(self, dispatcher: Dispatcher[Any, Any]) -> None:
-        super().__init__()
-        self.__dispatcher = dispatcher
-        self.__steps = []
-
-    if TYPE_CHECKING:  # pragma: no cover
-
-        @overload
-        def step[T](
-            self,
-            wrapped: PipeConverter[T, Any],
-            /,
-            *,
-            dispatcher: Dispatcher[T, Any] | None = ...,
-        ) -> PipeConverter[T, Any]: ...
-
-        @overload
-        def step[T](
-            self,
-            wrapped: None = ...,
-            /,
-            *,
-            dispatcher: Dispatcher[T, Any] | None = ...,
-        ) -> Callable[[PipeConverter[T, Any]], PipeConverter[T, Any]]: ...
-
-    def step[T](
-        self,
-        wrapped: PipeConverter[T, Any] | None = None,
-        /,
-        *,
-        dispatcher: Dispatcher[T, Any] | None = None,
-    ) -> Any:
-        def decorator(wp: PipeConverter[T, Any]) -> PipeConverter[T, Any]:
-            step = PipeStep(wp, dispatcher)
-            self.__steps.append(step)
-            return wp
-
-        return decorator(wrapped) if wrapped else decorator
-
-    def add_static_step[T](
-        self,
-        input_value: T,
-        *,
-        dispatcher: Dispatcher[T, Any] | None = None,
-    ) -> Self:
-        @self.step(dispatcher=dispatcher)
-        async def converter(_: Any) -> T:
-            return input_value
-
-        return self
-
-    async def dispatch(self, input_value: I, /) -> O:
-        return await self._invoke_with_middlewares(self.__execute, input_value)
-
-    async def __execute(self, input_value: I) -> O:
-        dispatcher = self.__dispatcher
-
-        for step in self.__steps:
-            output_value = await dispatcher.dispatch(input_value)
-            input_value = await step.converter(output_value)
-
-            if input_value is None:
-                return NotImplemented
-
-            dispatcher = step.dispatcher or self.__dispatcher
-
-        return await dispatcher.dispatch(input_value)
-
-
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class ContextPipelineStep[I, O]:
-    converter: PipeConverterMethod[I, O]
-    dispatcher: Dispatcher[I, Any] | None = field(default=None)
-
-
-class ContextPipeline[I]:
-    __slots__ = ("__dispatcher", "__middlewares", "__steps")
-
-    __dispatcher: Dispatcher[Any, Any]
-    __middlewares: deque[Middleware[Any, Any]]
-    __steps: list[ContextPipelineStep[Any, Any]]
-
-    def __init__(self, dispatcher: Dispatcher[Any, Any]) -> None:
-        self.__dispatcher = dispatcher
-        self.__middlewares = deque()
-        self.__steps = []
-
-    if TYPE_CHECKING:  # pragma: no cover
-
-        @overload
-        def __get__[O](self, instance: None, owner: type[O], /) -> Dispatcher[I, O]: ...
-
-        @overload
-        def __get__[O](
-            self,
-            instance: O,
-            owner: type[O] | None = ...,
-            /,
-        ) -> Dispatcher[I, O]: ...
-
-        @overload
-        def __get__(self, instance: None = ..., owner: None = ..., /) -> Self: ...
-
-    def __get__[O](
-        self,
-        instance: O | None = None,
-        owner: type[O] | None = None,
-        /,
-    ) -> Self | Dispatcher[I, O]:
-        if instance is None:
-            if owner is None:
-                return self
-
-            instance = owner()
-
-        pipeline = self.__new_pipeline(instance, owner)
-        return BoundContextPipeline(instance, pipeline)
-
-    def add_middlewares(self, *middlewares: Middleware[[I], Any]) -> Self:
-        self.__middlewares.extendleft(reversed(middlewares))
-        return self
-
-    if TYPE_CHECKING:  # pragma: no cover
-
-        @overload
-        def step[T](
-            self,
-            wrapped: PipeConverterMethod[T, Any],
-            /,
-            *,
-            dispatcher: Dispatcher[T, Any] | None = ...,
-        ) -> PipeConverterMethod[T, Any]: ...
-
-        @overload
-        def step[T](
-            self,
-            wrapped: None = ...,
-            /,
-            *,
-            dispatcher: Dispatcher[T, Any] | None = ...,
-        ) -> Callable[[PipeConverterMethod[T, Any]], PipeConverterMethod[T, Any]]: ...
-
-    def step[T](
-        self,
-        wrapped: PipeConverterMethod[T, Any] | None = None,
-        /,
-        *,
-        dispatcher: Dispatcher[T, Any] | None = None,
-    ) -> Any:
-        def decorator(wp: PipeConverterMethod[T, Any]) -> PipeConverterMethod[T, Any]:
-            step = ContextPipelineStep(wp, dispatcher)
-            self.__steps.append(step)
-            return wp
-
-        return decorator(wrapped) if wrapped else decorator
-
-    def __new_pipeline[T](
-        self,
-        context: T,
-        context_type: type[T] | None,
-    ) -> Pipe[I, Any]:
-        pipeline: Pipe[I, Any] = Pipe(self.__dispatcher)
-        pipeline.add_middlewares(*self.__middlewares)
-
-        for step in self.__steps:
-            converter = step.converter.__get__(context, context_type)
-            pipeline.step(converter, dispatcher=step.dispatcher)
-
-        return pipeline
-
-
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class BoundContextPipeline[I, O](Dispatcher[I, O]):
-    context: O
-    pipeline: Pipe[I, Any]
-
-    async def dispatch(self, input_value: I, /) -> O:
-        await self.pipeline.dispatch(input_value)
-        return self.context