buz 2.14.3__tar.gz → 2.15.1__tar.gz

{buz-2.14.3 → buz-2.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.14.3
+Version: 2.15.1
 Summary: Buz is a set of light, simple and extensible implementations of event, command and query buses.
 License: MIT
 Author: Luis Pintado Lozano

{buz-2.14.3 → buz-2.15.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "buz"
-version = "2.14.3"
+version = "2.15.1"
 description = "Buz is a set of light, simple and extensible implementations of event, command and query buses."
 readme = "README.md"
 authors = ["Luis Pintado Lozano <luis.pintado.lozano@gmail.com>", "Gerardo Parra <gprauxiliar@gmail.com>"]

{buz-2.14.3 → buz-2.15.1}/src/buz/event/exceptions/subscribers_not_found_exception.py

@@ -1,11 +1,15 @@
 from typing import Optional, Sequence
 
-from buz.event import Event, Subscriber
+from buz.event import Event
+from buz.event.meta_subscriber import MetaSubscriber
 
 
 class SubscribersNotFoundException(Exception):
     def __init__(
-        self, event: Event, allowed_subscriber_fqns: set[str], event_subscribers: Optional[Sequence[Subscriber]] = None
+        self,
+        event: Event,
+        allowed_subscriber_fqns: set[str],
+        event_subscribers: Optional[Sequence[MetaSubscriber]] = None,
     ) -> None:
         self.event = event
         self.allowed_subscriber_fqns = allowed_subscriber_fqns

{buz-2.14.3 → buz-2.15.1}/src/buz/event/infrastructure/kombu/kombu_consumer.py

@@ -1,3 +1,4 @@
+import asyncio
 from logging import Logger
 from typing import Optional, Callable, cast
 
@@ -5,11 +6,14 @@ from kombu import Connection, Queue, Consumer as MessageConsumer, Message
 from kombu.mixins import ConsumerMixin
 from kombu.transport.pyamqp import Channel
 
-from buz.event import Event, Subscriber
+from buz.event import Event
+from buz.event.async_subscriber import AsyncSubscriber
 from buz.event.infrastructure.kombu.allowed_kombu_serializer import AllowedKombuSerializer
 from buz.event.exceptions.term_signal_interruption_exception import TermSignalInterruptionException
+from buz.event.meta_subscriber import MetaSubscriber
 from buz.event.middleware import ConsumeMiddleware, ConsumeMiddlewareChainResolver
 from buz.event.middleware.exceptions.event_already_in_progress_exception import EventAlreadyInProgressException
+from buz.event.subscriber import Subscriber
 from buz.locator import Locator
 from buz.event.consumer import Consumer
 from buz.event.exceptions.event_restore_exception import EventRestoreException
@@ -27,7 +31,7 @@ class KombuConsumer(ConsumerMixin, Consumer):
         queues_mapping: QueueToSubscriberFqnMapping,
         serializer: AllowedKombuSerializer,
         prefetch_count: int,
-        locator: Locator[Event, Subscriber],
+        locator: Locator[Event, MetaSubscriber],
         logger: Logger,
         consume_retrier: Optional[ConsumeRetrier] = None,
         reject_callback: Optional[RejectCallback] = None,
@@ -83,7 +87,7 @@ class KombuConsumer(ConsumerMixin, Consumer):
         except Exception as exc:
             raise EventRestoreException(body, str(message)) from exc
 
-    def __subscribers(self, event: Event, allowed_subscriber_fqns: set[str]) -> list[Subscriber]:
+    def __subscribers(self, event: Event, allowed_subscriber_fqns: set[str]) -> list[MetaSubscriber]:
         event_subscribers = None
         try:
             event_subscribers = self.__locator.get(event)
@@ -97,22 +101,41 @@ class KombuConsumer(ConsumerMixin, Consumer):
         except Exception as exc:
             raise SubscribersNotFoundException(event, allowed_subscriber_fqns, event_subscribers) from exc
 
-    def __consume_event(self, message: Message, event: Event, subscribers: list[Subscriber]) -> None:
+    def __consume_event(self, message: Message, event: Event, meta_subscribers: list[MetaSubscriber]) -> None:
         try:
             if self.should_stop is True:
                 raise TermSignalInterruptionException()
 
-            for subscriber in subscribers:
+            for meta_subscriber in meta_subscribers:
+                # The problem here is that the chain resolver works with syncsubscribers, an asyncsubscriber would require of a async function,
+                # but we are using run-until-complete to run the async function, so we are not really using the async function, we are just running it as a sync function, so we can cast the asyncsubscriber to a subscriber
+                subscriber = cast(Subscriber, meta_subscriber)
                 self.__consume_middleware_chain_resolver.resolve(event, subscriber, self.__perform_consume)
             message.ack()
         except Exception as exc:
-            self.__on_consume_exception(message, event, subscribers, exc)
+            self.__on_consume_exception(message, event, meta_subscribers, exc)
 
-    def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
-        subscriber.consume(event)
+    def __perform_consume(self, event: Event, subscriber: MetaSubscriber) -> None:
+        if isinstance(subscriber, AsyncSubscriber):
+            self.__get_or_create_event_loop().run_until_complete(subscriber.consume(event))
+            return
+
+        if isinstance(subscriber, Subscriber):
+            return subscriber.consume(event)
+
+        raise TypeError(f"Subscriber {subscriber} is not an instance of Subscriber or AsyncSubscriber")
+
+    def __get_or_create_event_loop(self) -> asyncio.AbstractEventLoop:
+        try:
+            return asyncio.get_event_loop()
+        except RuntimeError:
+            self.__logger.warning("The current thread does not have an event loop attached. Creating new event loop.")
+            event_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(event_loop)
+            return event_loop
 
     def __on_consume_exception(
-        self, message: Message, event: Event, subscribers: list[Subscriber], exception: Exception
+        self, message: Message, event: Event, subscribers: list[MetaSubscriber], exception: Exception
     ) -> None:
         if isinstance(exception, EventAlreadyInProgressException) or isinstance(
             exception, TermSignalInterruptionException
@@ -139,7 +162,7 @@ class KombuConsumer(ConsumerMixin, Consumer):
         self.__reject_message(message, event, subscribers, exception)
 
     def __reject_message(
-        self, message: Message, event: Event, subscribers: list[Subscriber], exception: Exception
+        self, message: Message, event: Event, subscribers: list[MetaSubscriber], exception: Exception
     ) -> None:
         message.reject()
         if self.__reject_callback is not None:

{buz-2.14.3 → buz-2.15.1}/src/buz/event/middleware/__init__.py

@@ -1,3 +1,4 @@
+from buz.event.middleware.base_async_consume_middleware import BaseAsyncConsumeMiddleware
 from buz.event.middleware.publish_middleware import PublishMiddleware, PublishCallable
 from buz.event.middleware.base_publish_middleware import BasePublishMiddleware
 from buz.event.middleware.publish_middleware_chain_resolver import PublishMiddlewareChainResolver
@@ -14,4 +15,5 @@ __all__ = [
     "ConsumeCallable",
     "BaseConsumeMiddleware",
     "ConsumeMiddlewareChainResolver",
+    "BaseAsyncConsumeMiddleware",
 ]

buz-2.15.1/src/buz/event/middleware/base_async_consume_middleware.py

@@ -0,0 +1,20 @@
+from abc import abstractmethod
+
+from buz.event import Event
+from buz.event.async_subscriber import AsyncSubscriber
+from buz.event.middleware.async_consume_middleware import AsyncConsumeMiddleware, AsyncConsumeCallable
+
+
+class BaseAsyncConsumeMiddleware(AsyncConsumeMiddleware):
+    async def on_consume(self, event: Event, subscriber: AsyncSubscriber, consume: AsyncConsumeCallable) -> None:
+        await self._before_on_consume(event, subscriber)
+        await consume(event, subscriber)
+        await self._after_on_consume(event, subscriber)
+
+    @abstractmethod
+    async def _before_on_consume(self, event: Event, subscriber: AsyncSubscriber) -> None:
+        pass
+
+    @abstractmethod
+    async def _after_on_consume(self, event: Event, subscriber: AsyncSubscriber) -> None:
+        pass

buz-2.15.1/src/buz/kafka/infrastructure/cdc/cdc_message.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from buz.kafka.infrastructure.cdc.cdc_payload import CDCPayload
+
+
+@dataclass(frozen=True)
+class CDCMessage:
+    payload: CDCPayload
+    schema: Optional[dict]
+
+    def validate(self) -> None:
+        if not isinstance(self.payload, CDCPayload):
+            raise ValueError("The payload value is not a valid value")
+        if self.schema is not None and not isinstance(self.schema, dict):
+            raise ValueError("The schema value is not a valid value")
+
+    def __post_init__(self) -> None:
+        self.validate()

buz-2.14.3/src/buz/kafka/infrastructure/cdc/cdc_message.py → buz-2.15.1/src/buz/kafka/infrastructure/cdc/cdc_payload.py

@@ -22,15 +22,3 @@ class CDCPayload:
 
     def __post_init__(self) -> None:
         self.validate()
-
-
-@dataclass(frozen=True)
-class CDCMessage:
-    payload: CDCPayload
-
-    def validate(self) -> None:
-        if not isinstance(self.payload, CDCPayload):
-            raise ValueError("The payload value is not a valid value")
-
-    def __post_init__(self) -> None:
-        self.validate()

buz-2.15.1/src/buz/kafka/infrastructure/cdc/cdc_schema.py

@@ -0,0 +1,35 @@
+from buz.message import Message
+
+
+def generate_cdc_schema(message: Message) -> dict:
+    return {
+        "type": "struct",
+        "fields": [
+            {
+                "type": "string",
+                "optional": False,
+                "field": "payload",
+            },
+            {
+                "type": "string",
+                "optional": False,
+                "name": "io.debezium.data.Uuid",
+                "version": 1,
+                "field": "event_id",
+            },
+            {
+                "type": "string",
+                "optional": False,
+                "field": "event_fqn",
+            },
+            {
+                "type": "string",
+                "optional": False,
+                "name": "io.debezium.time.ZonedTimestamp",
+                "version": 1,
+                "field": "created_at",
+            },
+        ],
+        "optional": False,
+        "name": f"{message.fqn()}.Value",
+    }

{buz-2.14.3 → buz-2.15.1}/src/buz/kafka/infrastructure/deserializers/implementations/cdc/cdc_record_bytes_to_event_deserializer.py

@@ -7,7 +7,7 @@ import orjson
 from dacite import from_dict
 
 from buz.event import Event
-from buz.kafka.infrastructure.cdc.cdc_message import CDCMessage, CDCPayload
+from buz.kafka.infrastructure.cdc.cdc_message import CDCPayload
 from buz.kafka.infrastructure.deserializers.bytes_to_message_deserializer import BytesToMessageDeserializer
 from buz.kafka.infrastructure.deserializers.implementations.cdc.not_valid_cdc_message_exception import (
     NotValidCDCMessageException,
@@ -25,11 +25,11 @@ class CDCRecordBytesToEventDeserializer(BytesToMessageDeserializer[Event], Gener
     def deserialize(self, data: bytes) -> T:
         decoded_string = data.decode(self.__STRING_ENCODING)
         try:
-            cdc_message = self.__get_outbox_record_as_dict(decoded_string)
+            cdc_payload = self.__get_outbox_record_as_dict(decoded_string)
             return self.__event_class.restore(
-                id=cdc_message.payload.event_id,
-                created_at=self.__get_created_at_in_event_format(cdc_message.payload.created_at),
-                **orjson.loads(cdc_message.payload.payload),
+                id=cdc_payload.event_id,
+                created_at=self.__get_created_at_in_event_format(cdc_payload.created_at),
+                **orjson.loads(cdc_payload.payload),
             )
         except Exception as exception:
             raise NotValidCDCMessageException(decoded_string, exception) from exception
@@ -38,12 +38,12 @@ class CDCRecordBytesToEventDeserializer(BytesToMessageDeserializer[Event], Gener
         created_at_datetime = datetime.strptime(cdc_payload_created_at, CDCPayload.DATE_TIME_FORMAT)
         return created_at_datetime.strftime(Event.DATE_TIME_FORMAT)
 
-    def __get_outbox_record_as_dict(self, decoded_string: str) -> CDCMessage:
+    def __get_outbox_record_as_dict(self, decoded_string: str) -> CDCPayload:
         decoded_record: dict = orjson.loads(decoded_string)
 
         payload = decoded_record.get("payload")
+
         if not isinstance(payload, dict):
             raise ValueError("The provided payload value is not valid")
 
-        cdc_message = CDCMessage(payload=from_dict(CDCPayload, payload))
-        return cdc_message
+        return from_dict(CDCPayload, payload)

{buz-2.14.3 → buz-2.15.1}/src/buz/kafka/infrastructure/serializers/implementations/cdc_record_bytes_to_event_serializer.py

@@ -5,6 +5,7 @@ from datetime import datetime
 
 from buz.event import Event
 from buz.kafka.infrastructure.cdc.cdc_message import CDCMessage, CDCPayload
+from buz.kafka.infrastructure.cdc.cdc_schema import generate_cdc_schema
 from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
 from buz.kafka.infrastructure.serializers.implementations.json_byte_serializer import JSONByteSerializer
 
@@ -20,7 +21,8 @@ class CDCRecordBytesToEventSerializer(ByteSerializer):
                 created_at=self.__adapt_created_to_cdc_format(data.created_at),
                 event_fqn=data.fqn(),
                 payload=self.__serialize_payload(data),
-            )
+            ),
+            schema=generate_cdc_schema(data),
         )
         return self.__json_serializer.serialize(asdict(cdc_message))