buz 2.15.12__tar.gz → 2.17.0__tar.gz

{buz-2.15.12 → buz-2.17.0}/PKG-INFO

@@ -1,22 +1,20 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.15.12
+Version: 2.17.0
 Summary: Buz is a set of light, simple and extensible implementations of event, command and query buses.
 License: MIT
 Author: Luis Pintado Lozano
 Author-email: luis.pintado.lozano@gmail.com
 Maintainer: Fever - Platform Squad
 Maintainer-email: platform@feverup.com
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Provides-Extra: aiokafka

{buz-2.15.12 → buz-2.17.0}/pyproject.toml

@@ -1,34 +1,37 @@
 [tool.poetry]
 name = "buz"
-version = "2.15.12"
+version = "2.17.0"
 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>"]
+authors = [
+  "Luis Pintado Lozano <luis.pintado.lozano@gmail.com>",
+  "Gerardo Parra <gprauxiliar@gmail.com>",
+]
 maintainers = ["Fever - Platform Squad <platform@feverup.com>"]
 license = "MIT License"
-classifiers=[
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Operating System :: OS Independent",
-    "Topic :: Software Development :: Libraries",
-    "Typing :: Typed",
-    ]
+classifiers = [
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries",
+  "Typing :: Typed",
+]
 include = ["py.typed"]
 
 [tool.poetry.dependencies]
-python = ">= 3.9"
+python = ">= 3.10"
 pypendency = { version = "~0", optional = true }
 kombu = { version = ">= 4.6.11", optional = true }
-orjson = {version = "^3.10.1"}
-pympler = {version = "== 1.0.1"}
-kafka-python-ng= "2.2.3"
+orjson = { version = "^3.10.1" }
+pympler = { version = "== 1.0.1" }
+kafka-python-ng = "2.2.3"
 uuid-utils = "^0.9.0"
 dacite = "^1.8.1"
-aiokafka = {version = "==0.12.0", extras = ["lz4"], optional = true}
-asgiref = {version = "^3.8.1", optional = true}
+aiokafka = { version = "==0.12.0", extras = ["lz4"], optional = true }
+asgiref = { version = "^3.8.1", optional = true }
 cachetools = "^5.5.0"
 aiohttp = "^3.12.15"
 
@@ -51,7 +54,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.black]
 line-length = 120
-target_version = ['py38', 'py39']
+target_version = ['py310', 'py311', 'py312']
 include = '\.pyi?$'
 exclude = '''
     /(

buz-2.17.0/src/buz/event/async_subscriber.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from buz.event.event import Event
+from buz.event.meta_subscriber import MetaSubscriber
+
+TEvent = TypeVar("TEvent", bound=Event)
+
+
+class AsyncSubscriber(Generic[TEvent], MetaSubscriber[TEvent], ABC):
+    @abstractmethod
+    async def consume(self, event: TEvent) -> None:
+        pass

buz-2.17.0/src/buz/event/base_async_subscriber.py

@@ -0,0 +1,12 @@
+from abc import ABC
+from typing import Generic, TypeVar
+
+from buz.event.event import Event
+from buz.event.async_subscriber import AsyncSubscriber
+from buz.event.meta_base_subscriber import MetaBaseSubscriber
+
+TEvent = TypeVar("TEvent", bound=Event)
+
+
+class BaseAsyncSubscriber(Generic[TEvent], AsyncSubscriber[TEvent], MetaBaseSubscriber[TEvent], ABC):
+    pass

buz-2.17.0/src/buz/event/base_subscriber.py

@@ -0,0 +1,12 @@
+from abc import ABC
+from typing import Generic, TypeVar
+
+from buz.event.event import Event
+from buz.event.subscriber import Subscriber
+from buz.event.meta_base_subscriber import MetaBaseSubscriber
+
+TEvent = TypeVar("TEvent", bound=Event)
+
+
+class BaseSubscriber(Generic[TEvent], Subscriber[TEvent], MetaBaseSubscriber[TEvent], ABC):
+    pass

{buz-2.15.12 → buz-2.17.0}/src/buz/event/meta_base_subscriber.py

@@ -1,23 +1,26 @@
 from abc import ABC
-from typing import Type, get_type_hints
+from typing import Generic, Type, TypeVar, cast, get_type_hints
 
-from buz.event import Event
+from buz.event.event import Event
 from buz.event.meta_subscriber import MetaSubscriber
 
+TEvent = TypeVar("TEvent", bound=Event)
 
-class MetaBaseSubscriber(MetaSubscriber, ABC):
+
+class MetaBaseSubscriber(Generic[TEvent], MetaSubscriber[TEvent], ABC):
     @classmethod
     def fqn(cls) -> str:
         return f"subscriber.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Event]:
+    def handles(cls) -> Type[TEvent]:
         consume_types = get_type_hints(cls.consume)
 
-        if "event" not in consume_types:
+        t_event = consume_types.get("event")
+        if t_event is None:
             raise TypeError("event parameter not found in consume method")
 
-        if not issubclass(consume_types["event"], Event):
+        if not issubclass(t_event, Event):
             raise TypeError("event parameter is not an buz.event.Event subclass")
 
-        return consume_types["event"]
+        return cast(Type[TEvent], t_event)

buz-2.17.0/src/buz/event/meta_subscriber.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from typing import Awaitable, Generic, Type, TypeVar, Union
+
+from buz import Handler
+from buz.event.event import Event
+
+TEvent = TypeVar("TEvent", bound=Event)
+
+
+class MetaSubscriber(Generic[TEvent], Handler[TEvent], ABC):
+    @abstractmethod
+    def consume(self, event: TEvent) -> Union[None, Awaitable[None]]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def handles(cls) -> Type[TEvent]:
+        pass

buz-2.17.0/src/buz/event/subscriber.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from buz.event.event import Event
+from buz.event.meta_subscriber import MetaSubscriber
+
+TEvent = TypeVar("TEvent", bound=Event)
+
+
+class Subscriber(Generic[TEvent], MetaSubscriber[TEvent], ABC):
+    @abstractmethod
+    def consume(self, event: TEvent) -> None:
+        pass

{buz-2.15.12 → buz-2.17.0}/src/buz/event/transactional_outbox/event_to_outbox_record_translator.py

@@ -10,9 +10,11 @@ class EventToOutboxRecordTranslator:
         payload = dataclasses.asdict(event)
         payload.pop("id")
         payload.pop("created_at")
+        payload.pop("metadata")
         return OutboxRecord(
             event_id=UUID(event.id),
             event_fqn=event.fqn(),
             created_at=event.parsed_created_at(),
             event_payload=payload,
+            event_metadata=dict(event.metadata),
         )

{buz-2.15.12 → buz-2.17.0}/src/buz/event/transactional_outbox/outbox_record.py

@@ -12,6 +12,7 @@ class OutboxRecord:  # type: ignore[misc]
     event_fqn: str
     event_payload: dict[str, Any]  # type: ignore[misc]
     created_at: datetime
+    event_metadata: Optional[dict[str, Any]] = None
     delivered_at: Optional[datetime] = None
     delivery_errors: int = 0
     delivery_paused_at: Optional[datetime] = None

{buz-2.15.12 → buz-2.17.0}/src/buz/event/transactional_outbox/outbox_record_to_event_translator.py

@@ -16,6 +16,7 @@ class OutboxRecordToEventTranslator:
             event_klass.restore(
                 id=str(outbox_record.event_id),
                 created_at=outbox_record.parsed_created_at(),
+                metadata=outbox_record.event_metadata,
                 **outbox_record.event_payload,
             ),
         )

buz-2.17.0/src/buz/event/transactional_outbox/transactional_outbox_event_bus.py

@@ -0,0 +1,56 @@
+from typing import Optional, Iterable
+
+from buz.event import Event, EventBus
+from buz.event.middleware.publish_middleware import PublishMiddleware
+from buz.event.middleware.publish_middleware_chain_resolver import PublishMiddlewareChainResolver
+from buz.event.transactional_outbox import OutboxRecord
+from buz.event.transactional_outbox.event_to_outbox_record_translator import EventToOutboxRecordTranslator
+from buz.event.transactional_outbox.outbox_record_validation.outbox_record_validator import OutboxRecordValidator
+from buz.event.transactional_outbox.outbox_repository import OutboxRepository
+
+
+class TransactionalOutboxEventBus(EventBus):
+    def __init__(
+        self,
+        outbox_repository: OutboxRepository,
+        event_to_outbox_record_translator: EventToOutboxRecordTranslator,
+        outbox_record_validator: Optional[OutboxRecordValidator] = None,
+        publish_middlewares: Optional[list[PublishMiddleware]] = None,
+    ) -> None:
+        self.__outbox_repository = outbox_repository
+        self.__event_to_outbox_record_translator = event_to_outbox_record_translator
+        self.__outbox_record_validator = outbox_record_validator
+        self.__publish_middleware = publish_middlewares
+        self.__publish_middleware_chain_resolver = PublishMiddlewareChainResolver(self.__publish_middleware or [])
+
+    def publish(self, event: Event) -> None:
+        self.__publish_middleware_chain_resolver.resolve(event, self.__perform_publish)
+
+    def __perform_publish(self, event: Event) -> None:
+        outbox_record = self.__process_event(event)
+        self.__outbox_repository.save(outbox_record)
+
+    def bulk_publish(self, events: Iterable[Event]) -> None:
+        publish_middleware_chain_resolver = PublishMiddlewareChainResolver(self.__publish_middleware or [])
+        outbox_records: list[OutboxRecord] = []
+
+        for event in events:
+            publish_middleware_chain_resolver.resolve(event, lambda resolved_event: None)
+            outbox_records.append(self.__process_event(event))
+
+        if len(outbox_records) == 0:
+            return None
+
+        self.__outbox_repository.bulk_create(outbox_records)
+
+    def __process_event(self, event: Event) -> OutboxRecord:
+        outbox_record = self.__translate_event(event)
+        self.__validate_outbox_record(outbox_record)
+        return outbox_record
+
+    def __translate_event(self, event: Event) -> OutboxRecord:
+        return self.__event_to_outbox_record_translator.translate(event)
+
+    def __validate_outbox_record(self, outbox_record: OutboxRecord) -> None:
+        if self.__outbox_record_validator is not None:
+            self.__outbox_record_validator.validate(record=outbox_record)

{buz-2.15.12 → buz-2.17.0}/src/buz/kafka/infrastructure/cdc/cdc_payload.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Optional
 
 
 @dataclass(frozen=True)
@@ -9,6 +10,7 @@ class CDCPayload:
     event_id: str  # uuid
     created_at: str
     event_fqn: str
+    metadata: Optional[str] = None  # json encoded
 
     def validate(self) -> None:
         if not isinstance(self.payload, str):
@@ -19,6 +21,8 @@ class CDCPayload:
             raise ValueError("The created_at value is not a value")
         if not isinstance(self.event_fqn, str):
             raise ValueError("The event_fqn value is not a valid value")
+        if self.metadata is not None and not isinstance(self.metadata, str):
+            raise ValueError("The metadata value is not a valid value")
 
     def __post_init__(self) -> None:
         self.validate()

{buz-2.15.12 → buz-2.17.0}/src/buz/kafka/infrastructure/cdc/cdc_schema.py

@@ -22,6 +22,13 @@ def generate_cdc_schema(message: Message) -> dict:
                 "optional": False,
                 "field": "event_fqn",
             },
+            {
+                "type": "string",
+                "optional": True,
+                "name": "io.debezium.data.Json",
+                "version": 1,
+                "field": "metadata",
+            },
             {
                 "type": "string",
                 "optional": False,

{buz-2.15.12 → buz-2.17.0}/src/buz/kafka/infrastructure/deserializers/implementations/cdc/cdc_record_bytes_to_event_deserializer.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import TypeVar, Type, Generic
+from typing import Optional, TypeVar, Type, Generic
 
 import orjson
 from dacite import from_dict
@@ -29,6 +29,7 @@ class CDCRecordBytesToEventDeserializer(BytesToMessageDeserializer[Event], Gener
             return self.__event_class.restore(
                 id=cdc_payload.event_id,
                 created_at=self.__get_created_at_in_event_format(cdc_payload.created_at),
+                metadata=self.__deserialize_metadata(cdc_payload.metadata),
                 **orjson.loads(cdc_payload.payload),
             )
         except Exception as exception:
@@ -47,3 +48,8 @@ class CDCRecordBytesToEventDeserializer(BytesToMessageDeserializer[Event], Gener
             raise ValueError("The provided payload value is not valid")
 
         return from_dict(CDCPayload, payload)
+
+    def __deserialize_metadata(self, metadata: Optional[str]) -> dict:
+        if metadata is None:
+            return {}
+        return orjson.loads(metadata)

{buz-2.15.12 → buz-2.17.0}/src/buz/kafka/infrastructure/serializers/implementations/cdc_record_bytes_to_event_serializer.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import asdict
 from datetime import datetime
+from typing import Optional
 
 from buz.event import Event
 from buz.kafka.infrastructure.cdc.cdc_message import CDCMessage, CDCPayload
@@ -21,6 +22,7 @@ class CDCRecordBytesToEventSerializer(ByteSerializer):
                 created_at=self.__adapt_created_to_cdc_format(data.created_at),
                 event_fqn=data.fqn(),
                 payload=self.__serialize_payload(data),
+                metadata=self.__serialize_metadata(data),
             ),
             schema=generate_cdc_schema(data),
         )
@@ -31,8 +33,11 @@ class CDCRecordBytesToEventSerializer(ByteSerializer):
         return created_at_datetime.strftime(CDCPayload.DATE_TIME_FORMAT)
 
     def __serialize_payload(self, event: Event) -> str:
-        # Remove id and created at, because Transactional outbox is not adding them
         payload = asdict(event)
         del payload["id"]
         del payload["created_at"]
+        del payload["metadata"]
         return self.__json_serializer.serialize_as_json(payload)
+
+    def __serialize_metadata(self, event: Event) -> Optional[str]:
+        return self.__json_serializer.serialize_as_json(event.metadata)  # type: ignore[arg-type]

{buz-2.15.12 → buz-2.17.0}/src/buz/kafka/infrastructure/serializers/implementations/json_byte_serializer.py

@@ -15,7 +15,9 @@ ALLOWED_SERIALIZABLE_DICTIONARY_KEYS = str
 
 JSON_SERIALIZABLE_VALUE = Union[PRIMITIVES, list[PRIMITIVES], dict[ALLOWED_SERIALIZABLE_DICTIONARY_KEYS, PRIMITIVES]]
 
-JSON_SERIALIZABLE = dict[ALLOWED_SERIALIZABLE_DICTIONARY_KEYS, Union[JSON_SERIALIZABLE_VALUE, "JSON_SERIALIZABLE"]]
+JSON_SERIALIZABLE = Union[
+    dict[ALLOWED_SERIALIZABLE_DICTIONARY_KEYS, Union[JSON_SERIALIZABLE_VALUE, "JSON_SERIALIZABLE"]]
+]
 
 
 class JSONByteSerializer(ByteSerializer[JSON_SERIALIZABLE]):

{buz-2.15.12 → buz-2.17.0}/src/buz/message.py

@@ -8,6 +8,8 @@ from typing_extensions import Self
 
 from uuid_utils.compat import uuid7
 
+from buz.metadata import Metadata
+
 
 @dataclass(frozen=True)
 class Message(ABC):
@@ -17,6 +19,7 @@ class Message(ABC):
     created_at: str = field(
         init=False, default_factory=lambda: datetime.strftime(datetime.now(), Message.DATE_TIME_FORMAT)
     )
+    metadata: Metadata = field(init=False, default_factory=lambda: Metadata())
 
     @classmethod
     def fqn(cls) -> str:
@@ -26,11 +29,14 @@ class Message(ABC):
     def restore(cls, **kwargs: Any) -> Self:
         message_id = kwargs.pop("id")
         created_at = kwargs.pop("created_at")
+        metadata_kwargs = kwargs.pop("metadata", None) or {}
+        metadata = Metadata(**metadata_kwargs)
 
         instance = cls.__from_dict(kwargs)  # type: ignore
 
         object.__setattr__(instance, "id", message_id)
         object.__setattr__(instance, "created_at", created_at)
+        object.__setattr__(instance, "metadata", metadata)
         return instance
 
     @classmethod
@@ -61,3 +67,6 @@ class Message(ABC):
 
     def parsed_created_at(self) -> datetime:
         return datetime.strptime(self.created_at, self.DATE_TIME_FORMAT)
+
+    def add_metadata(self, metadata: Metadata) -> None:
+        self.metadata.update(metadata)

buz-2.17.0/src/buz/metadata.py

@@ -0,0 +1,8 @@
+from typing import Any, TypedDict
+
+
+class Metadata(TypedDict):
+    def __init__(self, **kwargs: dict[str, Any]) -> None:  # type: ignore[misc]
+        super().__init__()
+        for key, value in kwargs.items():
+            setattr(self, key, value)

{buz-2.15.12 → buz-2.17.0}/src/buz/query/asynchronous/query_handler.py

@@ -1,20 +1,19 @@
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.query import Query, QueryResponse
 
-
 TQuery = TypeVar("TQuery", bound=Query)
 TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
 
 
-class QueryHandler(Generic[TQuery, TQueryResponse], Handler[TQuery]):
+class QueryHandler(Generic[TQuery, TQueryResponse], Handler[TQuery], ABC):
     @classmethod
     @abstractmethod
     def handles(cls) -> Type[TQuery]:
         pass
 
     @abstractmethod
-    async def handle(self, query: Query) -> TQueryResponse:
+    async def handle(self, query: TQuery) -> TQueryResponse:
         pass

buz-2.15.12/src/buz/event/async_subscriber.py

@@ -1,10 +0,0 @@
-from abc import ABC, abstractmethod
-
-from buz.event import Event
-from buz.event.meta_subscriber import MetaSubscriber
-
-
-class AsyncSubscriber(MetaSubscriber, ABC):
-    @abstractmethod
-    async def consume(self, event: Event) -> None:
-        pass

buz-2.15.12/src/buz/event/base_async_subscriber.py

@@ -1,8 +0,0 @@
-from abc import ABC
-
-from buz.event.async_subscriber import AsyncSubscriber
-from buz.event.meta_base_subscriber import MetaBaseSubscriber
-
-
-class BaseAsyncSubscriber(AsyncSubscriber, MetaBaseSubscriber, ABC):
-    pass

buz-2.15.12/src/buz/event/base_subscriber.py

@@ -1,7 +0,0 @@
-from abc import ABC
-from buz.event import Subscriber
-from buz.event.meta_base_subscriber import MetaBaseSubscriber
-
-
-class BaseSubscriber(Subscriber, MetaBaseSubscriber, ABC):
-    pass

buz-2.15.12/src/buz/event/meta_subscriber.py

@@ -1,16 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Awaitable, Type, Union
-
-from buz import Handler
-from buz.event import Event
-
-
-class MetaSubscriber(Handler, ABC):
-    @abstractmethod
-    def consume(self, event: Event) -> Union[None, Awaitable[None]]:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def handles(cls) -> Type[Event]:
-        pass

buz-2.15.12/src/buz/event/subscriber.py

@@ -1,10 +0,0 @@
-from abc import ABC, abstractmethod
-
-from buz.event import Event
-from buz.event.meta_subscriber import MetaSubscriber
-
-
-class Subscriber(MetaSubscriber, ABC):
-    @abstractmethod
-    def consume(self, event: Event) -> None:
-        pass

buz-2.15.12/src/buz/event/transactional_outbox/transactional_outbox_event_bus.py

@@ -1,34 +0,0 @@
-from typing import Optional, Iterable
-
-from buz.event import Event, EventBus
-from buz.event.transactional_outbox import OutboxRecord
-from buz.event.transactional_outbox.event_to_outbox_record_translator import EventToOutboxRecordTranslator
-from buz.event.transactional_outbox.outbox_record_validation.outbox_record_validator import OutboxRecordValidator
-from buz.event.transactional_outbox.outbox_repository import OutboxRepository
-
-
-class TransactionalOutboxEventBus(EventBus):
-    def __init__(
-        self,
-        outbox_repository: OutboxRepository,
-        event_to_outbox_record_translator: EventToOutboxRecordTranslator,
-        outbox_record_validator: Optional[OutboxRecordValidator] = None,
-    ):
-        self.__outbox_repository = outbox_repository
-        self.__event_to_outbox_record_translator = event_to_outbox_record_translator
-        self.__outbox_record_validator = outbox_record_validator
-
-    def publish(self, event: Event) -> None:
-        outbox_record = self.__translate_and_validate(event)
-        self.__outbox_repository.save(outbox_record)
-
-    def bulk_publish(self, events: Iterable[Event]) -> None:
-        outbox_records = map(self.__translate_and_validate, events)
-        self.__outbox_repository.bulk_create(outbox_records)
-
-    # Raises OutboxRecordValidationException: If any validation inside outbox_record_validator fails
-    def __translate_and_validate(self, event: Event) -> OutboxRecord:
-        outbox_record = self.__event_to_outbox_record_translator.translate(event)
-        if self.__outbox_record_validator is not None:
-            self.__outbox_record_validator.validate(record=outbox_record)
-        return outbox_record