python-cq 0.22.1__tar.gz → 0.23.1__tar.gz

{python_cq-0.22.1 → python_cq-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-cq
-Version: 0.22.1
+Version: 0.23.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.22.1 → python_cq-0.23.1}/cq/__init__.py

@@ -1,9 +1,3 @@
-from ._core.cq import CQ
-from ._core.di import DIAdapter
-from ._core.di import NoDI as _NoDI
-from ._core.dispatchers.abc import Dispatcher
-from ._core.dispatchers.bus import Bus
-from ._core.dispatchers.pipe import ContextPipeline, Pipe
 from ._core.message import (
     AnyCommandBus,
     Command,
@@ -14,14 +8,20 @@ from ._core.message import (
     QueryBus,
 )
 from ._core.middleware import Middleware, MiddlewareResult, resolve_handler_source
-from ._core.pipetools import ContextCommandPipeline as _ContextCommandPipeline
-from ._core.pump import Pump
-from ._core.queues.abc import Consumer, Delivery, Producer, Queue
-from ._core.queues.memory import MemoryQueue
+from ._core.queuing.pump import Pump
+from ._core.queuing.queues.abc import Consumer, Delivery, Producer, Queue
+from ._core.queuing.queues.memory import MemoryQueue
 from ._core.related_events import AnyIORelatedEvents, RelatedEvents
+from ._core.routing.command_pipeline import (
+    ContextCommandPipeline as _ContextCommandPipeline,
+)
+from ._core.routing.di import DIAdapter
+from ._core.routing.dispatchers.abc import Dispatcher
+from ._core.routing.dispatchers.bus import Bus
+from ._core.routing.dispatchers.pipe import ContextPipeline, Pipe
+from ._core.routing.router import Router
 
 __all__ = (
-    "CQ",
     "AnyCommandBus",
     "AnyIORelatedEvents",
     "Bus",
@@ -45,7 +45,8 @@ __all__ = (
     "QueryBus",
     "Queue",
     "RelatedEvents",
-    "__cq__",
+    "Router",
+    "__router__",
     "command_handler",
     "event_handler",
     "new_command_bus",
@@ -55,28 +56,30 @@ __all__ = (
     "resolve_handler_source",
 )
 
+
 try:
-    from .ext.injection import InjectionAdapter as _InjectionAdapter
+    from .ext.injection import InjectionAdapter
 
 except ImportError:  # pragma: no cover
-    __cq__ = CQ(_NoDI())
+    __router__ = Router()
 
 else:
-    __cq__ = CQ(_InjectionAdapter())
+    __router__ = Router(InjectionAdapter())
+    del InjectionAdapter
 
-__cq__.register_defaults()
+__router__.register_defaults()
 
-command_handler = __cq__.command_handler
-event_handler = __cq__.event_handler
-query_handler = __cq__.query_handler
+command_handler = __router__.command_handler
+event_handler = __router__.event_handler
+query_handler = __router__.query_handler
 
-new_command_bus = __cq__.new_command_bus
-new_event_bus = __cq__.new_event_bus
-new_query_bus = __cq__.new_query_bus
+new_command_bus = __router__.new_command_bus
+new_event_bus = __router__.new_event_bus
+new_query_bus = __router__.new_query_bus
 
 
 class ContextCommandPipeline[C: Command](_ContextCommandPipeline[C]):
     __slots__ = ()
 
-    def __init__(self, di: DIAdapter = __cq__.di) -> None:
+    def __init__(self, di: DIAdapter = __router__.di) -> None:
         super().__init__(di)

{python_cq-0.22.1 → python_cq-0.23.1}/cq/_core/message.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from cq._core.dispatchers.abc import Dispatcher
+from cq._core.routing.dispatchers.abc import Dispatcher
 
 Command = object
 Event = object

{python_cq-0.22.1 → python_cq-0.23.1}/cq/_core/middleware.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass, field
 from inspect import isasyncgenfunction
 from typing import Any, Concatenate, Self, TypeGuard
 
-from cq._core.handler import HandleFunction, HandlerType
+from cq._core.routing.handler import HandleFunction, HandlerType
 from cq.exceptions import MiddlewareError
 
 type MiddlewareResult[T] = AsyncGenerator[None, T]

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/queuing}/pump.py

@@ -6,7 +6,7 @@ from typing import Any, Self
 import anyio
 
 from cq._core.middleware import Middleware, MiddlewareGroup
-from cq._core.queues.abc import Consumer
+from cq._core.queuing.queues.abc import Consumer
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/queuing}/queues/memory.py

@@ -7,8 +7,8 @@ import anyio
 from anyio.abc import ObjectReceiveStream, ObjectSendStream
 
 from cq._core.middleware import Middleware
-from cq._core.pump import Pump
-from cq._core.queues.abc import Delivery, Queue
+from cq._core.queuing.pump import Pump
+from cq._core.queuing.queues.abc import Delivery, Queue
 
 
 class MemoryQueue[T](Queue[T]):
@@ -17,7 +17,7 @@ class MemoryQueue[T](Queue[T]):
     __consumer: ObjectReceiveStream[T]
     __producer: ObjectSendStream[T]
 
-    def __init__(self, maxsize: int = 0) -> None:
+    def __init__(self, maxsize: float = 0) -> None:
         self.__producer, self.__consumer = anyio.create_memory_object_stream(maxsize)
 
     async def __aenter__(self) -> Self:

python_cq-0.22.1/cq/_core/pipetools.py → python_cq-0.23.1/cq/_core/routing/command_pipeline.py

@@ -1,16 +1,16 @@
 from typing import TYPE_CHECKING, Any, Self, overload
 
-from cq import Dispatcher
 from cq._core.common.typing import Decorator
-from cq._core.di import DIAdapter
-from cq._core.dispatchers.lazy import LazyDispatcher
-from cq._core.dispatchers.pipe import (
+from cq._core.message import Command, CommandBus, Query, QueryBus
+from cq._core.routing.di import DIAdapter
+from cq._core.routing.dispatchers.abc import Dispatcher
+from cq._core.routing.dispatchers.lazy import LazyDispatcher
+from cq._core.routing.dispatchers.pipe import (
     ContextPipeline,
     ConvertMethod,
     ConvertMethodAsync,
     ConvertMethodSync,
 )
-from cq._core.message import Command, CommandBus, Query, QueryBus
 
 
 class ContextCommandPipeline[C: Command](ContextPipeline[C]):

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/routing}/di.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from abc import abstractmethod
 from collections.abc import Awaitable, Callable
 from contextlib import nullcontext
-from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Any, Concatenate, Protocol, runtime_checkable
 
 from cq.middlewares.contextlib import AsyncContextManagerMiddleware
 
@@ -24,7 +24,7 @@ class DIAdapter(Protocol):
     __slots__ = ()
 
     @abstractmethod
-    def command_scope(self) -> Middleware[[Command], Any]:
+    def command_scope(self) -> Middleware[Concatenate[Command, ...], Any]:
         """
         Return a middleware that wraps each command dispatch.
 
@@ -88,7 +88,7 @@ class DIAdapter(Protocol):
 class NoDI(DIAdapter):
     __slots__ = ()
 
-    def command_scope(self) -> Middleware[[Command], Any]:
+    def command_scope(self) -> Middleware[Concatenate[Command, ...], Any]:
         return AsyncContextManagerMiddleware(nullcontext())
 
     def lazy[T](self, tp: type[T], /) -> Callable[[], Awaitable[T]]:

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/routing}/dispatchers/abc.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
-from typing import Protocol, Self, runtime_checkable
+from typing import Concatenate, Protocol, Self, runtime_checkable
 
 from cq._core.middleware import Middleware, MiddlewareGroup
 
@@ -20,18 +20,18 @@ class Dispatcher[I, O](Protocol):
 class BaseDispatcher[I, O](Dispatcher[I, O], ABC):
     __slots__ = ("__middleware_group",)
 
-    __middleware_group: MiddlewareGroup[[I], O]
+    __middleware_group: MiddlewareGroup[Concatenate[I, ...], O]
 
     def __init__(self) -> None:
         self.__middleware_group = MiddlewareGroup()
 
-    def add_middlewares(self, *middlewares: Middleware[[I], O]) -> Self:
+    def add_middlewares(self, *middlewares: Middleware[Concatenate[I, ...], O]) -> Self:
         self.__middleware_group.add(*middlewares)
         return self
 
     async def _invoke(
         self,
-        handler: Callable[[I], Awaitable[O]],
+        handler: Callable[Concatenate[I, ...], Awaitable[O]],
         message: I,
         /,
         fail_silently: bool = False,

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/routing}/dispatchers/bus.py

@@ -1,19 +1,19 @@
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, Iterator
-from typing import Any, Protocol, Self, runtime_checkable
+from typing import Any, Concatenate, Protocol, Self, runtime_checkable
 
 import anyio
 from anyio.abc import TaskGroup
 
-from cq._core.dispatchers.abc import BaseDispatcher, Dispatcher
-from cq._core.handler import (
+from cq._core.middleware import Middleware
+from cq._core.routing.dispatchers.abc import BaseDispatcher, Dispatcher
+from cq._core.routing.handler import (
     HandleFunction,
     HandlerFactory,
     HandlerRegistry,
     MultipleHandlerRegistry,
     SingleHandlerRegistry,
 )
-from cq._core.middleware import Middleware
 
 type Listener[T] = Callable[[T], Awaitable[Any]]
 
@@ -27,14 +27,14 @@ class Bus[I, O](Dispatcher[I, O], Protocol):
         raise NotImplementedError
 
     @abstractmethod
-    def add_middlewares(self, *middlewares: Middleware[[I], O]) -> Self:
+    def add_middlewares(self, *middlewares: Middleware[Concatenate[I, ...], O]) -> Self:
         raise NotImplementedError
 
     @abstractmethod
     def subscribe(
         self,
         message_type: type[I],
-        factory: HandlerFactory[[I], O],
+        factory: HandlerFactory[Concatenate[I, ...], O],
         fail_silently: bool = ...,
     ) -> Self:
         raise NotImplementedError
@@ -58,13 +58,16 @@ class BaseBus[I, O](BaseDispatcher[I, O], Bus[I, O], ABC):
     def subscribe(
         self,
         message_type: type[I],
-        factory: HandlerFactory[[I], O],
+        factory: HandlerFactory[Concatenate[I, ...], O],
         fail_silently: bool = False,
     ) -> Self:
         self.__registry.subscribe(message_type, factory, fail_silently=fail_silently)
         return self
 
-    def _handlers_from(self, message_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
+    def _handlers_from(
+        self,
+        message_type: type[I],
+    ) -> Iterator[HandleFunction[Concatenate[I, ...], O]]:
         return self.__registry.handlers_from(message_type)
 
     def _trigger_listeners(self, message: I, /, task_group: TaskGroup) -> None:
@@ -82,7 +85,7 @@ class SimpleBus[I, O](BaseBus[I, O]):
         async with anyio.create_task_group() as task_group:
             self._trigger_listeners(message, task_group)
 
-        for handler in self._handlers_from(type(message)):
+        for handler in self._handlers_from(message.__class__):
             return await self._invoke(handler, message, handler.fail_silently)
 
         return NotImplemented
@@ -98,7 +101,7 @@ class TaskBus[I](BaseBus[I, None]):
         async with anyio.create_task_group() as task_group:
             self._trigger_listeners(message, task_group)
 
-            for handler in self._handlers_from(type(message)):
+            for handler in self._handlers_from(message.__class__):
                 task_group.start_soon(
                     self._invoke,
                     handler,

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/routing}/dispatchers/lazy.py

@@ -2,8 +2,8 @@ from collections.abc import Awaitable, Callable
 from types import GenericAlias
 from typing import TypeAliasType
 
-from cq._core.di import DIAdapter
-from cq._core.dispatchers.abc import Dispatcher
+from cq._core.routing.di import DIAdapter
+from cq._core.routing.dispatchers.abc import Dispatcher
 
 
 class LazyDispatcher[I, O](Dispatcher[I, O]):

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/routing}/dispatchers/pipe.py

@@ -14,8 +14,8 @@ from typing import (
 )
 
 from cq._core.common.typing import Decorator, Method
-from cq._core.dispatchers.abc import BaseDispatcher, Dispatcher
 from cq._core.middleware import Middleware, MiddlewareGroup
+from cq._core.routing.dispatchers.abc import BaseDispatcher, Dispatcher
 
 type ConvertAsync[**P, I, O] = Callable[Concatenate[O, P], Awaitable[I]]
 type ConvertSync[**P, I, O] = Callable[Concatenate[O, P], I]

{python_cq-0.22.1/cq/_core → python_cq-0.23.1/cq/_core/routing}/handler.py

@@ -5,12 +5,20 @@ from dataclasses import dataclass, field
 from functools import partial
 from inspect import Parameter, isclass, unwrap
 from inspect import signature as inspect_signature
-from typing import TYPE_CHECKING, Any, Protocol, Self, overload, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Concatenate,
+    Protocol,
+    Self,
+    overload,
+    runtime_checkable,
+)
 
 from type_analyzer import MatchingTypesConfig, iter_matching_types, matching_types
 
 from cq._core.common.typing import Decorator
-from cq._core.di import DIAdapter, NoDI
+from cq._core.routing.di import DIAdapter, NoDI
 
 type HandlerType[**P, T] = type[Handler[P, T]]
 type HandlerFactory[**P, T] = Callable[..., Awaitable[Handler[P, T]]]
@@ -55,15 +63,18 @@ class HandlerRegistry[I, O](Protocol):
         raise NotImplementedError
 
     @abstractmethod
-    def handlers_from(self, message_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
+    def handlers_from(
+        self,
+        message_type: type[I],
+    ) -> Iterator[HandleFunction[Concatenate[I, ...], O]]:
         raise NotImplementedError
 
     @abstractmethod
     def subscribe(
         self,
         message_type: type[I],
-        handler_factory: HandlerFactory[[I], O],
-        handler_type: HandlerType[[I], O] | None = ...,
+        handler_factory: HandlerFactory[Concatenate[I, ...], O],
+        handler_type: HandlerType[Concatenate[I, ...], O] | None = ...,
         fail_silently: bool = ...,
     ) -> Self:
         raise NotImplementedError
@@ -71,7 +82,7 @@ class HandlerRegistry[I, O](Protocol):
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class MultipleHandlerRegistry[I, O](HandlerRegistry[I, O]):
-    __values: dict[type[I], list[HandleFunction[[I], O]]] = field(
+    __values: dict[type[I], list[HandleFunction[Concatenate[I, ...], O]]] = field(
         default_factory=partial(defaultdict, list),
         init=False,
     )
@@ -80,15 +91,18 @@ class MultipleHandlerRegistry[I, O](HandlerRegistry[I, O]):
     def message_types(self) -> KeysView[type[I]]:
         return self.__values.keys()
 
-    def handlers_from(self, message_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
+    def handlers_from(
+        self,
+        message_type: type[I],
+    ) -> Iterator[HandleFunction[Concatenate[I, ...], O]]:
         for key_type in _iter_key_types(message_type):
             yield from self.__values.get(key_type, ())
 
     def subscribe(
         self,
         message_type: type[I],
-        handler_factory: HandlerFactory[[I], O],
-        handler_type: HandlerType[[I], O] | None = None,
+        handler_factory: HandlerFactory[Concatenate[I, ...], O],
+        handler_type: HandlerType[Concatenate[I, ...], O] | None = None,
         fail_silently: bool = False,
     ) -> Self:
         function = HandleFunction.create(handler_factory, handler_type, fail_silently)
@@ -101,7 +115,7 @@ class MultipleHandlerRegistry[I, O](HandlerRegistry[I, O]):
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class SingleHandlerRegistry[I, O](HandlerRegistry[I, O]):
-    __values: dict[type[I], HandleFunction[[I], O]] = field(
+    __values: dict[type[I], HandleFunction[Concatenate[I, ...], O]] = field(
         default_factory=dict,
         init=False,
     )
@@ -110,7 +124,10 @@ class SingleHandlerRegistry[I, O](HandlerRegistry[I, O]):
     def message_types(self) -> KeysView[type[I]]:
         return self.__values.keys()
 
-    def handlers_from(self, message_type: type[I]) -> Iterator[HandleFunction[[I], O]]:
+    def handlers_from(
+        self,
+        message_type: type[I],
+    ) -> Iterator[HandleFunction[Concatenate[I, ...], O]]:
         for key_type in _iter_key_types(message_type):
             function = self.__values.get(key_type, None)
             if function is not None:
@@ -119,8 +136,8 @@ class SingleHandlerRegistry[I, O](HandlerRegistry[I, O]):
     def subscribe(
         self,
         message_type: type[I],
-        handler_factory: HandlerFactory[[I], O],
-        handler_type: HandlerType[[I], O] | None = None,
+        handler_factory: HandlerFactory[Concatenate[I, ...], O],
+        handler_type: HandlerType[Concatenate[I, ...], O] | None = None,
         fail_silently: bool = False,
     ) -> Self:
         function = HandleFunction.create(handler_factory, handler_type, fail_silently)
@@ -195,12 +212,12 @@ class HandlerDecorator[I, O]:
 
     def __decorator(
         self,
-        wrapped: HandlerType[[I], O],
+        wrapped: HandlerType[Concatenate[I, ...], O],
         /,
         *,
         message_type: type[I] | None = None,
         fail_silently: bool = False,
-    ) -> HandlerType[[I], O]:
+    ) -> HandlerType[Concatenate[I, ...], O]:
         factory = self.di.wire(wrapped)
         message_type = message_type or _resolve_message_type(wrapped)
         self.registry.subscribe(message_type, factory, wrapped, fail_silently)
@@ -221,7 +238,9 @@ def _iter_key_types(message_type: Any) -> Iterator[Any]:
     return iter_matching_types(message_type, config)
 
 
-def _resolve_message_type[I, O](handler_type: HandlerType[[I], O]) -> type[I]:
+def _resolve_message_type[I, O](
+    handler_type: HandlerType[Concatenate[I, ...], O],
+) -> type[I]:
     fake_method = handler_type.handle.__get__(NotImplemented, handler_type)
     signature = inspect_signature(fake_method, eval_str=True)
 

python_cq-0.22.1/cq/_core/cq.py → python_cq-0.23.1/cq/_core/routing/router.py

@@ -1,18 +1,18 @@
 from collections.abc import KeysView
 from typing import Any, Self
 
-from cq._core.di import DIAdapter
-from cq._core.dispatchers.bus import Bus, SimpleBus, TaskBus
-from cq._core.handler import (
+from cq._core.message import Command, Event, Query
+from cq._core.routing.di import DIAdapter, NoDI
+from cq._core.routing.dispatchers.bus import Bus, SimpleBus, TaskBus
+from cq._core.routing.handler import (
     HandlerDecorator,
     HandlerRegistry,
     MultipleHandlerRegistry,
     SingleHandlerRegistry,
 )
-from cq._core.message import Command, Event, Query
 
 
-class CQ:
+class Router:
     __slots__ = ("__command_registry", "__di", "__event_registry", "__query_registry")
 
     __command_registry: HandlerRegistry[Command, Any]
@@ -20,8 +20,8 @@ class CQ:
     __event_registry: HandlerRegistry[Event, Any]
     __query_registry: HandlerRegistry[Query, Any]
 
-    def __init__(self, di: DIAdapter, /) -> None:
-        self.__di = di
+    def __init__(self, di: DIAdapter | None = None, /) -> None:
+        self.__di = di or NoDI()
         self.__command_registry = SingleHandlerRegistry()
         self.__event_registry = MultipleHandlerRegistry()
         self.__query_registry = SingleHandlerRegistry()

{python_cq-0.22.1 → python_cq-0.23.1}/cq/ext/injection.py

@@ -2,15 +2,15 @@ from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import AsyncExitStack
 from dataclasses import dataclass, field
 from enum import StrEnum
-from typing import Any
+from typing import Any, Concatenate
 
 from injection import Module, adefine_scope, mod
 from injection.exceptions import ScopeAlreadyDefinedError
 
-from cq._core.di import DIAdapter
 from cq._core.message import Command, CommandBus, EventBus, QueryBus
 from cq._core.middleware import Middleware, MiddlewareResult
 from cq._core.related_events import AnyIORelatedEvents, RelatedEvents
+from cq._core.routing.di import DIAdapter
 
 __all__ = ("CQScope", "InjectionAdapter", "InjectionScopeMiddleware")
 
@@ -24,7 +24,7 @@ class InjectionAdapter(DIAdapter):
     module: Module = field(default_factory=mod)
     threadsafe: bool | None = field(default=None)
 
-    def command_scope(self) -> Middleware[[Command], Any]:
+    def command_scope(self) -> Middleware[Concatenate[Command, ...], Any]:
         return InjectionScopeMiddleware(
             CQScope.COMMAND_DISPATCH,
             threadsafe=self.threadsafe,

{python_cq-0.22.1 → python_cq-0.23.1}/pyproject.toml

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