python-cqrs 0.0.2__py3-none-any.whl

cqrs/__init__.py

@@ -0,0 +1,28 @@
+from cqrs.compressors.protocol import Compressor
+from cqrs.compressors.zlib import ZlibCompressor
+from cqrs.events.event import DomainEvent, ECSTEvent, NotificationEvent
+from cqrs.events.event_emitter import EventEmitter
+from cqrs.events.event_handler import EventHandler
+from cqrs.mediator import EventMediator, RequestMediator
+from cqrs.outbox.producer import EventProducer
+from cqrs.outbox.repository import OutboxedEventRepository
+from cqrs.outbox.sqlalchemy import SqlAlchemyOutboxedEventRepository
+from cqrs.requests.request import Request
+from cqrs.requests.request_handler import RequestHandler
+
+__all__ = (
+    "RequestMediator",
+    "EventMediator",
+    "DomainEvent",
+    "NotificationEvent",
+    "ECSTEvent",
+    "EventEmitter",
+    "EventHandler",
+    "RequestHandler",
+    "Request",
+    "OutboxedEventRepository",
+    "SqlAlchemyOutboxedEventRepository",
+    "EventProducer",
+    "Compressor",
+    "ZlibCompressor",
+)

cqrs/adapters/amqp.py

@@ -0,0 +1,63 @@
+import asyncio
+import typing
+from functools import partial
+
+import aio_pika
+from aio_pika import abc, pool
+
+
+async def connection_pool_factory(url: str) -> abc.AbstractRobustConnection:
+    return await aio_pika.connect_robust(url=url)
+
+
+async def channel_pool_factory(connection_pool: pool.Pool) -> aio_pika.Channel:
+    async with connection_pool.acquire() as connection:
+        return await connection.channel()
+
+
+class AMQPPublisher:
+    def __init__(self, url: str, max_connection_pool_size=2, max_channel_pool_size=10):
+        self.url = url
+        self.max_connection_pool_size = max_connection_pool_size
+        self.max_channel_pool_size = max_channel_pool_size
+        self.connection_pool: pool.Pool = pool.Pool(
+            partial(connection_pool_factory, url=url),
+            max_size=self.max_connection_pool_size,
+        )
+        self.channel_pool: pool.Pool = pool.Pool(
+            partial(channel_pool_factory, connection_pool=self.connection_pool),
+            max_size=self.max_channel_pool_size,
+        )
+
+    async def publish(self, message: abc.AbstractMessage, queue_name: str, exchange_name: str) -> None:
+        async with self.channel_pool.acquire() as channel:
+            queue: aio_pika.Queue = await channel.declare_queue(queue_name)
+            exchange: aio_pika.Exchange = await channel.declare_exchange(exchange_name, type="direct", auto_delete=True)
+            await queue.bind(exchange=exchange, routing_key=queue_name)
+            await exchange.publish(message=message, routing_key=queue_name)
+
+
+class AMQPConsumer:
+    def __init__(self, url: str, max_connection_pool_size=2, max_channel_pool_size=10):
+        self.url = url
+        self.max_connection_pool_size = max_connection_pool_size
+        self.max_channel_pool_size = max_channel_pool_size
+        self.connection_pool: pool.Pool = pool.Pool(
+            partial(connection_pool_factory, url=url),
+            max_size=self.max_connection_pool_size,
+        )
+        self.channel_pool: pool.Pool = pool.Pool(
+            partial(channel_pool_factory, connection_pool=self.connection_pool),
+            max_size=self.max_channel_pool_size,
+        )
+
+    async def consume(
+        self,
+        handler: typing.Callable[[abc.AbstractIncomingMessage], typing.Awaitable[None]],
+        queue_name: str,
+    ) -> None:
+        async with self.channel_pool.acquire() as channel:
+            await channel.set_qos(prefetch_count=1)
+            queue = await channel.declare_queue(queue_name)
+            await queue._consume(handler)
+            await asyncio.Future()

cqrs/adapters/kafka.py

@@ -0,0 +1,102 @@
+import asyncio
+import functools
+import logging
+import typing
+
+import aiokafka
+import orjson
+import retry_async
+from aiokafka import errors
+
+from cqrs.message_brokers import protocol
+
+__all__ = (
+    "KafkaProducer",
+    "kafka_producer_factory",
+)
+
+_retry = functools.partial(
+    retry_async.retry,
+    exceptions=(
+        errors.KafkaConnectionError,
+        errors.NodeNotReadyError,
+        errors.RequestTimedOutError,
+    ),
+    is_async=True,
+)
+
+SecurityProtocol: typing.TypeAlias = typing.Literal["PLAINTEXT", "SSL", "SASL_PLAINTEXT", "SASL_SSL"]
+SaslMechanism: typing.TypeAlias = typing.Literal["PLAIN", "GSSAPI", "SCRAM-SHA-256", "SCRAM-SHA-512", "OAUTHBEARER"]
+
+logger = logging.getLogger("cqrs")
+logger.setLevel(logging.DEBUG)
+
+
+def _serializer(message: protocol.Message) -> typing.ByteString:
+    return orjson.dumps(message.model_dump(mode="json"))
+
+
+class _Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(_Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class KafkaProducer(metaclass=_Singleton):
+    def __init__(
+        self,
+        producer: aiokafka.AIOKafkaProducer,
+        topics: typing.List[typing.Text],
+        retry_count: int,
+        retry_delay: int,
+    ):
+        self._topics = topics
+        self._producer = producer
+        self._retry_count = retry_count
+        self._retry_delay = retry_delay
+
+    async def _check_connection(self):
+        node_id = self._producer.client.get_random_node()
+        if not await self._producer.client.ready(node_id=node_id):
+            await self._producer.start()
+
+    async def _produce(self, message: protocol.Message):
+        await self._check_connection()
+        for topic in self._topics:
+            logger.debug(f"produce message {message} to topic {topic}")
+            await self._producer.send_and_wait(topic, value=message)
+
+    async def produce(self, message: protocol.Message):
+        """
+        Produces event to kafka broker.
+        Tries to reconnect if connect has been lost or has not been opened.
+        """
+        await _retry(tries=self._retry_count, delay=self._retry_delay)(self._produce)(message)
+
+
+def kafka_producer_factory(
+    dsn: typing.Text,
+    topics: typing.List[typing.Text],
+    security_protocol: SecurityProtocol = "PLAINTEXT",
+    sasl_mechanism: SaslMechanism = "PLAIN",
+    retry_count: int = 3,
+    retry_delay: int = 1,
+    user: typing.Text | None = None,
+    password: typing.Text | None = None,
+) -> KafkaProducer:
+    loop = asyncio.get_event_loop()
+    asyncio.set_event_loop(loop)
+
+    producer = aiokafka.AIOKafkaProducer(
+        bootstrap_servers=dsn,
+        value_serializer=_serializer,
+        security_protocol=security_protocol,
+        sasl_mechanism=sasl_mechanism,
+        sasl_plain_username=user,
+        sasl_plain_password=password,
+        loop=loop,
+    )
+    return KafkaProducer(producer=producer, topics=topics, retry_count=retry_count, retry_delay=retry_delay)

cqrs/compressors/protocol.py

@@ -0,0 +1,9 @@
+import typing
+
+
+class Compressor(typing.Protocol):
+    def compress(self, value: bytes) -> bytes:
+        """Compress value"""
+
+    def decompress(self, value: bytes) -> bytes:
+        """Decompress compressed value"""

cqrs/compressors/zlib.py

@@ -0,0 +1,9 @@
+import zlib
+
+
+class ZlibCompressor:
+    def compress(self, value: bytes) -> bytes:
+        return zlib.compress(value)
+
+    def decompress(self, value: bytes) -> bytes:
+        return zlib.decompress(value)

cqrs/container/__init__.py

@@ -0,0 +1,3 @@
+from cqrs.container.protocol import Container
+
+__all__ = ("Container",)

cqrs/container/di.py

@@ -0,0 +1,19 @@
+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)

cqrs/container/protocol.py

@@ -0,0 +1,20 @@
+import typing
+
+T = typing.TypeVar("T")
+C = typing.TypeVar("C")
+
+
+class Container(typing.Protocol[C]):
+    """
+    The container interface.
+    """
+
+    @property
+    def external_container(self) -> C:
+        ...
+
+    def attach_external_container(self, container: C) -> None:
+        ...
+
+    async def resolve(self, type_: typing.Type[T]) -> T:
+        ...

cqrs/dispatcher/__init__.py

@@ -0,0 +1,7 @@
+from cqrs.dispatcher.dispatcher import EventDispatcher, RequestDispatcher, RequestDispatchResult
+
+__all__ = (
+    "RequestDispatchResult",
+    "RequestDispatcher",
+    "EventDispatcher",
+)

cqrs/dispatcher/dispatcher.py

@@ -0,0 +1,64 @@
+import logging
+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
+
+logger = logging.getLogger("cqrs")
+
+
+class RequestDispatchResult(pydantic.BaseModel):
+    response: res.Response | None = pydantic.Field(default=None)
+    events: typing.List[cqrs_events.Event] = pydantic.Field(default_factory=list)
+
+
+class RequestDispatcher:
+    def __init__(
+        self,
+        request_map: requests.RequestMap,
+        container: di_container.Container,
+        middleware_chain: middlewares.MiddlewareChain | None = None,
+    ) -> None:
+        self._request_map = request_map
+        self._container = container
+        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 = await self._container.resolve(handler_type)
+        wrapped_handle = self._middleware_chain.wrap(handler.handle)
+        response = await wrapped_handle(request)
+        return RequestDispatchResult(response=response, events=handler.events)
+
+
+E = typing.TypeVar("E", bound=cqrs_events.Event, contravariant=True)
+
+
+class EventDispatcher:
+    def __init__(
+        self,
+        event_map: cqrs_events.EventMap,
+        container: di_container.Container,
+        middleware_chain: middlewares.MiddlewareChain | None = None,
+    ):
+        self._event_map = event_map
+        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]]):
+        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))
+        if not handler_types:
+            logger.warning(
+                "Handlers for event %s not found",
+                type(event).__name__,
+            )
+        for h_type in handler_types:
+            await self._handle_event(event, h_type)

cqrs/events/__init__.py

@@ -0,0 +1,14 @@
+from cqrs.events.event import DomainEvent, ECSTEvent, Event, NotificationEvent
+from cqrs.events.event_emitter import EventEmitter
+from cqrs.events.event_handler import EventHandler
+from cqrs.events.map import EventMap
+
+__all__ = (
+    "Event",
+    "DomainEvent",
+    "ECSTEvent",
+    "NotificationEvent",
+    "EventEmitter",
+    "EventHandler",
+    "EventMap",
+)

cqrs/events/bootstrap.py

@@ -0,0 +1,55 @@
+import typing
+
+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
+
+
+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,
+) -> cqrs.EventMediator:
+
+    _events_mapper = events.EventMap()
+    if events_mapper:
+        events_mapper(_events_mapper)
+
+    middleware_chain = mediator_middlewares.MiddlewareChain()
+    if middlewares is None:
+        middlewares = []
+
+    for middleware in middlewares:
+        middleware_chain.add(middleware)
+
+    return cqrs.EventMediator(
+        event_map=_events_mapper,
+        container=container,
+        middleware_chain=middleware_chain,
+    )
+
+
+def bootstrap(
+    di_container: di.Container | None = None,
+    middlewares: typing.Iterable[mediator_middlewares.Middleware] | None = None,
+    events_mapper: typing.Callable[[events.EventMap], None] = None,
+    on_startup: typing.List[typing.Callable[[], None]] | None = None,
+) -> cqrs.EventMediator:
+    if on_startup is None:
+        on_startup = []
+
+    for fun in on_startup:
+        fun()
+
+    if middlewares is None:
+        middlewares = []
+    container = ed_di_container.DIContainer(di_container)
+    return setup_mediator(
+        container,
+        events_mapper=events_mapper,
+        middlewares=middlewares + [logging_middleware.LoggingMiddleware()],
+    )

cqrs/events/event.py

@@ -0,0 +1,86 @@
+import datetime
+import typing
+import uuid
+
+import pydantic
+
+
+class Event(pydantic.BaseModel, frozen=True):
+    """The base class for events"""
+
+
+class DomainEvent(Event):
+    """
+    The base class for domain events.
+    """
+
+
+_P = typing.TypeVar("_P")
+
+
+class NotificationEvent(Event):
+    """
+    The base class for notification events.
+
+    Contains only identification information about state change.
+
+    Example plain structure::
+
+      {
+          "event_id": "82a0b10e-1b3d-4c3c-9bdd-3934f8f824c2",
+          "event_timestamp": "2023-03-06 12:11:35.103792",
+          "event_topic": "user_notification_events",
+          "payload": {
+              "changed_user_id": 987
+          }
+      }
+
+    """
+
+    event_id: uuid.UUID = pydantic.Field(default_factory=uuid.uuid4)
+    event_timestamp: datetime.datetime = pydantic.Field(default_factory=datetime.datetime.now)
+    event_name: typing.Text
+    event_type: typing.ClassVar[typing.Text] = "notification_event"
+
+    payload: typing.Dict = pydantic.Field(default_factory=dict)
+
+    model_config = pydantic.ConfigDict(from_attributes=True)
+
+    def __hash__(self):
+        return hash(self.event_id)
+
+
+class ECSTEvent(Event, typing.Generic[_P]):
+    """
+    Base class for ECST events.
+
+    ECST means event-carried state transfer.
+
+    Contains full information about state change.
+
+    Example plain structure::
+
+      {
+          "event_id": "82a0b10e-1b3d-4c3c-9bdd-3934f8f824c2",
+          "event_timestamp": "2023-03-06 12:11:35.103792",
+          "event_topic": "user_ecst_events",
+          "payload": {
+              "user_id": 987,
+              "new_user_last_name": "Doe",
+              "new_user_nickname": "kend"
+          }
+      }
+
+    """
+
+    event_id: uuid.UUID = pydantic.Field(default_factory=uuid.uuid4)
+    event_timestamp: datetime.datetime = pydantic.Field(default_factory=datetime.datetime.now)
+    event_name: typing.Text
+    event_type: typing.ClassVar = "ecst_event"
+
+    payload: _P | None = pydantic.Field(default=None)
+
+    model_config = pydantic.ConfigDict(from_attributes=True)
+
+    def __hash__(self):
+        return hash(self.event_id)

cqrs/events/event_emitter.py

@@ -0,0 +1,86 @@
+import functools
+import logging
+
+from cqrs import container, message_brokers
+from cqrs.events import event, map
+
+logger = logging.getLogger("cqrs")
+
+
+class EventEmitter:
+    """
+    The event emitter is responsible for sending events to the according handlers or
+    to the message broker abstraction.
+    """
+
+    def __init__(
+        self,
+        event_map: map.EventMap,
+        container: container.Container,
+        message_broker: message_brokers.MessageBroker | None = None,
+    ) -> None:
+        self._event_map = event_map
+        self._container = container
+        self._message_broker = message_broker
+
+    @functools.singledispatchmethod
+    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))
+        if not handlers_types:
+            logger.warning(
+                "Handlers for domain event %s not found",
+                type(event).__name__,
+            )
+        for handler_type in handlers_types:
+            handler = 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)
+
+    @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.")
+
+        message = _build_message(event)
+
+        logger.debug(
+            "Sending Notification Event(%s) to message broker %s",
+            event.event_id,
+            type(self._message_broker).__name__,
+        )
+
+        await self._message_broker.send_message(message)
+
+    @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.")
+
+        message = _build_message(event)
+
+        logger.debug(
+            "Sending ECST event(%s) to message broker %s",
+            event.event_id,
+            type(self._message_broker).__name__,
+        )
+
+        await self._message_broker.send_message(message)
+
+
+def _build_message(event: event.NotificationEvent | event.ECSTEvent) -> message_brokers.Message:
+    payload = event.model_dump(mode="json")
+
+    return message_brokers.Message(
+        message_type=event.event_type,
+        message_name=type(event).__name__,
+        message_id=event.event_id,
+        payload=payload,
+    )

cqrs/events/event_handler.py

@@ -0,0 +1,24 @@
+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

cqrs/events/map.py

@@ -0,0 +1,27 @@
+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)