python-cqrs 0.0.2__tar.gz → 0.0.5__tar.gz

{python_cqrs-0.0.2/src/python_cqrs.egg-info → python_cqrs-0.0.5}/PKG-INFO

@@ -1,7 +1,9 @@
 Metadata-Version: 2.1
 Name: python-cqrs
-Version: 0.0.2
-Author: Vadim Kozyrevskiy
+Version: 0.0.5
+Summary: Python CQRS pattern implementation
+Author: Nikita Kunov
+Author-email: Vadim Kozyrevskiy <vadikko2@mail.ru>, Dmitriy Kutlubaev <kutlubaev00@mail.ru>
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic==2.*
@@ -10,22 +12,19 @@ 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
-Provides-Extra: git
-Requires-Dist: pre-commit==3.8.0; extra == "git"
+Provides-Extra: dev
+Requires-Dist: pre-commit==3.8.0; extra == "dev"
+Requires-Dist: pyright==1.1.377; extra == "dev"
+Requires-Dist: ruff==0.6.2; extra == "dev"
+Requires-Dist: aiokafka==0.10.0; extra == "dev"
+Requires-Dist: pytest~=7.4.2; extra == "dev"
+Requires-Dist: pytest-asyncio~=0.21.1; extra == "dev"
+Requires-Dist: pytest-env==0.6.2; extra == "dev"
+Requires-Dist: python-dotenv==1.0.1; extra == "dev"
+Requires-Dist: cryptography==42.0.2; extra == "dev"
+Requires-Dist: asyncmy==0.2.9; extra == "dev"
 Provides-Extra: kafka
 Requires-Dist: aiokafka==0.10.0; extra == "kafka"
-Provides-Extra: lint
-Requires-Dist: flake8==7.0.0; extra == "lint"
-Requires-Dist: flake8-pytest; extra == "lint"
-Requires-Dist: black; extra == "lint"
-Provides-Extra: tests
-Requires-Dist: aiokafka==0.10.0; extra == "tests"
-Requires-Dist: pytest~=7.4.2; extra == "tests"
-Requires-Dist: pytest-asyncio~=0.21.1; extra == "tests"
-Requires-Dist: pytest-env==0.6.2; extra == "tests"
-Requires-Dist: python-dotenv==1.0.1; extra == "tests"
-Requires-Dist: cryptography==42.0.2; extra == "tests"
-Requires-Dist: asyncmy==0.2.9; extra == "tests"
 
 # CQRS
 

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/pyproject.toml

@@ -4,7 +4,9 @@ requires = ["setuptools>=42", "wheel"]
 
 [project]
 authors = [
-  {name = "Vadim Kozyrevskiy"}
+  {name = "Vadim Kozyrevskiy", email = "vadikko2@mail.ru"},
+  {name = "Dmitriy Kutlubaev", email = "kutlubaev00@mail.ru"},
+  {name = "Nikita Kunov"}
 ]
 dependencies = [
   "pydantic==2.*",
@@ -14,24 +16,17 @@ dependencies = [
   "sqlalchemy[asyncio]==2.0.*",
   "retry-async==0.1.4"
 ]
-description = ""
+description = "Python CQRS pattern implementation"
 name = "python-cqrs"
 readme = "README.md"
-version = "0.0.2"
+version = "0.0.5"
 
 [project.optional-dependencies]
-git = [
-  "pre-commit==3.8.0 "
-]
-kafka = [
-  "aiokafka==0.10.0"
-]
-lint = [
-  "flake8==7.0.0",
-  "flake8-pytest",
-  "black"
-]
-tests = [
+dev = [
+  "pre-commit==3.8.0",
+  "pyright==1.1.377",
+  "ruff==0.6.2",
+  # Tests
   "aiokafka==0.10.0",
   "pytest~=7.4.2",
   "pytest-asyncio~=0.21.1",
@@ -40,6 +35,9 @@ tests = [
   "cryptography==42.0.2",
   "asyncmy==0.2.9"
 ]
+kafka = [
+  "aiokafka==0.10.0"
+]
 
 [tool.pytest.ini_options]
 addopts = "--junit-xml=report.xml"

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/compressors/protocol.py

@@ -4,6 +4,8 @@ import typing
 class Compressor(typing.Protocol):
     def compress(self, value: bytes) -> bytes:
         """Compress value"""
+        raise NotImplementedError
 
     def decompress(self, value: bytes) -> bytes:
         """Decompress compressed value"""
+        raise NotImplementedError

python_cqrs-0.0.5/src/cqrs/container/di.py

@@ -0,0 +1,29 @@
+import typing
+
+import di
+from di import dependent, executors
+
+from cqrs import container as cqrs_container
+
+T = typing.TypeVar("T")
+
+
+class DIContainer(cqrs_container.Container[di.Container]):
+    def __init__(self, external_container: di.Container) -> None:
+        self._external_container = external_container
+
+    @property
+    def external_container(self) -> di.Container:
+        return self._external_container
+
+    def attach_external_container(self, container: di.Container) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: typing.Type[T]) -> T:
+        executor = executors.AsyncExecutor()
+        solved = self._external_container.solve(
+            dependent.Dependent(type_, scope="request"),
+            scopes=["request"],
+        )
+        with self._external_container.enter_scope("request") as state:
+            return await solved.execute_async(executor=executor, state=state)

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/container/protocol.py

@@ -11,10 +11,10 @@ class Container(typing.Protocol[C]):
 
     @property
     def external_container(self) -> C:
-        ...
+        raise NotImplementedError
 
     def attach_external_container(self, container: C) -> None:
-        ...
+        raise NotImplementedError
 
     async def resolve(self, type_: typing.Type[T]) -> T:
-        ...
+        raise NotImplementedError

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/dispatcher/dispatcher.py

@@ -3,14 +3,20 @@ import typing
 
 import pydantic
 
-from cqrs import container as di_container
-from cqrs import events as cqrs_events
-from cqrs import middlewares, requests
-from cqrs import response as res
+from cqrs import (
+    container as di_container,
+    events as cqrs_events,
+    middlewares,
+    requests,
+    response as res,
+)
 
 logger = logging.getLogger("cqrs")
 
 
+class RequestHandlerDoesNotExist(Exception): ...
+
+
 class RequestDispatchResult(pydantic.BaseModel):
     response: res.Response | None = pydantic.Field(default=None)
     events: typing.List[cqrs_events.Event] = pydantic.Field(default_factory=list)
@@ -28,7 +34,11 @@ class RequestDispatcher:
         self._middleware_chain = middleware_chain or middlewares.MiddlewareChain()
 
     async def dispatch(self, request: requests.Request) -> RequestDispatchResult:
-        handler_type = self._request_map.get(type(request))
+        handler_type = self._request_map.get(type(request), None)
+        if handler_type is None:
+            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)
         response = await wrapped_handle(request)
@@ -49,12 +59,16 @@ class EventDispatcher:
         self._container = container
         self._middleware_chain = middleware_chain or middlewares.MiddlewareChain()
 
-    async def _handle_event(self, event: E, handle_type: typing.Type[cqrs_events.EventHandler[E]]):
+    async def _handle_event(
+        self,
+        event: cqrs_events.Event,
+        handle_type: typing.Type[cqrs_events.EventHandler[cqrs_events.Event]],
+    ):
         handler = await self._container.resolve(handle_type)
         await handler.handle(event)
 
-    async def dispatch(self, event: E) -> None:
-        handler_types = self._event_map.get(type(event))
+    async def dispatch(self, event: cqrs_events.Event) -> None:
+        handler_types = self._event_map.get(type(event), [])
         if not handler_types:
             logger.warning(
                 "Handlers for event %s not found",

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/events/bootstrap.py

@@ -5,23 +5,19 @@ import di
 import cqrs
 from cqrs import events
 from cqrs.container import di as ed_di_container
-from cqrs.middlewares import base as mediator_middlewares
-from cqrs.middlewares import logging as logging_middleware
+from cqrs.middlewares import base as mediator_middlewares, logging as logging_middleware
 
 
 def setup_mediator(
-    container: ed_di_container.DIContainer | None,
-    middlewares: typing.Iterable[mediator_middlewares.Middleware] | None = None,
-    events_mapper: typing.Callable[[events.EventMap], None] = None,
+    container: ed_di_container.DIContainer,
+    middlewares: typing.Iterable[mediator_middlewares.Middleware],
+    events_mapper: typing.Callable[[events.EventMap], None] | None = None,
 ) -> cqrs.EventMediator:
-
     _events_mapper = events.EventMap()
-    if events_mapper:
+    if events_mapper is not None:
         events_mapper(_events_mapper)
 
     middleware_chain = mediator_middlewares.MiddlewareChain()
-    if middlewares is None:
-        middlewares = []
 
     for middleware in middlewares:
         middleware_chain.add(middleware)
@@ -34,9 +30,9 @@ def setup_mediator(
 
 
 def bootstrap(
-    di_container: di.Container | None = None,
-    middlewares: typing.Iterable[mediator_middlewares.Middleware] | None = None,
-    events_mapper: typing.Callable[[events.EventMap], None] = None,
+    di_container: di.Container,
+    middlewares: typing.Sequence[mediator_middlewares.Middleware] | None = None,
+    events_mapper: typing.Callable[[events.EventMap], None] | None = None,
     on_startup: typing.List[typing.Callable[[], None]] | None = None,
 ) -> cqrs.EventMediator:
     if on_startup is None:
@@ -45,11 +41,12 @@ def bootstrap(
     for fun in on_startup:
         fun()
 
-    if middlewares is None:
-        middlewares = []
     container = ed_di_container.DIContainer(di_container)
+    middlewares_list: typing.List[mediator_middlewares.Middleware] = list(
+        middlewares or [],
+    )
     return setup_mediator(
         container,
         events_mapper=events_mapper,
-        middlewares=middlewares + [logging_middleware.LoggingMiddleware()],
+        middlewares=middlewares_list + [logging_middleware.LoggingMiddleware()],
     )

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/events/event.py

@@ -9,7 +9,7 @@ class Event(pydantic.BaseModel, frozen=True):
     """The base class for events"""
 
 
-class DomainEvent(Event):
+class DomainEvent(Event, frozen=True):
     """
     The base class for domain events.
     """
@@ -18,7 +18,7 @@ class DomainEvent(Event):
 _P = typing.TypeVar("_P")
 
 
-class NotificationEvent(Event):
+class NotificationEvent(Event, frozen=True):
     """
     The base class for notification events.
 
@@ -38,7 +38,9 @@ class NotificationEvent(Event):
     """
 
     event_id: uuid.UUID = pydantic.Field(default_factory=uuid.uuid4)
-    event_timestamp: datetime.datetime = pydantic.Field(default_factory=datetime.datetime.now)
+    event_timestamp: datetime.datetime = pydantic.Field(
+        default_factory=datetime.datetime.now,
+    )
     event_name: typing.Text
     event_type: typing.ClassVar[typing.Text] = "notification_event"
 
@@ -50,7 +52,7 @@ class NotificationEvent(Event):
         return hash(self.event_id)
 
 
-class ECSTEvent(Event, typing.Generic[_P]):
+class ECSTEvent(Event, typing.Generic[_P], frozen=True):
     """
     Base class for ECST events.
 
@@ -74,7 +76,9 @@ class ECSTEvent(Event, typing.Generic[_P]):
     """
 
     event_id: uuid.UUID = pydantic.Field(default_factory=uuid.uuid4)
-    event_timestamp: datetime.datetime = pydantic.Field(default_factory=datetime.datetime.now)
+    event_timestamp: datetime.datetime = pydantic.Field(
+        default_factory=datetime.datetime.now,
+    )
     event_name: typing.Text
     event_type: typing.ClassVar = "ecst_event"
 

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/events/event_emitter.py

@@ -24,12 +24,11 @@ class EventEmitter:
         self._message_broker = message_broker
 
     @functools.singledispatchmethod
-    async def emit(self, event: event.Event) -> None:
-        ...
+    async def emit(self, event: event.Event) -> None: ...
 
     @emit.register
     async def _(self, event: event.DomainEvent) -> None:
-        handlers_types = self._event_map.get(type(event))
+        handlers_types = self._event_map.get(type(event), [])
         if not handlers_types:
             logger.warning(
                 "Handlers for domain event %s not found",
@@ -47,7 +46,9 @@ class EventEmitter:
     @emit.register
     async def _(self, event: event.NotificationEvent) -> None:
         if not self._message_broker:
-            raise RuntimeError("To use NotificationEvent, message_broker argument must be specified.")
+            raise RuntimeError(
+                "To use NotificationEvent, message_broker argument must be specified.",
+            )
 
         message = _build_message(event)
 
@@ -62,7 +63,9 @@ class EventEmitter:
     @emit.register
     async def _(self, event: event.ECSTEvent) -> None:
         if not self._message_broker:
-            raise RuntimeError("To use ECSTEvent, message_broker argument must be specified.")
+            raise RuntimeError(
+                "To use ECSTEvent, message_broker argument must be specified.",
+            )
 
         message = _build_message(event)
 
@@ -75,7 +78,9 @@ class EventEmitter:
         await self._message_broker.send_message(message)
 
 
-def _build_message(event: event.NotificationEvent | event.ECSTEvent) -> message_brokers.Message:
+def _build_message(
+    event: event.NotificationEvent | event.ECSTEvent,
+) -> message_brokers.Message:
     payload = event.model_dump(mode="json")
 
     return message_brokers.Message(

python_cqrs-0.0.5/src/cqrs/events/map.py

@@ -0,0 +1,28 @@
+import typing
+
+from cqrs.events import event, event_handler
+
+_KT = typing.TypeVar("_KT", bound=typing.Type[event.Event])
+_VT = typing.List[typing.Type[event_handler.EventHandler[event.Event]]]
+
+
+class EventMap(typing.Dict[_KT, _VT]):
+    def bind(
+        self,
+        event_type: _KT,
+        handler_type: typing.Type[event_handler.EventHandler[event.Event]],
+    ) -> None:
+        if event_type not in self:
+            self[event_type] = [handler_type]
+        else:
+            if handler_type in self[event_type]:
+                raise KeyError(f"{handler_type} already bind to {event_type}")
+            self[event_type].append(handler_type)
+
+    def __setitem__(self, __key: _KT, __value: _VT) -> None:
+        if __key in self:
+            raise KeyError(f"{__key} already exists in registry")
+        super().__setitem__(__key, __value)
+
+    def __delitem__(self, __key_: _KT):
+        raise TypeError(f"{self.__class__.__name__} has no delete method")

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/mediator.py

@@ -1,11 +1,13 @@
 import typing
 
-from cqrs import container as di_container
-from cqrs import dispatcher, events, middlewares, requests, response
-
-Req = typing.TypeVar("Req", bound=requests.Request, contravariant=True)
-Resp = typing.TypeVar("Resp", bound=response.Response, covariant=True)
-E = typing.TypeVar("E", bound=events.Event, contravariant=True)
+from cqrs import (
+    container as di_container,
+    dispatcher,
+    events,
+    middlewares,
+    requests,
+    response,
+)
 
 
 class RequestMediator:
@@ -43,7 +45,9 @@ class RequestMediator:
         event_emitter: events.EventEmitter | None = None,
         middleware_chain: middlewares.MiddlewareChain | None = None,
         *,
-        dispatcher_type: typing.Type[dispatcher.RequestDispatcher] = dispatcher.RequestDispatcher,
+        dispatcher_type: typing.Type[
+            dispatcher.RequestDispatcher
+        ] = dispatcher.RequestDispatcher,
     ) -> None:
         self._event_emitter = event_emitter
         self._dispatcher = dispatcher_type(
@@ -52,7 +56,7 @@ class RequestMediator:
             middleware_chain=middleware_chain,  # type: ignore
         )
 
-    async def send(self, request: Req) -> Resp | None:
+    async def send(self, request: requests.Request) -> response.Response | None:
         dispatch_result = await self._dispatcher.dispatch(request)
 
         if dispatch_result.events:
@@ -60,7 +64,7 @@ class RequestMediator:
 
         return dispatch_result.response
 
-    async def _send_events(self, events: typing.List[E]) -> None:
+    async def _send_events(self, events: typing.List[events.Event]) -> None:
         if not self._event_emitter:
             return
 
@@ -91,7 +95,9 @@ class EventMediator:
         container: di_container.Container,
         middleware_chain: middlewares.MiddlewareChain | None = None,
         *,
-        dispatcher_type: typing.Type[dispatcher.EventDispatcher] = dispatcher.EventDispatcher,
+        dispatcher_type: typing.Type[
+            dispatcher.EventDispatcher
+        ] = dispatcher.EventDispatcher,
     ):
         self._dispatcher = dispatcher_type(
             event_map=event_map,  # type: ignore
@@ -99,5 +105,5 @@ class EventMediator:
             middleware_chain=middleware_chain,  # type: ignore
         )
 
-    async def send(self, event: E) -> None:
+    async def send(self, event: events.Event) -> None:
         await self._dispatcher.dispatch(event)

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/middlewares/base.py

@@ -9,8 +9,7 @@ HandleType = typing.Callable[[Req], typing.Awaitable[Res]]
 
 
 class Middleware(typing.Protocol):
-    async def __call__(self, request: requests.Request, handle: HandleType) -> Res:
-        ...
+    async def __call__(self, request: requests.Request, handle: HandleType) -> Res: ...
 
 
 class MiddlewareChain:

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/middlewares/logging.py

@@ -2,21 +2,18 @@ import logging
 import typing
 
 from cqrs import requests, response
+from cqrs.middlewares import base
 
 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]]
 
+logger = logging.getLogger("cqrs")
 
-class LoggingMiddleware:
-    def __init__(
-        self,
-        logger: logging.Logger | None = None,
-    ) -> None:
-        self._logger = logger or logging.getLogger("cqrs")
 
-    async def __call__(self, request: Req, handle: HandleType) -> Res:
-        self._logger.debug(
+class LoggingMiddleware(base.Middleware):
+    async def __call__(self, request: requests.Request, handle: HandleType) -> Res:
+        logger.debug(
             "Handle %s request",
             type(request).__name__,
             extra={
@@ -25,11 +22,13 @@ class LoggingMiddleware:
             },
         )
         resp = await handle(request)
-        self._logger.debug(
+        logger.debug(
             "Request %s handled",
             type(request).__name__,
             extra={
-                "request_json_fields": {"response": resp.model_dump(mode="json") if resp else {}},
+                "request_json_fields": {
+                    "response": resp.model_dump(mode="json") if resp else {},
+                },
                 "to_mask": True,
             },
         )

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/outbox/producer.py

@@ -13,7 +13,10 @@ logger = logging.getLogger("cqrs")
 logger.setLevel(logging.DEBUG)
 
 SessionFactory: typing.TypeAlias = typing.Callable[[], sql_session.AsyncSession]
-Serializer: typing.TypeAlias = typing.Callable[[repository_protocol.Event], typing.Awaitable[typing.Dict]]
+Serializer: typing.TypeAlias = typing.Callable[
+    [repository_protocol.Event],
+    typing.Awaitable[typing.Dict],
+]
 
 
 class EventProducer:
@@ -27,15 +30,27 @@ class EventProducer:
         self.repository = repository
         self.serializer = serializer
 
-    async def periodically_task(self, batch_size: int = 100, wait_ms: int = 500) -> None:
+    async def periodically_task(
+        self,
+        batch_size: int = 100,
+        wait_ms: int = 500,
+    ) -> None:
         """Calls produce periodically with specified delay"""
         while True:
             await asyncio.sleep(float(wait_ms) / 1000.0)
             await self.produce_batch(batch_size)
 
-    async def send_message(self, session: repository_protocol.Session, event: cqrs.ECSTEvent | cqrs.NotificationEvent):
+    async def send_message(
+        self,
+        session: object,
+        event: cqrs.ECSTEvent | cqrs.NotificationEvent,
+    ):
         try:
-            serialized = (await self.serializer(event)) if self.serializer else event.model_dump(mode="json")
+            serialized = (
+                (await self.serializer(event))
+                if self.serializer
+                else event.model_dump(mode="json")
+            )
             await self.message_broker.send_message(
                 broker_protocol.Message(
                     message_type=event.event_type,
@@ -45,10 +60,20 @@ class EventProducer:
                 ),
             )
         except Exception as e:
-            logger.error(f"Error while producing event {event.event_id} to kafka broker: {e}")
-            await self.repository.update_status(session, event.event_id, repository_protocol.EventStatus.NOT_PRODUCED)
+            logger.error(
+                f"Error while producing event {event.event_id} to kafka broker: {e}",
+            )
+            await self.repository.update_status(
+                session,
+                event.event_id,
+                repository_protocol.EventStatus.NOT_PRODUCED,
+            )
         else:
-            await self.repository.update_status(session, event.event_id, repository_protocol.EventStatus.PRODUCED)
+            await self.repository.update_status(
+                session,
+                event.event_id,
+                repository_protocol.EventStatus.PRODUCED,
+            )
 
     async def produce_one(self, event_id: uuid.UUID) -> None:
         async with self.repository as session:

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/outbox/protocol.py

@@ -11,33 +11,45 @@ Event: typing.TypeAlias = ev.NotificationEvent | ev.ECSTEvent
 class Outbox(typing.Protocol):
     def add(self, event: Event):
         """Adds event to outbox"""
+        raise NotImplementedError
 
     async def save(self):
         """Commits events to the storage"""
+        raise NotImplementedError
 
     async def get_events(self, batch_size: int = 100) -> typing.List[Event]:
         """Returns not produced events"""
+        raise NotImplementedError
 
     async def get_event(self, event_id: uuid.UUID) -> Event | None:
         """Returns event by id"""
+        raise NotImplementedError
 
     async def mark_as_produced(self, event_id: uuid.UUID) -> None:
         """Marks event as produced"""
+        raise NotImplementedError
 
     async def mark_as_failure(self, event_id: uuid.UUID) -> None:
         """Marks event as not produced with failure"""
+        raise NotImplementedError
 
 
 class EventProducer(abc.ABC):
     @abc.abstractmethod
     async def produce_one(self, event_id: uuid.UUID) -> None:
         """Produces event to broker"""
+        raise NotImplementedError
 
     @abc.abstractmethod
     async def produce_batch(self, batch_size: int = 100) -> None:
         """Produces events to broker"""
+        raise NotImplementedError
 
-    async def periodically_task(self, batch_size: int = 100, wait_ms: int = 500) -> None:
+    async def periodically_task(
+        self,
+        batch_size: int = 100,
+        wait_ms: int = 500,
+    ) -> None:
         """Calls produce periodically with specified delay"""
         while True:
             await asyncio.sleep(float(wait_ms) / 1000.0)

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/outbox/sqlalchemy.py

@@ -46,13 +46,21 @@ class OutboxModel(Base):
         autoincrement=True,
         comment="Identity",
     )
-    event_id = sqlalchemy.Column(sqlalchemy.Uuid, nullable=False, comment="Event idempotency id")
+    event_id = sqlalchemy.Column(
+        sqlalchemy.Uuid,
+        nullable=False,
+        comment="Event idempotency id",
+    )
     event_id_bin = sqlalchemy.Column(
         sqlalchemy.BINARY(16),
         nullable=False,
         comment="Event idempotency id in 16 bit presentation",
     )
-    event_type = sqlalchemy.Column(sqlalchemy.Enum(EventType), nullable=False, comment="Event type")
+    event_type = sqlalchemy.Column(
+        sqlalchemy.Enum(EventType),
+        nullable=False,
+        comment="Event type",
+    )
     event_status = sqlalchemy.Column(
         sqlalchemy.Enum(repository.EventStatus),
         nullable=False,
@@ -65,7 +73,11 @@ class OutboxModel(Base):
         default=0,
         comment="Event producing flush counter",
     )
-    event_name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False, comment="Event name")
+    event_name = sqlalchemy.Column(
+        sqlalchemy.String(255),
+        nullable=False,
+        comment="Event name",
+    )
 
     created_at = sqlalchemy.Column(
         sqlalchemy.DateTime,
@@ -73,10 +85,17 @@ class OutboxModel(Base):
         server_default=func.now(),
         comment="Event creation timestamp",
     )
-    payload = sqlalchemy.Column(mysql.BLOB, nullable=False, default={}, comment="Event payload")
+    payload = sqlalchemy.Column(
+        mysql.BLOB,
+        nullable=False,
+        default={},
+        comment="Event payload",
+    )
 
     def row_to_dict(self) -> typing.Dict[typing.Text, typing.Any]:
-        return {column.name: getattr(self, column.name) for column in self.__table__.columns}
+        return {
+            column.name: getattr(self, column.name) for column in self.__table__.columns
+        }
 
     @classmethod
     def get_batch_query(cls, size: int) -> sqlalchemy.Select:
@@ -85,7 +104,12 @@ class OutboxModel(Base):
             .select_from(cls)
             .where(
                 sqlalchemy.and_(
-                    cls.event_status.in_([repository.EventStatus.NEW, repository.EventStatus.NOT_PRODUCED]),
+                    cls.event_status.in_(
+                        [
+                            repository.EventStatus.NEW,
+                            repository.EventStatus.NOT_PRODUCED,
+                        ],
+                    ),
                     cls.flush_counter < MAX_FLUSH_COUNTER_VALUE,
                 ),
             )
@@ -103,7 +127,12 @@ class OutboxModel(Base):
             .where(
                 sqlalchemy.and_(
                     cls.event_id_bin == func.UUID_TO_BIN(event_id),
-                    cls.event_status.in_([repository.EventStatus.NEW, repository.EventStatus.NOT_PRODUCED]),
+                    cls.event_status.in_(
+                        [
+                            repository.EventStatus.NEW,
+                            repository.EventStatus.NOT_PRODUCED,
+                        ],
+                    ),
                     cls.flush_counter < MAX_FLUSH_COUNTER_VALUE,
                 ),
             )
@@ -116,19 +145,23 @@ class OutboxModel(Base):
     def update_status_query(
         cls,
         event_id: uuid.UUID,
-        status: typing.Literal[
-            repository.EventStatus.PRODUCED,
-            repository.EventStatus.NOT_PRODUCED,
-        ],
+        status: repository.EventStatus,
     ) -> sqlalchemy.Update:
-        values = {"event_status": status}
+        values = {
+            "event_status": status,
+            "flush_counter": cls.flush_counter,
+        }
         if status == repository.EventStatus.NOT_PRODUCED:
-            values["flush_counter"] = cls.flush_counter + 1
+            values["flush_counter"] += 1
 
-        return sqlalchemy.update(cls).where(cls.event_id_bin == func.UUID_TO_BIN(event_id)).values(**values)
+        return (
+            sqlalchemy.update(cls)
+            .where(cls.event_id_bin == func.UUID_TO_BIN(event_id))
+            .values(**values)
+        )
 
     @classmethod
-    def status_sorting_case(cls) -> sqlalchemy.case:
+    def status_sorting_case(cls) -> sqlalchemy.Case:
         return sqlalchemy.case(
             {
                 repository.EventStatus.NEW: 1,
@@ -140,8 +173,12 @@ class OutboxModel(Base):
         )
 
 
-class SqlAlchemyOutboxedEventRepository(repository.OutboxedEventRepository[sql_session.AsyncSession]):
-    EVENT_CLASS_MAPPING: typing.ClassVar[typing.Dict[EventType, typing.Type[repository.Event]]] = {
+class SqlAlchemyOutboxedEventRepository(
+    repository.OutboxedEventRepository[sql_session.AsyncSession],
+):
+    EVENT_CLASS_MAPPING: typing.ClassVar[
+        typing.Dict[EventType, typing.Type[repository.Event]]
+    ] = {
         EventType.NOTIFICATION_EVENT: ev.NotificationEvent,
         EventType.ECST_EVENT: ev.ECSTEvent,
     }
@@ -164,26 +201,42 @@ class SqlAlchemyOutboxedEventRepository(repository.OutboxedEventRepository[sql_s
     def _process_events(self, model: OutboxModel) -> repository.Event:
         event_dict = model.row_to_dict()
         event_dict["payload"] = orjson.loads(
-            self._compressor.decompress(event_dict["payload"]) if self._compressor else event_dict["payload"],
+            self._compressor.decompress(event_dict["payload"])
+            if self._compressor
+            else event_dict["payload"],
+        )
+        return self.EVENT_CLASS_MAPPING[event_dict["event_type"]].model_validate(
+            event_dict,
         )
-        return self.EVENT_CLASS_MAPPING[event_dict["event_type"]].model_validate(event_dict)
 
-    async def get_many(self, session: sql_session.AsyncSession, batch_size: int = 100) -> typing.List[repository.Event]:
+    async def get_many(
+        self,
+        session: sql_session.AsyncSession,
+        batch_size: int = 100,
+    ) -> typing.List[repository.Event]:
         events: typing.Sequence[OutboxModel] = (
-            (await session.execute(OutboxModel.get_batch_query(batch_size))).scalars().all()
+            (await session.execute(OutboxModel.get_batch_query(batch_size)))
+            .scalars()
+            .all()
         )
 
         tasks = []
         for event in events:
-            if not self.EVENT_CLASS_MAPPING.get(event.event_type):
+            if not self.EVENT_CLASS_MAPPING.get(EventType(event.event_type)):
                 logger.warning(f"Unknown event type for {event}")
                 continue
             tasks.append(asyncio.to_thread(self._process_events, event))
 
         return await asyncio.gather(*tasks)  # noqa
 
-    async def get_one(self, session: sql_session.AsyncSession, event_id: uuid.UUID) -> repository.Event | None:
-        event: OutboxModel | None = (await session.execute(OutboxModel.get_event_query(event_id))).scalar()
+    async def get_one(
+        self,
+        session: sql_session.AsyncSession,
+        event_id: uuid.UUID,
+    ) -> repository.Event | None:
+        event: OutboxModel | None = (
+            await session.execute(OutboxModel.get_event_query(event_id))
+        ).scalar()
 
         if event is None:
             return
@@ -194,7 +247,9 @@ class SqlAlchemyOutboxedEventRepository(repository.OutboxedEventRepository[sql_s
 
         event_dict = event.row_to_dict()
         event_dict["payload"] = orjson.loads(
-            self._compressor.decompress(event_dict["payload"]) if self._compressor else event_dict["payload"],
+            self._compressor.decompress(event_dict["payload"])
+            if self._compressor
+            else event_dict["payload"],
         )
 
         return self.EVENT_CLASS_MAPPING[event.event_type].model_validate(event_dict)
@@ -205,7 +260,9 @@ class SqlAlchemyOutboxedEventRepository(repository.OutboxedEventRepository[sql_s
         event_id: uuid.UUID,
         new_status: repository.EventStatus,
     ) -> None:
-        await session.execute(OutboxModel.update_status_query(event_id, new_status))
+        await session.execute(
+            statement=OutboxModel.update_status_query(event_id, new_status),
+        )
 
     async def commit(self, session: sql_session.AsyncSession):
         await session.commit()
@@ -218,6 +275,7 @@ class SqlAlchemyOutboxedEventRepository(repository.OutboxedEventRepository[sql_s
         return self.session
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.session.rollback()
-        await self.session.close()
-        self.session = None
+        if self.session:
+            await self.session.rollback()
+            await self.session.close()
+            self.session = None

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/cqrs/requests/bootstrap.py

@@ -6,16 +6,15 @@ import cqrs
 from cqrs import events, requests
 from cqrs.container import di as ed_di_container
 from cqrs.message_brokers import devnull, protocol
-from cqrs.middlewares import base as mediator_middlewares
-from cqrs.middlewares import logging as logging_middleware
+from cqrs.middlewares import base as mediator_middlewares, logging as logging_middleware
 
 DEFAULT_MESSAGE_BROKER = devnull.DevnullMessageBroker()
 
 
 def setup_event_emitter(
-    container: ed_di_container.DIContainer | None,
-    domain_events_mapper: typing.Callable[[events.EventMap], None] = None,
-    message_broker: protocol.MessageBroker = None,
+    container: ed_di_container.DIContainer,
+    domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
+    message_broker: protocol.MessageBroker | None = None,
 ):
     if message_broker is None:
         message_broker = DEFAULT_MESSAGE_BROKER
@@ -33,12 +32,11 @@ def setup_event_emitter(
 
 def setup_mediator(
     event_emitter: events.EventEmitter,
-    container: ed_di_container.DIContainer | None,
-    middlewares: typing.Iterable[mediator_middlewares.Middleware] | None = None,
-    commands_mapper: typing.Callable[[requests.RequestMap], None] = None,
-    queries_mapper: typing.Callable[[requests.RequestMap], None] = None,
+    container: ed_di_container.DIContainer,
+    middlewares: typing.Iterable[mediator_middlewares.Middleware],
+    commands_mapper: typing.Callable[[requests.RequestMap], None] | None = None,
+    queries_mapper: typing.Callable[[requests.RequestMap], None] | None = None,
 ) -> cqrs.RequestMediator:
-
     requests_mapper = requests.RequestMap()
     if commands_mapper:
         commands_mapper(requests_mapper)
@@ -46,8 +44,6 @@ def setup_mediator(
         queries_mapper(requests_mapper)
 
     middleware_chain = mediator_middlewares.MiddlewareChain()
-    if middlewares is None:
-        middlewares = []
 
     for middleware in middlewares:
         middleware_chain.add(middleware)
@@ -61,12 +57,12 @@ def setup_mediator(
 
 
 def bootstrap(
+    di_container: di.Container,
     message_broker: protocol.MessageBroker | None = None,
-    di_container: di.Container | None = None,
-    middlewares: typing.Iterable[mediator_middlewares.Middleware] | None = None,
-    commands_mapper: typing.Callable[[requests.RequestMap], None] = None,
-    domain_events_mapper: typing.Callable[[events.EventMap], None] = None,
-    queries_mapper: typing.Callable[[requests.RequestMap], None] = None,
+    middlewares: typing.Sequence[mediator_middlewares.Middleware] | None = None,
+    commands_mapper: typing.Callable[[requests.RequestMap], None] | None = None,
+    domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
+    queries_mapper: typing.Callable[[requests.RequestMap], None] | None = None,
     on_startup: typing.List[typing.Callable[[], None]] | None = None,
 ) -> cqrs.RequestMediator:
     if message_broker is None:
@@ -77,18 +73,20 @@ def bootstrap(
     for fun in on_startup:
         fun()
 
-    if middlewares is None:
-        middlewares = []
     container = ed_di_container.DIContainer(di_container)
+
     event_emitter = setup_event_emitter(
         container,
         domain_events_mapper,
         message_broker,
     )
+    middlewares_list: typing.List[mediator_middlewares.Middleware] = list(
+        middlewares or [],
+    )
     return setup_mediator(
         event_emitter,
         container,
-        middlewares=middlewares + [logging_middleware.LoggingMiddleware()],
+        middlewares=middlewares_list + [logging_middleware.LoggingMiddleware()],
         commands_mapper=commands_mapper,
         queries_mapper=queries_mapper,
     )

python_cqrs-0.0.5/src/cqrs/requests/map.py

@@ -0,0 +1,27 @@
+import typing
+
+from cqrs import response
+from cqrs.requests import request, request_handler
+
+_KT = typing.TypeVar("_KT", bound=typing.Type[request.Request])
+_VT = typing.TypeVar(
+    "_VT",
+    bound=typing.Type[
+        request_handler.RequestHandler[request.Request, response.Response]
+    ],
+)
+
+
+class RequestMap(typing.Dict[_KT, _VT]):
+    _registry: typing.Dict[_KT, _VT]
+
+    def bind(self, request_type: _KT, handler_type: _VT) -> None:
+        self[request_type] = handler_type
+
+    def __setitem__(self, __key: _KT, __value: _VT) -> None:
+        if __key in self:
+            raise KeyError(f"{__key} already exists in registry")
+        super().__setitem__(__key, __value)
+
+    def __delitem__(self, __key):
+        raise TypeError(f"{self.__class__.__name__} has no delete method")

{python_cqrs-0.0.2 → python_cqrs-0.0.5/src/python_cqrs.egg-info}/PKG-INFO

@@ -1,7 +1,9 @@
 Metadata-Version: 2.1
 Name: python-cqrs
-Version: 0.0.2
-Author: Vadim Kozyrevskiy
+Version: 0.0.5
+Summary: Python CQRS pattern implementation
+Author: Nikita Kunov
+Author-email: Vadim Kozyrevskiy <vadikko2@mail.ru>, Dmitriy Kutlubaev <kutlubaev00@mail.ru>
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic==2.*
@@ -10,22 +12,19 @@ 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
-Provides-Extra: git
-Requires-Dist: pre-commit==3.8.0; extra == "git"
+Provides-Extra: dev
+Requires-Dist: pre-commit==3.8.0; extra == "dev"
+Requires-Dist: pyright==1.1.377; extra == "dev"
+Requires-Dist: ruff==0.6.2; extra == "dev"
+Requires-Dist: aiokafka==0.10.0; extra == "dev"
+Requires-Dist: pytest~=7.4.2; extra == "dev"
+Requires-Dist: pytest-asyncio~=0.21.1; extra == "dev"
+Requires-Dist: pytest-env==0.6.2; extra == "dev"
+Requires-Dist: python-dotenv==1.0.1; extra == "dev"
+Requires-Dist: cryptography==42.0.2; extra == "dev"
+Requires-Dist: asyncmy==0.2.9; extra == "dev"
 Provides-Extra: kafka
 Requires-Dist: aiokafka==0.10.0; extra == "kafka"
-Provides-Extra: lint
-Requires-Dist: flake8==7.0.0; extra == "lint"
-Requires-Dist: flake8-pytest; extra == "lint"
-Requires-Dist: black; extra == "lint"
-Provides-Extra: tests
-Requires-Dist: aiokafka==0.10.0; extra == "tests"
-Requires-Dist: pytest~=7.4.2; extra == "tests"
-Requires-Dist: pytest-asyncio~=0.21.1; extra == "tests"
-Requires-Dist: pytest-env==0.6.2; extra == "tests"
-Requires-Dist: python-dotenv==1.0.1; extra == "tests"
-Requires-Dist: cryptography==42.0.2; extra == "tests"
-Requires-Dist: asyncmy==0.2.9; extra == "tests"
 
 # CQRS
 

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/python_cqrs.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 pyproject.toml
 src/cqrs/__init__.py
 src/cqrs/mediator.py
-src/cqrs/registry.py
 src/cqrs/response.py
 src/cqrs/adapters/__init__.py
 src/cqrs/adapters/amqp.py

{python_cqrs-0.0.2 → python_cqrs-0.0.5}/src/python_cqrs.egg-info/requires.txt

@@ -5,18 +5,10 @@ di[anyio]==0.79.2
 sqlalchemy[asyncio]==2.0.*
 retry-async==0.1.4
 
-[git]
+[dev]
 pre-commit==3.8.0
-
-[kafka]
-aiokafka==0.10.0
-
-[lint]
-flake8==7.0.0
-flake8-pytest
-black
-
-[tests]
+pyright==1.1.377
+ruff==0.6.2
 aiokafka==0.10.0
 pytest~=7.4.2
 pytest-asyncio~=0.21.1
@@ -24,3 +16,6 @@ pytest-env==0.6.2
 python-dotenv==1.0.1
 cryptography==42.0.2
 asyncmy==0.2.9
+
+[kafka]
+aiokafka==0.10.0

python_cqrs-0.0.2/src/cqrs/container/di.py

@@ -1,19 +0,0 @@
-import typing
-
-import di
-from di import dependent, executors
-
-from cqrs import container
-
-T = typing.TypeVar("T")
-
-
-class DIContainer(container.Container[di.Container]):
-    def __init__(self, external_container: di.Container | None = None) -> None:
-        self._external_container = external_container
-
-    async def resolve(self, type_: typing.Type[T]) -> T:
-        executor = executors.AsyncExecutor()
-        solved = self._external_container.solve(dependent.Dependent(type_, scope="request"), scopes=["request"])
-        with self._external_container.enter_scope("request") as state:
-            return await solved.execute_async(executor=executor, state=state)

python_cqrs-0.0.2/src/cqrs/events/map.py

@@ -1,27 +0,0 @@
-import collections
-import typing
-
-from cqrs import registry
-from cqrs.events import event, event_handler
-
-E = typing.TypeVar("E", bound=event.Event, contravariant=True)
-
-
-class EventMap(registry.InMemoryRegistry[typing.Type[E]], typing.List[typing.Type[event_handler.EventHandler]]):
-    _registry: collections.defaultdict
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._registry = collections.defaultdict(list)
-
-    def bind(self, event_type: typing.Type[E], handler_type: typing.Type[event_handler.EventHandler[E]]) -> None:
-        self[event_type].append(handler_type)
-
-    def get(self, event_type: typing.Type[E]) -> typing.List[typing.Type[event_handler.EventHandler[E]]]:
-        return self._registry[event_type]
-
-    def get_events(self) -> list[typing.Type[E]]:
-        return list(self.keys())
-
-    def __str__(self) -> str:
-        return str(self._registry)

python_cqrs-0.0.2/src/cqrs/registry.py

@@ -1,29 +0,0 @@
-import typing
-from collections import abc
-
-_VT = typing.TypeVar("_VT")
-_KT = typing.TypeVar("_KT")
-
-
-class InMemoryRegistry(abc.MutableMapping[_KT, _VT]):
-    _registry: typing.Dict[_KT, _VT]
-
-    def __init__(self):
-        self._registry = dict()
-
-    def __setitem__(self, __key: _KT, __value: _VT) -> None:
-        if __key in self._registry:
-            raise KeyError(f"{__key} already exists in registry")
-        self._registry[__key] = __value
-
-    def __delitem__(self, __key):
-        raise TypeError(f"{self.__class__.__name__} has no delete method")
-
-    def __getitem__(self, __key: _KT) -> _VT:
-        return self._registry[__key]
-
-    def __len__(self):
-        return len(self._registry.keys())
-
-    def __iter__(self):
-        return iter(self._registry.keys())

python_cqrs-0.0.2/src/cqrs/requests/map.py

@@ -1,30 +0,0 @@
-import typing
-
-from cqrs import registry
-from cqrs.requests import request, request_handler
-
-TReq = typing.TypeVar("TReq", bound=typing.Type[request.Request], contravariant=True)
-TH = typing.TypeVar("TH", bound=typing.Type[request_handler.RequestHandler], contravariant=True)
-
-
-class RequestMap(registry.InMemoryRegistry[TReq, TH]):
-    def bind(
-        self,
-        request_type: TReq,
-        handler_type: TH,
-    ) -> None:
-        self._registry[request_type] = handler_type
-
-    def get(self, request_type: TReq) -> TH:
-        handler_type = self._registry.get(request_type)
-        if not handler_type:
-            raise RequestHandlerDoesNotExist("RequestHandler not found matching Request type.")
-
-        return handler_type
-
-    def __str__(self) -> str:
-        return str(self._registry)
-
-
-class RequestHandlerDoesNotExist(Exception):
-    ...