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

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

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

{python_cq-0.11.0 → python_cq-0.11.1}/cq/_core/dispatcher/pipe.py

@@ -1,7 +1,7 @@
 from collections import deque
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import Any, Protocol, Self, overload
+from typing import TYPE_CHECKING, Any, Protocol, Self, overload
 
 from cq._core.dispatcher.base import BaseDispatcher, Dispatcher
 from cq._core.middleware import Middleware
@@ -34,23 +34,25 @@ class Pipe[I, O](BaseDispatcher[I, O]):
         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]]: ...
+    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,
@@ -114,23 +116,33 @@ class ContextPipeline[I]:
         self.__middlewares = deque()
         self.__steps = []
 
-    @overload
-    def __get__[O](
-        self,
-        instance: O,
-        owner: type[O] | None = ...,
-    ) -> Dispatcher[I, O]: ...
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        def __get__[O](self, instance: None, owner: type[O], /) -> Dispatcher[I, O]: ...
 
-    @overload
-    def __get__(self, instance: None = ..., owner: type | None = ...) -> Self: ...
+        @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:
-            return self
+            if owner is None:
+                return self
+
+            instance = owner()
 
         pipeline = self.__new_pipeline(instance, owner)
         return BoundContextPipeline(instance, pipeline)
@@ -139,23 +151,25 @@ class ContextPipeline[I]:
         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]]: ...
+    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,

{python_cq-0.11.0 → python_cq-0.11.1}/cq/_core/handler.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from functools import partial
 from inspect import Parameter, getmro, isclass
 from inspect import signature as inspect_signature
-from typing import Any, Protocol, Self, overload, runtime_checkable
+from typing import TYPE_CHECKING, Any, Protocol, Self, overload, runtime_checkable
 
 import injection
 
@@ -89,32 +89,34 @@ class HandlerDecorator[I, O]:
     manager: HandlerManager[I, O]
     injection_module: injection.Module = field(default_factory=injection.mod)
 
-    @overload
-    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]]: ...
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        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,

{python_cq-0.11.0 → python_cq-0.11.1}/cq/ext/fastapi.py

@@ -53,7 +53,7 @@ async def new_deferred_query_bus[T](
     return FastAPIDeferredDispatcher(background_tasks, query_bus)
 
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     type DeferredCommandBus = DeferredDispatcher[Command]
     type DeferredEventBus = DeferredDispatcher[Event]
     type DeferredQueryBus = DeferredDispatcher[Query]

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

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