python-cq 0.9.1__tar.gz → 0.11.0__tar.gz

{python_cq-0.9.1 → python_cq-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cq
-Version: 0.9.1
+Version: 0.11.0
 Summary: Lightweight CQRS library for async Python projects.
 Project-URL: Repository, https://github.com/100nm/python-cq
 Author: remimd

{python_cq-0.9.1 → python_cq-0.11.0}/cq/__init__.py

@@ -1,6 +1,7 @@
-from ._core.defer import DeferredBus
+from ._core.dispatcher.base import DeferredDispatcher, Dispatcher
 from ._core.dispatcher.bus import Bus
-from ._core.dispatcher.pipe import Pipe
+from ._core.dispatcher.lazy import LazyDispatcher
+from ._core.dispatcher.pipe import ContextPipeline, Pipe
 from ._core.message import (
     AnyCommandBus,
     Command,
@@ -17,6 +18,7 @@ from ._core.message import (
     query_handler,
 )
 from ._core.middleware import Middleware, MiddlewareResult
+from ._core.pipetools import ContextCommandPipeline
 from ._core.related_events import RelatedEvents
 from ._core.scope import CQScope
 
@@ -26,9 +28,13 @@ __all__ = (
     "CQScope",
     "Command",
     "CommandBus",
-    "DeferredBus",
+    "ContextCommandPipeline",
+    "ContextPipeline",
+    "DeferredDispatcher",
+    "Dispatcher",
     "Event",
     "EventBus",
+    "LazyDispatcher",
     "Middleware",
     "MiddlewareResult",
     "Pipe",

{python_cq-0.9.1 → python_cq-0.11.0}/cq/_core/dispatcher/base.py

@@ -13,8 +13,13 @@ class Dispatcher[I, O](Protocol):
     async def dispatch(self, input_value: I, /) -> O:
         raise NotImplementedError
 
+
+@runtime_checkable
+class DeferredDispatcher[I](Protocol):
+    __slots__ = ()
+
     @abstractmethod
-    def add_middlewares(self, *middlewares: Middleware[[I], O]) -> Self:
+    async def defer(self, input_value: I, /) -> None:
         raise NotImplementedError
 
 

{python_cq-0.9.1 → python_cq-0.11.0}/cq/_core/dispatcher/bus.py

@@ -12,6 +12,7 @@ from cq._core.handler import (
     MultipleHandlerManager,
     SingleHandlerManager,
 )
+from cq._core.middleware import Middleware
 
 type Listener[T] = Callable[[T], Awaitable[Any]]
 
@@ -21,11 +22,15 @@ class Bus[I, O](Dispatcher[I, O], Protocol):
     __slots__ = ()
 
     @abstractmethod
-    def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
+    def add_listeners(self, *listeners: Listener[I]) -> Self:
         raise NotImplementedError
 
     @abstractmethod
-    def add_listeners(self, *listeners: Listener[I]) -> Self:
+    def add_middlewares(self, *middlewares: Middleware[[I], O]) -> Self:
+        raise NotImplementedError
+
+    @abstractmethod
+    def subscribe(self, input_type: type[I], factory: HandlerFactory[[I], O]) -> Self:
         raise NotImplementedError
 
 

python_cq-0.11.0/cq/_core/dispatcher/lazy.py

@@ -0,0 +1,28 @@
+from collections.abc import Awaitable
+from types import GenericAlias
+from typing import TypeAliasType
+
+import injection
+
+from cq._core.dispatcher.base import Dispatcher
+
+
+class LazyDispatcher[I, O](Dispatcher[I, O]):
+    __slots__ = ("__value",)
+
+    __value: Awaitable[Dispatcher[I, O]]
+
+    def __init__(
+        self,
+        dispatcher_type: type[Dispatcher[I, O]] | TypeAliasType | GenericAlias,
+        /,
+        *,
+        injection_module: injection.Module | None = None,
+        threadsafe: bool | None = None,
+    ) -> None:
+        module = injection_module or injection.mod()
+        self.__value = module.aget_lazy_instance(dispatcher_type, threadsafe=threadsafe)
+
+    async def dispatch(self, input_value: I, /) -> O:
+        dispatcher = await self.__value
+        return await dispatcher.dispatch(input_value)

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

@@ -0,0 +1,196 @@
+from collections import deque
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import 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 = []
+
+    @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 = []
+
+    @overload
+    def __get__[O](
+        self,
+        instance: O,
+        owner: type[O] | None = ...,
+    ) -> Dispatcher[I, O]: ...
+
+    @overload
+    def __get__(self, instance: None = ..., owner: type | None = ...) -> Self: ...
+
+    def __get__[O](
+        self,
+        instance: O | None = None,
+        owner: type[O] | None = None,
+    ) -> Self | Dispatcher[I, O]:
+        if instance is None:
+            return self
+
+        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
+
+    @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

python_cq-0.11.0/cq/_core/pipetools.py

@@ -0,0 +1,31 @@
+import injection
+
+from cq._core.dispatcher.lazy import LazyDispatcher
+from cq._core.dispatcher.pipe import ContextPipeline
+from cq._core.message import AnyCommandBus, Command
+from cq._core.scope import CQScope
+from cq.middlewares.scope import InjectionScopeMiddleware
+
+
+class ContextCommandPipeline[I: Command](ContextPipeline[I]):
+    __slots__ = ()
+
+    def __init__(
+        self,
+        /,
+        *,
+        injection_module: injection.Module | None = None,
+        threadsafe: bool | None = None,
+    ) -> None:
+        dispatcher = LazyDispatcher(
+            AnyCommandBus,
+            injection_module=injection_module,
+            threadsafe=threadsafe,
+        )
+        super().__init__(dispatcher)
+        transaction_scope_middleware = InjectionScopeMiddleware(
+            CQScope.TRANSACTION,
+            exist_ok=True,
+            threadsafe=threadsafe,
+        )
+        self.add_middlewares(transaction_scope_middleware)

python_cq-0.11.0/cq/ext/fastapi.py

@@ -0,0 +1,73 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Annotated, Any
+
+from fastapi import BackgroundTasks, Depends
+from injection.ext.fastapi import Inject
+
+from cq import (
+    Command,
+    CommandBus,
+    DeferredDispatcher,
+    Dispatcher,
+    Event,
+    EventBus,
+    Query,
+    QueryBus,
+)
+
+__all__ = (
+    "DeferredCommandBus",
+    "DeferredEventBus",
+    "DeferredQueryBus",
+    "FastAPIDeferredDispatcher",
+)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class FastAPIDeferredDispatcher[I](DeferredDispatcher[I]):
+    background_tasks: BackgroundTasks
+    dispatcher: Dispatcher[I, Any]
+
+    async def defer(self, input_value: I, /) -> None:
+        self.background_tasks.add_task(self.dispatcher.dispatch, input_value)
+
+
+async def new_deferred_command_bus[T](
+    background_tasks: BackgroundTasks,
+    command_bus: Inject[CommandBus[T]],
+) -> DeferredDispatcher[Command]:
+    return FastAPIDeferredDispatcher(background_tasks, command_bus)
+
+
+async def new_deferred_event_bus(
+    background_tasks: BackgroundTasks,
+    event_bus: Inject[EventBus],
+) -> DeferredDispatcher[Event]:
+    return FastAPIDeferredDispatcher(background_tasks, event_bus)
+
+
+async def new_deferred_query_bus[T](
+    background_tasks: BackgroundTasks,
+    query_bus: Inject[QueryBus[T]],
+) -> DeferredDispatcher[Query]:
+    return FastAPIDeferredDispatcher(background_tasks, query_bus)
+
+
+if TYPE_CHECKING:
+    type DeferredCommandBus = DeferredDispatcher[Command]
+    type DeferredEventBus = DeferredDispatcher[Event]
+    type DeferredQueryBus = DeferredDispatcher[Query]
+
+else:
+    DeferredCommandBus = Annotated[
+        DeferredDispatcher[Command],
+        Depends(new_deferred_command_bus, use_cache=False),
+    ]
+    DeferredEventBus = Annotated[
+        DeferredDispatcher[Event],
+        Depends(new_deferred_event_bus, use_cache=False),
+    ]
+    DeferredQueryBus = Annotated[
+        DeferredDispatcher[Query],
+        Depends(new_deferred_query_bus, use_cache=False),
+    ]

{python_cq-0.9.1 → python_cq-0.11.0}/pyproject.toml

@@ -23,7 +23,7 @@ test = [
 
 [project]
 name = "python-cq"
-version = "0.9.1"
+version = "0.11.0"
 description = "Lightweight CQRS library for async Python projects."
 license = "MIT"
 license-files = ["LICENSE"]

python_cq-0.9.1/cq/_core/defer.py

@@ -1,10 +0,0 @@
-from abc import abstractmethod
-from typing import Protocol
-
-
-class DeferredBus[I](Protocol):
-    __slots__ = ()
-
-    @abstractmethod
-    async def defer(self, input_value: I, /) -> None:
-        raise NotImplementedError

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

@@ -1,82 +0,0 @@
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
-from typing import Any, Self, overload
-
-from cq._core.dispatcher.base import BaseDispatcher, Dispatcher
-
-type PipeConverter[I, O] = Callable[[O], Awaitable[I]]
-
-
-@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 = []
-
-    @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)
-            dispatcher = step.dispatcher or self.__dispatcher
-
-        return await dispatcher.dispatch(input_value)

python_cq-0.9.1/cq/ext/fastapi.py

@@ -1,44 +0,0 @@
-from dataclasses import dataclass
-from typing import Annotated, Any
-
-from fastapi import BackgroundTasks, Depends
-from injection.ext.fastapi import Inject
-
-from cq import Bus, Command, CommandBus, DeferredBus, Event, EventBus, Query, QueryBus
-
-__all__ = ("DeferredCommandBus", "DeferredEventBus", "DeferredQueryBus")
-
-
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class FastAPIDeferredBus[I](DeferredBus[I]):
-    background_tasks: BackgroundTasks
-    bus: Bus[I, Any]
-
-    async def defer(self, input_value: I, /) -> None:
-        self.background_tasks.add_task(self.bus.dispatch, input_value)
-
-
-async def new_deferred_command_bus[T](
-    background_tasks: BackgroundTasks,
-    command_bus: Inject[CommandBus[T]],
-) -> DeferredBus[Command]:
-    return FastAPIDeferredBus(background_tasks, command_bus)
-
-
-async def new_deferred_event_bus(
-    background_tasks: BackgroundTasks,
-    event_bus: Inject[EventBus],
-) -> DeferredBus[Event]:
-    return FastAPIDeferredBus(background_tasks, event_bus)
-
-
-async def new_deferred_query_bus[T](
-    background_tasks: BackgroundTasks,
-    query_bus: Inject[QueryBus[T]],
-) -> DeferredBus[Query]:
-    return FastAPIDeferredBus(background_tasks, query_bus)
-
-
-DeferredCommandBus = Annotated[DeferredBus[Command], Depends(new_deferred_command_bus)]
-DeferredEventBus = Annotated[DeferredBus[Event], Depends(new_deferred_event_bus)]
-DeferredQueryBus = Annotated[DeferredBus[Query], Depends(new_deferred_query_bus)]

python_cq-0.9.1/cq/ext/fastapi.pyi

@@ -1,5 +0,0 @@
-from cq import Command, DeferredBus, Event, Query
-
-type DeferredCommandBus = DeferredBus[Command]
-type DeferredEventBus = DeferredBus[Event]
-type DeferredQueryBus = DeferredBus[Query]