python-cqrs 0.0.18__tar.gz → 0.1.2__tar.gz

{python_cqrs-0.0.18/src/python_cqrs.egg-info → python_cqrs-0.1.2}/PKG-INFO

@@ -1,9 +1,8 @@
 Metadata-Version: 2.1
 Name: python-cqrs
-Version: 0.0.18
+Version: 0.1.2
 Summary: Python CQRS pattern implementation
-Author: Nikita Kunov
-Author-email: Dmitriy Kutlubaev <kutlubaev00@mail.ru>, Vadim Kozyrevskiy <vadikko2@mail.ru>
+Author-email: Vadim Kozyrevskiy <vadikko2@mail.ru>
 Maintainer-email: Vadim Kozyrevskiy <vadikko2@mail.ru>
 Project-URL: Issues, https://github.com/vadikko2/python-cqrs/issues
 Project-URL: Repository, https://github.com/vadikko2/python-cqrs
@@ -65,7 +64,7 @@ As a result of executing the command, an event may be produced to the broker.
 > By default, the command handler does not return any result, but it is not mandatory.
 
 ```python
-from cqrs.requests.request_handler import RequestHandler
+from cqrs.requests.request_handler import RequestHandler, SyncRequestHandler
 from cqrs.events.event import Event
 
 class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
@@ -80,6 +79,21 @@ class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
 
       async def handle(self, request: JoinMeetingCommand) -> None:
           await self._meetings_api.join_user(request.user_id, request.meeting_id)
+
+
+class SyncJoinMeetingCommandHandler(SyncRequestHandler[JoinMeetingCommand, None]):
+
+      def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+          self._meetings_api = meetings_api
+          self.events: list[Event] = []
+
+      @property
+      def events(self) -> typing.List[events.Event]:
+          return self._events
+
+      def handle(self, request: JoinMeetingCommand) -> None:
+          # do some sync logic
+          ...
 ```
 
 ### Query handler
@@ -105,6 +119,7 @@ class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryR
       async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
           link = await self._meetings_api.get_link(request.meeting_id)
           return ReadMeetingQueryResult(link=link, meeting_id=request.meeting_id)
+
 ```
 
 
@@ -115,7 +130,7 @@ To configure event handling, you need to implement a broker consumer on the side
 Below is an example of `Kafka event consuming` that can be used in the Presentation Layer.
 
 ```python
-from cqrs.events import EventHandler
+from cqrs.events import EventHandler, SyncEventHandler
 
 class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler]):
 
@@ -124,6 +139,15 @@ class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler]):
 
     async def handle(self, event: UserJoinedEventHandler) -> None:
       await self._meetings_api.notify_room(event.meeting_id, "New user joined!")
+
+class SyncUserJoinedEventHandler(SyncEventHandler[UserJoinedEventHandler]):
+
+    def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+      self._meetings_api = meetings_api
+
+    def handle(self, event: UserJoinedEventHandler) -> None:
+      # do some sync logic
+      ...
 ```
 
 ## Producing Notification/ECST Events

{python_cqrs-0.0.18 → python_cqrs-0.1.2}/README.md

@@ -27,7 +27,7 @@ As a result of executing the command, an event may be produced to the broker.
 > By default, the command handler does not return any result, but it is not mandatory.
 
 ```python
-from cqrs.requests.request_handler import RequestHandler
+from cqrs.requests.request_handler import RequestHandler, SyncRequestHandler
 from cqrs.events.event import Event
 
 class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
@@ -42,6 +42,21 @@ class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
 
       async def handle(self, request: JoinMeetingCommand) -> None:
           await self._meetings_api.join_user(request.user_id, request.meeting_id)
+
+
+class SyncJoinMeetingCommandHandler(SyncRequestHandler[JoinMeetingCommand, None]):
+
+      def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+          self._meetings_api = meetings_api
+          self.events: list[Event] = []
+
+      @property
+      def events(self) -> typing.List[events.Event]:
+          return self._events
+
+      def handle(self, request: JoinMeetingCommand) -> None:
+          # do some sync logic
+          ...
 ```
 
 ### Query handler
@@ -67,6 +82,7 @@ class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryR
       async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
           link = await self._meetings_api.get_link(request.meeting_id)
           return ReadMeetingQueryResult(link=link, meeting_id=request.meeting_id)
+
 ```
 
 
@@ -77,7 +93,7 @@ To configure event handling, you need to implement a broker consumer on the side
 Below is an example of `Kafka event consuming` that can be used in the Presentation Layer.
 
 ```python
-from cqrs.events import EventHandler
+from cqrs.events import EventHandler, SyncEventHandler
 
 class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler]):
 
@@ -86,6 +102,15 @@ class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler]):
 
     async def handle(self, event: UserJoinedEventHandler) -> None:
       await self._meetings_api.notify_room(event.meeting_id, "New user joined!")
+
+class SyncUserJoinedEventHandler(SyncEventHandler[UserJoinedEventHandler]):
+
+    def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+      self._meetings_api = meetings_api
+
+    def handle(self, event: UserJoinedEventHandler) -> None:
+      # do some sync logic
+      ...
 ```
 
 ## Producing Notification/ECST Events

{python_cqrs-0.0.18 → python_cqrs-0.1.2}/pyproject.toml

@@ -4,8 +4,6 @@ requires = ["setuptools>=42", "wheel"]
 
 [project]
 authors = [
-  {name = "Dmitriy Kutlubaev", email = "kutlubaev00@mail.ru"},
-  {name = "Nikita Kunov"},
   {name = "Vadim Kozyrevskiy", email = "vadikko2@mail.ru"}
 ]
 classifiers = [
@@ -29,7 +27,7 @@ maintainers = [{name = "Vadim Kozyrevskiy", email = "vadikko2@mail.ru"}]
 name = "python-cqrs"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.0.18"
+version = "0.1.2"
 
 [project.optional-dependencies]
 dev = [

{python_cqrs-0.0.18 → python_cqrs-0.1.2}/src/cqrs/dispatcher/dispatcher.py

@@ -1,3 +1,5 @@
+import asyncio
+import functools
 import logging
 import typing
 
@@ -8,19 +10,28 @@ from cqrs import (
     events as cqrs_events,
     middlewares,
     requests,
-    response as res,
+    response as resp,
 )
+from cqrs.events import event_handler
+from cqrs.requests import request_handler
 
 logger = logging.getLogger("cqrs")
 
-Resp = typing.TypeVar("Resp", res.Response, None, contravariant=True)
+_Resp = typing.TypeVar("_Resp", resp.Response, None, contravariant=True)
+
+_RequestHandler: typing.TypeAlias = (
+    request_handler.RequestHandler | request_handler.SyncRequestHandler
+)
+_EventHandler: typing.TypeAlias = (
+    event_handler.EventHandler | event_handler.SyncEventHandler
+)
 
 
 class RequestHandlerDoesNotExist(Exception): ...
 
 
-class RequestDispatchResult(pydantic.BaseModel, typing.Generic[Resp]):
-    response: Resp = pydantic.Field(default=None)
+class RequestDispatchResult(pydantic.BaseModel, typing.Generic[_Resp]):
+    response: _Resp = pydantic.Field(default=None)
     events: typing.List[cqrs_events.Event] = pydantic.Field(default_factory=list)
 
 
@@ -41,9 +52,15 @@ class RequestDispatcher:
             raise RequestHandlerDoesNotExist(
                 f"RequestHandler not found matching Request type {type(request)}",
             )
-        handler = await self._container.resolve(handler_type)
-        wrapped_handle = self._middleware_chain.wrap(handler.handle)
+        handler: _RequestHandler = await self._container.resolve(handler_type)
+        if asyncio.iscoroutinefunction(handler.handle):
+            wrapped_handle = self._middleware_chain.wrap(handler.handle)
+        else:
+            wrapped_handle = self._middleware_chain.wrap(
+                functools.partial(asyncio.to_thread, handler.handle),
+            )
         response = await wrapped_handle(request)
+
         return RequestDispatchResult(response=response, events=handler.events)
 
 
@@ -64,10 +81,13 @@ class EventDispatcher:
     async def _handle_event(
         self,
         event: cqrs_events.Event,
-        handle_type: typing.Type[cqrs_events.EventHandler[cqrs_events.Event]],
+        handle_type: typing.Type[cqrs_events.EventHandler],
     ):
-        handler = await self._container.resolve(handle_type)
-        await handler.handle(event)
+        handler: _EventHandler = await self._container.resolve(handle_type)
+        if asyncio.iscoroutinefunction(handler.handle):
+            await handler.handle(event)
+        else:
+            await asyncio.to_thread(handler.handle, event)
 
     async def dispatch(self, event: cqrs_events.Event) -> None:
         handler_types = self._event_map.get(type(event), [])

{python_cqrs-0.0.18 → python_cqrs-0.1.2}/src/cqrs/events/event_emitter.py

@@ -1,11 +1,17 @@
+import asyncio
 import functools
 import logging
+import typing
 
-from cqrs import container, message_brokers
-from cqrs.events import event, map
+from cqrs import container as di_container, message_brokers
+from cqrs.events import event as event_model, event_handler, map
 
 logger = logging.getLogger("cqrs")
 
+_EventHandler: typing.TypeAlias = (
+    event_handler.EventHandler | event_handler.SyncEventHandler
+)
+
 
 class EventEmitter:
     """
@@ -16,7 +22,7 @@ class EventEmitter:
     def __init__(
         self,
         event_map: map.EventMap,
-        container: container.Container,
+        container: di_container.Container,
         message_broker: message_brokers.MessageBroker | None = None,
     ) -> None:
         self._event_map = event_map
@@ -24,10 +30,10 @@ class EventEmitter:
         self._message_broker = message_broker
 
     @functools.singledispatchmethod
-    async def emit(self, event: event.Event) -> None: ...
+    async def emit(self, event: event_model.Event) -> None: ...
 
     @emit.register
-    async def _(self, event: event.DomainEvent) -> None:
+    async def _(self, event: event_model.DomainEvent) -> None:
         handlers_types = self._event_map.get(type(event), [])
         if not handlers_types:
             logger.warning(
@@ -35,16 +41,21 @@ class EventEmitter:
                 type(event).__name__,
             )
         for handler_type in handlers_types:
-            handler = await self._container.resolve(handler_type)
+            handler: _EventHandler = await self._container.resolve(
+                handler_type,
+            )
             logger.debug(
                 "Handling Event(%s) via event handler(%s)",
                 type(event).__name__,
                 handler_type.__name__,
             )
-            await handler.handle(event)
+            if asyncio.iscoroutinefunction(handler.handle):
+                await handler.handle(event)
+            else:
+                await asyncio.to_thread(handler.handle, event)
 
     @emit.register
-    async def _(self, event: event.NotificationEvent) -> None:
+    async def _(self, event: event_model.NotificationEvent) -> None:
         if not self._message_broker:
             raise RuntimeError(
                 "To use NotificationEvent, message_broker argument must be specified.",
@@ -61,7 +72,7 @@ class EventEmitter:
         await self._message_broker.send_message(message)
 
     @emit.register
-    async def _(self, event: event.ECSTEvent) -> None:
+    async def _(self, event: event_model.ECSTEvent) -> None:
         if not self._message_broker:
             raise RuntimeError(
                 "To use ECSTEvent, message_broker argument must be specified.",
@@ -79,7 +90,7 @@ class EventEmitter:
 
 
 def _build_message(
-    event: event.NotificationEvent | event.ECSTEvent,
+    event: event_model.NotificationEvent | event_model.ECSTEvent,
 ) -> message_brokers.Message:
     payload = event.model_dump(mode="json")
 

python_cqrs-0.1.2/src/cqrs/events/event_handler.py

@@ -0,0 +1,46 @@
+import abc
+import typing
+
+from cqrs.events import event as event_models
+
+E = typing.TypeVar("E", bound=event_models.Event, contravariant=True)
+
+
+class EventHandler(abc.ABC, typing.Generic[E]):
+    """
+    The event handler interface.
+
+    Usage::
+
+      class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler])
+          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+              self._meetings_api = meetings_api
+
+          async def handle(self, event: UserJoinedEventHandler) -> None:
+              await self._meetings_api.notify_room(event.meeting_id, "New user joined!")
+
+    """
+
+    @abc.abstractmethod
+    async def handle(self, event: E) -> None:
+        raise NotImplementedError
+
+
+class SyncEventHandler(abc.ABC, typing.Generic[E]):
+    """
+    The event handler interface.
+
+    Usage::
+
+      class UserJoinedEventHandler(SyncEventHandler[UserJoinedEventHandler])
+          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+              self._meetings_api = meetings_api
+
+          def handle(self, event: UserJoinedEventHandler) -> None:
+              self._meetings_api.notify_room(event.meeting_id, "New user joined!")
+
+    """
+
+    @abc.abstractmethod
+    def handle(self, event: E) -> None:
+        raise NotImplementedError

{python_cqrs-0.0.18 → python_cqrs-0.1.2}/src/cqrs/mediator.py

@@ -3,13 +3,13 @@ import typing
 from cqrs import (
     container as di_container,
     dispatcher,
-    events,
+    events as ev,
     middlewares,
     requests,
     response,
 )
 
-Resp = typing.TypeVar("Resp", response.Response, None, contravariant=True)
+_Resp = typing.TypeVar("_Resp", response.Response, None, contravariant=True)
 
 
 class RequestMediator:
@@ -44,7 +44,7 @@ class RequestMediator:
         self,
         request_map: requests.RequestMap,
         container: di_container.Container,
-        event_emitter: events.EventEmitter | None = None,
+        event_emitter: ev.EventEmitter | None = None,
         middleware_chain: middlewares.MiddlewareChain | None = None,
         *,
         dispatcher_type: typing.Type[
@@ -58,7 +58,7 @@ class RequestMediator:
             middleware_chain=middleware_chain,  # type: ignore
         )
 
-    async def send(self, request: requests.Request) -> Resp:
+    async def send(self, request: requests.Request) -> _Resp:
         dispatch_result = await self._dispatcher.dispatch(request)
 
         if dispatch_result.events:
@@ -66,7 +66,7 @@ class RequestMediator:
 
         return dispatch_result.response
 
-    async def _send_events(self, events: typing.List[events.Event]) -> None:
+    async def _send_events(self, events: typing.List[ev.Event]) -> None:
         if not self._event_emitter:
             return
 
@@ -93,7 +93,7 @@ class EventMediator:
 
     def __init__(
         self,
-        event_map: events.EventMap,
+        event_map: ev.EventMap,
         container: di_container.Container,
         middleware_chain: middlewares.MiddlewareChain | None = None,
         *,
@@ -107,5 +107,5 @@ class EventMediator:
             middleware_chain=middleware_chain,  # type: ignore
         )
 
-    async def send(self, event: events.Event) -> None:
+    async def send(self, event: ev.Event) -> None:
         await self._dispatcher.dispatch(event)

{python_cqrs-0.0.18 → python_cqrs-0.1.2}/src/cqrs/middlewares/base.py

@@ -3,20 +3,20 @@ import typing
 
 from cqrs import requests, response
 
-Req = typing.TypeVar("Req", bound=requests.Request, contravariant=True)
-Res = typing.TypeVar("Res", response.Response, None, contravariant=True)
-HandleType = typing.Callable[[Req], typing.Awaitable[Res]]
+_Req = typing.TypeVar("_Req", bound=requests.Request, contravariant=True)
+_Res = typing.TypeVar("_Res", response.Response, None, covariant=True)
+HandleType = typing.Callable[[_Req], typing.Awaitable[_Res] | _Res]
 
 
-class Middleware(typing.Protocol):
-    async def __call__(self, request: requests.Request, handle: HandleType) -> Res: ...
+class Middleware(typing.Protocol[_Req, _Res]):
+    async def __call__(self, request: _Req, handle: HandleType) -> _Res: ...
 
 
 class MiddlewareChain:
     def __init__(self) -> None:
-        self._chain: list[Middleware] = []
+        self._chain: typing.List[Middleware] = []
 
-    def set(self, chain: list[Middleware]) -> None:
+    def set(self, chain: typing.List[Middleware]) -> None:
         self._chain = chain
 
     def add(self, middleware: Middleware) -> None:

python_cqrs-0.1.2/src/cqrs/requests/request_handler.py

@@ -0,0 +1,86 @@
+import abc
+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 RequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
+    """
+    The request handler interface.
+
+    The request handler is an object, which gets a request as input and may return a response as a result.
+
+    Command handler example::
+
+      class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None])
+          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+              self._meetings_api = meetings_api
+              self.events: list[Event] = []
+
+          async def handle(self, request: JoinMeetingCommand) -> None:
+              await self._meetings_api.join_user(request.user_id, request.meeting_id)
+
+    Query handler example::
+
+      class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryResult])
+          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+              self._meetings_api = meetings_api
+              self.events: list[Event] = []
+
+          async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
+              link = await self._meetings_api.get_link(request.meeting_id)
+              return ReadMeetingQueryResult(link=link, meeting_id=request.meeting_id)
+
+    """
+
+    @property
+    @abc.abstractmethod
+    def events(self) -> list[event.Event]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def handle(self, request: _Req) -> _Resp:
+        raise NotImplementedError
+
+
+class SyncRequestHandler(abc.ABC, typing.Generic[_Req, _Resp]):
+    """
+    The synchronous request handler interface.
+
+    The request handler is an object, which gets a request as input and may return a response as a result.
+
+    Command handler example::
+
+      class JoinMeetingCommandHandler(SyncRequestHandler[JoinMeetingCommand, None])
+          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+              self._meetings_api = meetings_api
+              self.events: list[Event] = []
+
+          def handle(self, request: JoinMeetingCommand) -> None:
+              self._meetings_api.join_user(request.user_id, request.meeting_id)
+
+    Query handler example::
+
+      class ReadMeetingQueryHandler(SyncRequestHandler[ReadMeetingQuery, ReadMeetingQueryResult])
+          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+              self._meetings_api = meetings_api
+              self.events: list[Event] = []
+
+          def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
+              link = self._meetings_api.get_link(request.meeting_id)
+              return ReadMeetingQueryResult(link=link, meeting_id=request.meeting_id)
+    """
+
+    @property
+    @abc.abstractmethod
+    def events(self) -> list[event.Event]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def handle(self, request: _Req) -> _Resp:
+        raise NotImplementedError

{python_cqrs-0.0.18 → python_cqrs-0.1.2/src/python_cqrs.egg-info}/PKG-INFO

@@ -1,9 +1,8 @@
 Metadata-Version: 2.1
 Name: python-cqrs
-Version: 0.0.18
+Version: 0.1.2
 Summary: Python CQRS pattern implementation
-Author: Nikita Kunov
-Author-email: Dmitriy Kutlubaev <kutlubaev00@mail.ru>, Vadim Kozyrevskiy <vadikko2@mail.ru>
+Author-email: Vadim Kozyrevskiy <vadikko2@mail.ru>
 Maintainer-email: Vadim Kozyrevskiy <vadikko2@mail.ru>
 Project-URL: Issues, https://github.com/vadikko2/python-cqrs/issues
 Project-URL: Repository, https://github.com/vadikko2/python-cqrs
@@ -65,7 +64,7 @@ As a result of executing the command, an event may be produced to the broker.
 > By default, the command handler does not return any result, but it is not mandatory.
 
 ```python
-from cqrs.requests.request_handler import RequestHandler
+from cqrs.requests.request_handler import RequestHandler, SyncRequestHandler
 from cqrs.events.event import Event
 
 class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
@@ -80,6 +79,21 @@ class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
 
       async def handle(self, request: JoinMeetingCommand) -> None:
           await self._meetings_api.join_user(request.user_id, request.meeting_id)
+
+
+class SyncJoinMeetingCommandHandler(SyncRequestHandler[JoinMeetingCommand, None]):
+
+      def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+          self._meetings_api = meetings_api
+          self.events: list[Event] = []
+
+      @property
+      def events(self) -> typing.List[events.Event]:
+          return self._events
+
+      def handle(self, request: JoinMeetingCommand) -> None:
+          # do some sync logic
+          ...
 ```
 
 ### Query handler
@@ -105,6 +119,7 @@ class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryR
       async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
           link = await self._meetings_api.get_link(request.meeting_id)
           return ReadMeetingQueryResult(link=link, meeting_id=request.meeting_id)
+
 ```
 
 
@@ -115,7 +130,7 @@ To configure event handling, you need to implement a broker consumer on the side
 Below is an example of `Kafka event consuming` that can be used in the Presentation Layer.
 
 ```python
-from cqrs.events import EventHandler
+from cqrs.events import EventHandler, SyncEventHandler
 
 class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler]):
 
@@ -124,6 +139,15 @@ class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler]):
 
     async def handle(self, event: UserJoinedEventHandler) -> None:
       await self._meetings_api.notify_room(event.meeting_id, "New user joined!")
+
+class SyncUserJoinedEventHandler(SyncEventHandler[UserJoinedEventHandler]):
+
+    def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+      self._meetings_api = meetings_api
+
+    def handle(self, event: UserJoinedEventHandler) -> None:
+      # do some sync logic
+      ...
 ```
 
 ## Producing Notification/ECST Events

python_cqrs-0.0.18/src/cqrs/events/event_handler.py

@@ -1,24 +0,0 @@
-import typing
-
-from cqrs.events import event as event_models
-
-E = typing.TypeVar("E", bound=event_models.Event, contravariant=True)
-
-
-class EventHandler(typing.Protocol[E]):
-    """
-    The event handler interface.
-
-    Usage::
-
-      class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler])
-          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
-              self._meetings_api = meetings_api
-
-          async def handle(self, event: UserJoinedEventHandler) -> None:
-              await self._meetings_api.notify_room(event.meeting_id, "New user joined!")
-
-    """
-
-    async def handle(self, event: E) -> None:
-        raise NotImplementedError

python_cqrs-0.0.18/src/cqrs/requests/request_handler.py

@@ -1,45 +0,0 @@
-import typing
-
-from cqrs import response
-from cqrs.events import event
-from cqrs.requests import request
-
-Req = typing.TypeVar("Req", bound=request.Request, contravariant=True)
-Res = typing.TypeVar("Res", response.Response, None, covariant=True)
-
-
-class RequestHandler(typing.Protocol[Req, Res]):
-    """
-    The request handler interface.
-
-    The request handler is an object, which gets a request as input and may return a response as a result.
-
-    Command handler example::
-
-      class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None])
-          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
-              self._meetings_api = meetings_api
-              self.events: list[Event] = []
-
-          async def handle(self, request: JoinMeetingCommand) -> None:
-              await self._meetings_api.join_user(request.user_id, request.meeting_id)
-
-    Query handler example::
-
-      class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryResult])
-          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
-              self._meetings_api = meetings_api
-              self.events: list[Event] = []
-
-          async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
-              link = await self._meetings_api.get_link(request.meeting_id)
-              return ReadMeetingQueryResult(link=link, meeting_id=request.meeting_id)
-
-    """
-
-    @property
-    def events(self) -> list[event.Event]:
-        ...
-
-    async def handle(self, request: Req) -> Res:
-        raise NotImplementedError