python-cqrs 4.2.0__tar.gz → 4.3.1__tar.gz

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cqrs
-Version: 4.2.0
+Version: 4.3.1
 Summary: Python CQRS pattern implementation
 Author-email: Vadim Kozyrevskiy <vadikko2@mail.ru>, Dmitry Kutlubaev <kutlubaev00@mail.ru>
 Maintainer-email: Vadim Kozyrevskiy <vadikko2@mail.ru>
@@ -18,7 +18,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic==2.*
 Requires-Dist: orjson==3.9.15
-Requires-Dist: aio-pika==9.3.0
 Requires-Dist: di[anyio]==0.79.2
 Requires-Dist: sqlalchemy[asyncio]==2.0.*
 Requires-Dist: retry-async==0.1.4
@@ -46,6 +45,8 @@ Requires-Dist: aiokafka==0.10.0; extra == "kafka"
 Requires-Dist: confluent-kafka==2.6.0; extra == "kafka"
 Provides-Extra: protobuf
 Requires-Dist: protobuf==4.25.5; extra == "protobuf"
+Provides-Extra: rabbit
+Requires-Dist: aio-pika==9.3.0; extra == "rabbit"
 Dynamic: license-file
 
 # Python CQRS pattern implementation with Transaction Outbox supporting
@@ -70,7 +71,8 @@ project ([documentation](https://akhundmurad.github.io/diator/)) with several en
 8. FastStream supporting;
 9. [Protobuf](https://protobuf.dev/) events supporting;
 10. `StreamingRequestMediator` and `StreamingRequestHandler` for handling streaming requests with real-time progress updates;
-11. Parallel event processing with configurable concurrency limits.
+11. Parallel event processing with configurable concurrency limits;
+12. Chain of Responsibility pattern support with `CORRequestHandler` for processing requests through multiple handlers in sequence.
 
 ## Request Handlers
 
@@ -171,6 +173,9 @@ class ProcessFilesCommandHandler(StreamingRequestHandler[ProcessFilesCommand, Fi
     def events(self) -> list[Event]:
         return self._events.copy()
 
+    def clear_events(self) -> None:
+        self._events.clear()
+
     async def handle(self, request: ProcessFilesCommand) -> typing.AsyncIterator[FileProcessedResult]:
         for file_id in request.file_ids:
             # Process file
@@ -178,12 +183,74 @@ class ProcessFilesCommandHandler(StreamingRequestHandler[ProcessFilesCommand, Fi
             # Emit events
             self._events.append(FileProcessedEvent(file_id=file_id, ...))
             yield result
-            self._events.clear()
 ```
 
 A complete example can be found in
 the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/streaming_handler_parallel_events.py)
 
+### Chain of Responsibility Request Handler
+
+Chain of Responsibility Request Handler implements the chain of responsibility pattern, allowing multiple handlers
+to process a request in sequence until one successfully handles it. This pattern is particularly useful when you have
+multiple processing strategies or need to implement fallback mechanisms.
+
+Each handler in the chain decides whether to process the request or pass it to the next handler. The chain stops
+when a handler successfully processes the request or when all handlers have been exhausted.
+
+```python
+import typing
+from cqrs.requests.cor_request_handler import CORRequestHandler
+from cqrs.events.event import Event
+
+class CreditCardPaymentHandler(CORRequestHandler[ProcessPaymentCommand, PaymentResult]):
+    def __init__(self, payment_service: PaymentServiceProtocol) -> None:
+        self._payment_service = payment_service
+        self._events: typing.List[Event] = []
+
+    @property
+    def events(self) -> typing.List[Event]:
+        return self._events
+
+    async def handle(self, request: ProcessPaymentCommand) -> PaymentResult | None:
+        if request.payment_method == "credit_card":
+            # Process credit card payment
+            result = await self._payment_service.process_credit_card(request)
+            self._events.append(PaymentProcessedEvent(...))
+            return PaymentResult(success=True, transaction_id=result.id)
+
+        # Pass to next handler
+        return await self.next(request)
+
+class PayPalPaymentHandler(CORRequestHandler[ProcessPaymentCommand, PaymentResult]):
+    def __init__(self, paypal_service: PayPalServiceProtocol) -> None:
+        self._paypal_service = paypal_service
+        self._events: typing.List[Event] = []
+
+    @property
+    def events(self) -> typing.List[Event]:
+        return self._events
+
+    async def handle(self, request: ProcessPaymentCommand) -> PaymentResult | None:
+        if request.payment_method == "paypal":
+            # Process PayPal payment
+            result = await self._paypal_service.process_payment(request)
+            return PaymentResult(success=True, transaction_id=result.id)
+
+        # Pass to next handler
+        return await self.next(request)
+
+# Chain registration
+def payment_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ProcessPaymentCommand, [
+        CreditCardPaymentHandler,
+        PayPalPaymentHandler,
+        DefaultPaymentHandler  # Fallback handler
+    ])
+```
+
+A complete example can be found in
+the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/cor_request_handler.py)
+
 ## Event Handlers
 
 Event handlers are designed to process `Notification` and `ECST` events that are consumed from the broker.

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/README.md

@@ -20,7 +20,8 @@ project ([documentation](https://akhundmurad.github.io/diator/)) with several en
 8. FastStream supporting;
 9. [Protobuf](https://protobuf.dev/) events supporting;
 10. `StreamingRequestMediator` and `StreamingRequestHandler` for handling streaming requests with real-time progress updates;
-11. Parallel event processing with configurable concurrency limits.
+11. Parallel event processing with configurable concurrency limits;
+12. Chain of Responsibility pattern support with `CORRequestHandler` for processing requests through multiple handlers in sequence.
 
 ## Request Handlers
 
@@ -121,6 +122,9 @@ class ProcessFilesCommandHandler(StreamingRequestHandler[ProcessFilesCommand, Fi
     def events(self) -> list[Event]:
         return self._events.copy()
 
+    def clear_events(self) -> None:
+        self._events.clear()
+
     async def handle(self, request: ProcessFilesCommand) -> typing.AsyncIterator[FileProcessedResult]:
         for file_id in request.file_ids:
             # Process file
@@ -128,12 +132,74 @@ class ProcessFilesCommandHandler(StreamingRequestHandler[ProcessFilesCommand, Fi
             # Emit events
             self._events.append(FileProcessedEvent(file_id=file_id, ...))
             yield result
-            self._events.clear()
 ```
 
 A complete example can be found in
 the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/streaming_handler_parallel_events.py)
 
+### Chain of Responsibility Request Handler
+
+Chain of Responsibility Request Handler implements the chain of responsibility pattern, allowing multiple handlers
+to process a request in sequence until one successfully handles it. This pattern is particularly useful when you have
+multiple processing strategies or need to implement fallback mechanisms.
+
+Each handler in the chain decides whether to process the request or pass it to the next handler. The chain stops
+when a handler successfully processes the request or when all handlers have been exhausted.
+
+```python
+import typing
+from cqrs.requests.cor_request_handler import CORRequestHandler
+from cqrs.events.event import Event
+
+class CreditCardPaymentHandler(CORRequestHandler[ProcessPaymentCommand, PaymentResult]):
+    def __init__(self, payment_service: PaymentServiceProtocol) -> None:
+        self._payment_service = payment_service
+        self._events: typing.List[Event] = []
+
+    @property
+    def events(self) -> typing.List[Event]:
+        return self._events
+
+    async def handle(self, request: ProcessPaymentCommand) -> PaymentResult | None:
+        if request.payment_method == "credit_card":
+            # Process credit card payment
+            result = await self._payment_service.process_credit_card(request)
+            self._events.append(PaymentProcessedEvent(...))
+            return PaymentResult(success=True, transaction_id=result.id)
+
+        # Pass to next handler
+        return await self.next(request)
+
+class PayPalPaymentHandler(CORRequestHandler[ProcessPaymentCommand, PaymentResult]):
+    def __init__(self, paypal_service: PayPalServiceProtocol) -> None:
+        self._paypal_service = paypal_service
+        self._events: typing.List[Event] = []
+
+    @property
+    def events(self) -> typing.List[Event]:
+        return self._events
+
+    async def handle(self, request: ProcessPaymentCommand) -> PaymentResult | None:
+        if request.payment_method == "paypal":
+            # Process PayPal payment
+            result = await self._paypal_service.process_payment(request)
+            return PaymentResult(success=True, transaction_id=result.id)
+
+        # Pass to next handler
+        return await self.next(request)
+
+# Chain registration
+def payment_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ProcessPaymentCommand, [
+        CreditCardPaymentHandler,
+        PayPalPaymentHandler,
+        DefaultPaymentHandler  # Fallback handler
+    ])
+```
+
+A complete example can be found in
+the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/cor_request_handler.py)
+
 ## Event Handlers
 
 Event handlers are designed to process `Notification` and `ECST` events that are consumed from the broker.

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/pyproject.toml

@@ -18,7 +18,6 @@ classifiers = [
 dependencies = [
   "pydantic==2.*",
   "orjson==3.9.15",
-  "aio-pika==9.3.0",
   "di[anyio]==0.79.2",
   "sqlalchemy[asyncio]==2.0.*",
   "retry-async==0.1.4",
@@ -30,7 +29,7 @@ maintainers = [{name = "Vadim Kozyrevskiy", email = "vadikko2@mail.ru"}]
 name = "python-cqrs"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "4.2.0"
+version = "4.3.1"
 
 [project.optional-dependencies]
 dev = [
@@ -60,6 +59,9 @@ kafka = [
   "confluent-kafka==2.6.0"
 ]
 protobuf = ["protobuf==4.25.5"]
+rabbit = [
+  "aio-pika==9.3.0"
+]
 
 [project.urls]
 Documentation = "https://vadikko2.github.io/python-cqrs-mkdocs/"

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/src/cqrs/dispatcher/dispatcher.py

@@ -3,6 +3,7 @@ import functools
 import inspect
 import logging
 import typing
+from collections import abc
 
 import pydantic
 
@@ -15,13 +16,17 @@ from cqrs import (
 )
 from cqrs.events import event_handler
 from cqrs.requests import request_handler
+from cqrs.requests import cor_request_handler
 
 logger = logging.getLogger("cqrs")
 
 _Resp = typing.TypeVar("_Resp", resp.Response, None, contravariant=True)
 
 _RequestHandler: typing.TypeAlias = (
-    request_handler.RequestHandler | request_handler.SyncRequestHandler
+    request_handler.RequestHandler
+    | request_handler.SyncRequestHandler
+    | cor_request_handler.CORRequestHandler
+    | cor_request_handler.SyncCORRequestHandler
 )
 _StreamingRequestHandler: typing.TypeAlias = (
     request_handler.StreamingRequestHandler
@@ -36,6 +41,10 @@ class RequestHandlerDoesNotExist(Exception):
     pass
 
 
+class RequestHandlerTypeError(Exception):
+    pass
+
+
 class RequestDispatchResult(pydantic.BaseModel, typing.Generic[_Resp]):
     response: _Resp = pydantic.Field(default=None)
     events: typing.List[cqrs_events.Event] = pydantic.Field(default_factory=list)
@@ -52,13 +61,34 @@ class RequestDispatcher:
         self._container = container
         self._middleware_chain = middleware_chain or middlewares.MiddlewareChain()
 
+    async def _resolve_handler(self, handler_type: typing.Type[_RequestHandler] | typing.List[typing.Type[_RequestHandler]]) -> _RequestHandler:
+        """
+        Resolve a single handler or build a chain from multiple handlers.
+
+        For single handlers, resolves them using the DI container.
+        For lists of handlers, validates they are COR handlers and builds a chain.
+        """
+        if isinstance(handler_type, abc.Iterable):
+            if not all(issubclass(handler_cls, (
+                    cor_request_handler.CORRequestHandler,
+                    cor_request_handler.SyncCORRequestHandler
+            )) for handler_cls in handler_type):
+                raise RequestHandlerTypeError(f"COR handler must be type CORRequestHandler or SyncCORRequestHandler")
+
+            async with asyncio.TaskGroup() as tg:
+                tasks = [tg.create_task(self._container.resolve(h)) for h in handler_type]
+            handlers = [task.result() for task in tasks]
+            return cor_request_handler.build_chain(handlers)
+
+        return await self._container.resolve(handler_type)
+
     async def dispatch(self, request: requests.Request) -> RequestDispatchResult:
         handler_type = self._request_map.get(type(request), None)
-        if handler_type is None:
+        if not handler_type:
             raise RequestHandlerDoesNotExist(
                 f"RequestHandler not found matching Request type {type(request)}",
             )
-        handler: _RequestHandler = await self._container.resolve(handler_type)
+        handler: _RequestHandler = await self._resolve_handler(handler_type)
         if asyncio.iscoroutinefunction(handler.handle):
             wrapped_handle = self._middleware_chain.wrap(handler.handle)
         else:

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/src/cqrs/requests/bootstrap.py

@@ -18,7 +18,7 @@ def setup_event_emitter(
     container: di_container_impl.DIContainer,
     domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
     message_broker: protocol.MessageBroker | None = None,
-): ...
+) -> events.EventEmitter: ...
 
 
 @overload
@@ -33,7 +33,7 @@ def setup_event_emitter(
     container: di_container_impl.DIContainer | CQRSContainer,
     domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
     message_broker: protocol.MessageBroker | None = None,
-):
+) -> events.EventEmitter:
     if message_broker is None:
         message_broker = DEFAULT_MESSAGE_BROKER
     event_mapper = events.EventMap()

python_cqrs-4.3.1/src/cqrs/requests/cor_request_handler.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+import abc
+import functools
+import typing
+
+from cqrs import response
+from cqrs.events import event
+from cqrs.requests import request as r
+
+_Req = typing.TypeVar("_Req", bound=r.Request, contravariant=True)
+_Resp = typing.TypeVar("_Resp", response.Response, None, covariant=True)
+
+
+class CORRequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
+    """
+    The chain of responsibility request handler interface.
+
+    Implements the chain of responsibility pattern, allowing multiple handlers
+    to process a request in sequence until one handles it successfully.
+
+    Chain handler example::
+
+      class AuthenticationHandler(CORRequestHandler[LoginCommand, None]):
+          def __init__(self, auth_service: AuthServiceProtocol) -> None:
+              self._auth_service = auth_service
+              self.events: typing.List[Event] = []
+
+          async def handle(self, request: LoginCommand) -> None | None:
+              if self._auth_service.can_authenticate(request):
+                  return await self._auth_service.authenticate(request)
+              return await super().handle(request)
+    """
+
+    _next_handler: "CORRequestHandler" = None
+
+    def set_next(self, handler: "CORRequestHandler") -> "CORRequestHandler":
+        if self._next_handler is None:
+            self._next_handler = handler
+
+        return self._next_handler
+
+    async def next(self, request: _Req) -> _Resp:
+        if self._next_handler:
+            return await self._next_handler.handle(request)
+
+        return None
+
+    @property
+    @abc.abstractmethod
+    def events(self) -> typing.List[event.Event]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def handle(self, request: _Req) -> _Resp:
+        raise NotImplementedError
+
+
+class SyncCORRequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
+    """
+    The synchronous chain of responsibility request handler interface.
+
+    Implements the chain of responsibility pattern, allowing multiple handlers
+    to process a request in sequence until one handles it successfully.
+
+    Chain handler example::
+
+      class AuthenticationHandler(SyncCORRequestHandler[LoginCommand, None]):
+          def __init__(self, auth_service: AuthServiceProtocol) -> None:
+              self._auth_service = auth_service
+              self.events: typing.List[Event] = []
+
+          def handle(self, request: LoginCommand) -> None | None:
+              if self._auth_service.can_authenticate(request):
+                  return self._auth_service.authenticate(request)
+              return super().handle(request)
+    """
+
+    _next_handler: "SyncCORRequestHandler" = None
+
+    def set_next(self, handler: "SyncCORRequestHandler") -> "SyncCORRequestHandler":
+        if self._next_handler is None:
+            self._next_handler = handler
+
+        return self._next_handler
+
+    def next(self, request: _Req) -> _Resp:
+        if self._next_handler:
+            return self._next_handler.handle(request)
+
+        return None
+
+    @property
+    @abc.abstractmethod
+    def events(self) -> typing.List[event.Event]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def handle(self, request: _Req) -> _Resp:
+        raise NotImplementedError
+
+
+_RequestHandler: typing.TypeAlias = CORRequestHandler | SyncCORRequestHandler
+
+
+def build_chain(handlers: typing.List[_RequestHandler]) -> _RequestHandler:
+    """
+    Build a chain of responsibility from a list of handlers.
+
+    Links handlers together in the order they appear in the list,
+    with each handler pointing to the next one in sequence.
+
+    Args:
+        handlers: List of handlers to be linked together
+
+    Returns:
+        The first handler in the chain
+    """
+
+    def link(handler1, handler2):
+        handler1.set_next(handler2)
+        return handler2
+
+    functools.reduce(link, handlers)
+    return handlers[0]

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/src/cqrs/requests/map.py

@@ -1,13 +1,17 @@
 import typing
 
-from cqrs.requests import request, request_handler
+from cqrs.requests import request, request_handler, cor_request_handler
 
 _KT = typing.TypeVar("_KT", bound=typing.Type[request.Request])
 _VT = typing.TypeVar(
     "_VT",
     bound=typing.Type[
         request_handler.RequestHandler | request_handler.SyncRequestHandler
-    ],
+    ]
+    | typing.List[typing.Type[cor_request_handler.CORRequestHandler]]
+    | typing.List[typing.Type[cor_request_handler.SyncCORRequestHandler]]
+    | typing.Type[request_handler.StreamingRequestHandler]
+    | typing.Type[request_handler.SyncStreamingRequestHandler],
 )
 
 

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/src/cqrs/requests/request_handler.py

@@ -105,6 +105,9 @@ class StreamingRequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
           def events(self) -> list[Event]:
               return self._events.copy()
 
+          def clear_events(self) -> None:
+              self._events.clear()
+
           async def handle(self, request: ProcessItemsCommand) -> typing.AsyncIterator[ProcessItemResult]:
               for item_id in request.item_ids:
                   result = await self._items_api.process_item(item_id)
@@ -121,6 +124,7 @@ class StreamingRequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
     async def handle(self, request: _Req) -> typing.AsyncIterator[_Resp]:
         raise NotImplementedError
 
+    @abc.abstractmethod
     def clear_events(self) -> None:
         """
         Clear events that have been processed.
@@ -150,6 +154,9 @@ class SyncStreamingRequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
           def events(self) -> list[Event]:
               return self._events.copy()
 
+          def clear_events(self) -> None:
+              self._events.clear()
+
           def handle(self, request: ProcessItemsCommand) -> typing.Iterator[ProcessItemResult]:
               for item_id in request.item_ids:
                   result = self._items_api.process_item(item_id)
@@ -166,6 +173,7 @@ class SyncStreamingRequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
     def handle(self, request: _Req) -> typing.Iterator[_Resp]:
         raise NotImplementedError
 
+    @abc.abstractmethod
     def clear_events(self) -> None:
         """
         Clear events that have been processed.

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/src/python_cqrs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cqrs
-Version: 4.2.0
+Version: 4.3.1
 Summary: Python CQRS pattern implementation
 Author-email: Vadim Kozyrevskiy <vadikko2@mail.ru>, Dmitry Kutlubaev <kutlubaev00@mail.ru>
 Maintainer-email: Vadim Kozyrevskiy <vadikko2@mail.ru>
@@ -18,7 +18,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic==2.*
 Requires-Dist: orjson==3.9.15
-Requires-Dist: aio-pika==9.3.0
 Requires-Dist: di[anyio]==0.79.2
 Requires-Dist: sqlalchemy[asyncio]==2.0.*
 Requires-Dist: retry-async==0.1.4
@@ -46,6 +45,8 @@ Requires-Dist: aiokafka==0.10.0; extra == "kafka"
 Requires-Dist: confluent-kafka==2.6.0; extra == "kafka"
 Provides-Extra: protobuf
 Requires-Dist: protobuf==4.25.5; extra == "protobuf"
+Provides-Extra: rabbit
+Requires-Dist: aio-pika==9.3.0; extra == "rabbit"
 Dynamic: license-file
 
 # Python CQRS pattern implementation with Transaction Outbox supporting
@@ -70,7 +71,8 @@ project ([documentation](https://akhundmurad.github.io/diator/)) with several en
 8. FastStream supporting;
 9. [Protobuf](https://protobuf.dev/) events supporting;
 10. `StreamingRequestMediator` and `StreamingRequestHandler` for handling streaming requests with real-time progress updates;
-11. Parallel event processing with configurable concurrency limits.
+11. Parallel event processing with configurable concurrency limits;
+12. Chain of Responsibility pattern support with `CORRequestHandler` for processing requests through multiple handlers in sequence.
 
 ## Request Handlers
 
@@ -171,6 +173,9 @@ class ProcessFilesCommandHandler(StreamingRequestHandler[ProcessFilesCommand, Fi
     def events(self) -> list[Event]:
         return self._events.copy()
 
+    def clear_events(self) -> None:
+        self._events.clear()
+
     async def handle(self, request: ProcessFilesCommand) -> typing.AsyncIterator[FileProcessedResult]:
         for file_id in request.file_ids:
             # Process file
@@ -178,12 +183,74 @@ class ProcessFilesCommandHandler(StreamingRequestHandler[ProcessFilesCommand, Fi
             # Emit events
             self._events.append(FileProcessedEvent(file_id=file_id, ...))
             yield result
-            self._events.clear()
 ```
 
 A complete example can be found in
 the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/streaming_handler_parallel_events.py)
 
+### Chain of Responsibility Request Handler
+
+Chain of Responsibility Request Handler implements the chain of responsibility pattern, allowing multiple handlers
+to process a request in sequence until one successfully handles it. This pattern is particularly useful when you have
+multiple processing strategies or need to implement fallback mechanisms.
+
+Each handler in the chain decides whether to process the request or pass it to the next handler. The chain stops
+when a handler successfully processes the request or when all handlers have been exhausted.
+
+```python
+import typing
+from cqrs.requests.cor_request_handler import CORRequestHandler
+from cqrs.events.event import Event
+
+class CreditCardPaymentHandler(CORRequestHandler[ProcessPaymentCommand, PaymentResult]):
+    def __init__(self, payment_service: PaymentServiceProtocol) -> None:
+        self._payment_service = payment_service
+        self._events: typing.List[Event] = []
+
+    @property
+    def events(self) -> typing.List[Event]:
+        return self._events
+
+    async def handle(self, request: ProcessPaymentCommand) -> PaymentResult | None:
+        if request.payment_method == "credit_card":
+            # Process credit card payment
+            result = await self._payment_service.process_credit_card(request)
+            self._events.append(PaymentProcessedEvent(...))
+            return PaymentResult(success=True, transaction_id=result.id)
+
+        # Pass to next handler
+        return await self.next(request)
+
+class PayPalPaymentHandler(CORRequestHandler[ProcessPaymentCommand, PaymentResult]):
+    def __init__(self, paypal_service: PayPalServiceProtocol) -> None:
+        self._paypal_service = paypal_service
+        self._events: typing.List[Event] = []
+
+    @property
+    def events(self) -> typing.List[Event]:
+        return self._events
+
+    async def handle(self, request: ProcessPaymentCommand) -> PaymentResult | None:
+        if request.payment_method == "paypal":
+            # Process PayPal payment
+            result = await self._paypal_service.process_payment(request)
+            return PaymentResult(success=True, transaction_id=result.id)
+
+        # Pass to next handler
+        return await self.next(request)
+
+# Chain registration
+def payment_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ProcessPaymentCommand, [
+        CreditCardPaymentHandler,
+        PayPalPaymentHandler,
+        DefaultPaymentHandler  # Fallback handler
+    ])
+```
+
+A complete example can be found in
+the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/cor_request_handler.py)
+
 ## Event Handlers
 
 Event handlers are designed to process `Notification` and `ECST` events that are consumed from the broker.

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/src/python_cqrs.egg-info/SOURCES.txt

@@ -16,9 +16,6 @@ src/cqrs/container/__init__.py
 src/cqrs/container/dependency_injector.py
 src/cqrs/container/di.py
 src/cqrs/container/protocol.py
-src/cqrs/decoders/__init__.py
-src/cqrs/decoders/kafka/__init__.py
-src/cqrs/decoders/kafka/empty_message.py
 src/cqrs/deserializers/__init__.py
 src/cqrs/deserializers/json.py
 src/cqrs/deserializers/protobuf.py
@@ -45,6 +42,7 @@ src/cqrs/outbox/repository.py
 src/cqrs/outbox/sqlalchemy.py
 src/cqrs/requests/__init__.py
 src/cqrs/requests/bootstrap.py
+src/cqrs/requests/cor_request_handler.py
 src/cqrs/requests/map.py
 src/cqrs/requests/request.py
 src/cqrs/requests/request_handler.py

{python_cqrs-4.2.0 → python_cqrs-4.3.1}/src/python_cqrs.egg-info/requires.txt

@@ -1,6 +1,5 @@
 pydantic==2.*
 orjson==3.9.15
-aio-pika==9.3.0
 di[anyio]==0.79.2
 sqlalchemy[asyncio]==2.0.*
 retry-async==0.1.4
@@ -32,3 +31,6 @@ confluent-kafka==2.6.0
 
 [protobuf]
 protobuf==4.25.5
+
+[rabbit]
+aio-pika==9.3.0

python_cqrs-4.2.0/src/cqrs/decoders/kafka/__init__.py

@@ -1,5 +0,0 @@
-from cqrs.decoders.kafka.empty_message import empty_message_decoder
-
-__all__ = (
-    "empty_message_decoder",
-)

python_cqrs-4.2.0/src/cqrs/decoders/kafka/empty_message.py

@@ -1,24 +0,0 @@
-import typing
-
-try:
-    from faststream import kafka, types
-except ImportError:
-    print(
-        'Please install faststream with kafka supporting (pip install "faststream[kafka]") for use kafka message decoder',
-    )
-    raise
-
-
-async def empty_message_decoder(
-    msg: kafka.KafkaMessage,
-    original_decoder: typing.Callable[
-        [kafka.KafkaMessage],
-        typing.Awaitable[types.DecodedMessage],
-    ],
-) -> types.DecodedMessage | None:
-    """
-    Decode a kafka message and return it if it is not empty.
-    """
-    if not msg.body:
-        return None
-    return await original_decoder(msg)