buz 2.15.10rc6__tar.gz → 2.15.11__tar.gz

{buz-2.15.10rc6 → buz-2.15.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.15.10rc6
+Version: 2.15.11
 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.15.10rc6 → buz-2.15.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "buz"
-version = "2.15.10-rc6"
+version = "2.15.11"
 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.15.10rc6 → buz-2.15.11}/src/buz/event/infrastructure/buz_kafka/kafka_event_async_subscriber_executor.py

@@ -8,6 +8,7 @@ from buz.event.infrastructure.buz_kafka.consume_strategy.kafka_on_fail_strategy
 from buz.event.infrastructure.buz_kafka.exceptions.max_consumer_retry_exception import MaxConsumerRetryException
 from buz.event.infrastructure.buz_kafka.exceptions.retry_exception import ConsumerRetryException
 from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware.async_consume_middleware import AsyncConsumeMiddleware
 from buz.event.middleware.async_consume_middleware_chain_resolver import AsyncConsumeMiddlewareChainResolver
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
@@ -15,6 +16,7 @@ from buz.event.strategies.retry.reject_callback import RejectCallback
 from buz.kafka.domain.exceptions.not_valid_kafka_message_exception import NotValidKafkaMessageException
 from buz.kafka.domain.models.kafka_consumer_record import KafkaConsumerRecord
 from buz.kafka.domain.models.kafka_poll_record import KafkaPollRecord
+from buz.event.infrastructure.buz_kafka.models.kafka_delivery_context import KafkaDeliveryContext
 from buz.kafka.infrastructure.deserializers.byte_deserializer import ByteDeserializer
 from buz.kafka.infrastructure.serializers.kafka_header_serializer import KafkaHeaderSerializer
 
@@ -67,18 +69,33 @@ class KafkaEventAsyncSubscriberExecutor(KafkaEventSubscriberExecutor):
                     value=deserialized_value,
                     headers=self.__header_deserializer.deserialize(kafka_poll_record.headers),
                 ),
+                ExecutionContext(
+                    delivery_context=KafkaDeliveryContext(
+                        topic=kafka_poll_record.topic,
+                        consumer_group=self.__subscriber.fqn(),
+                        partition=kafka_poll_record.partition,
+                        timestamp=kafka_poll_record.timestamp,
+                    )
+                ),
             )
         except NotValidKafkaMessageException:
             self.__logger.error(
                 f'The message "{str(kafka_poll_record.value)}" is not valid, it will be consumed but not processed'
             )
 
-    async def __consumption_callback(self, subscriber: AsyncSubscriber, message: KafkaConsumerRecord[Event]) -> None:
+    async def __consumption_callback(
+        self, subscriber: AsyncSubscriber, message: KafkaConsumerRecord[Event], execution_context: ExecutionContext
+    ) -> None:
         await self.__consume_middleware_chain_resolver.resolve(
-            event=message.value, subscriber=subscriber, consume=self.__perform_consume
+            event=message.value,
+            subscriber=subscriber,
+            execution_context=execution_context,
+            consume=self.__perform_consume,
         )
 
-    async def __perform_consume(self, event: Event, subscriber: AsyncSubscriber) -> None:
+    async def __perform_consume(
+        self, event: Event, subscriber: AsyncSubscriber, execution_context: ExecutionContext
+    ) -> None:
         number_of_executions = 0
         should_retry = True
 

{buz-2.15.10rc6 → buz-2.15.11}/src/buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py

@@ -7,6 +7,8 @@ from buz.event.infrastructure.buz_kafka.consume_strategy.kafka_on_fail_strategy
 from buz.event.infrastructure.buz_kafka.exceptions.max_consumer_retry_exception import MaxConsumerRetryException
 from buz.event.infrastructure.buz_kafka.exceptions.retry_exception import ConsumerRetryException
 from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
+from buz.event.infrastructure.buz_kafka.models.kafka_delivery_context import KafkaDeliveryContext
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware.consume_middleware import ConsumeMiddleware
 from buz.event.middleware.consume_middleware_chain_resolver import ConsumeMiddlewareChainResolver
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
@@ -64,11 +66,19 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
             await get_running_loop().run_in_executor(
                 None,
                 lambda: self.__execution_callback(
-                    self.__subscriber,
-                    KafkaConsumerRecord(
+                    subscriber=self.__subscriber,
+                    message=KafkaConsumerRecord(
                         value=deserialized_value,
                         headers=self.__header_deserializer.deserialize(kafka_poll_record.headers),
                     ),
+                    execution_context=ExecutionContext(
+                        delivery_context=KafkaDeliveryContext(
+                            topic=kafka_poll_record.topic,
+                            consumer_group=self.__subscriber.fqn(),
+                            partition=kafka_poll_record.partition,
+                            timestamp=kafka_poll_record.timestamp,
+                        )
+                    ),
                 ),
             )
 
@@ -77,12 +87,17 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
                 f'The message "{str(kafka_poll_record.value)}" is not valid, it will be consumed but not processed'
             )
 
-    def __execution_callback(self, subscriber: Subscriber, message: KafkaConsumerRecord[Event]) -> None:
+    def __execution_callback(
+        self, subscriber: Subscriber, message: KafkaConsumerRecord[Event], execution_context: ExecutionContext
+    ) -> None:
         self.__consume_middleware_chain_resolver.resolve(
-            event=message.value, subscriber=subscriber, consume=self.__perform_consume
+            event=message.value,
+            subscriber=subscriber,
+            execution_context=execution_context,
+            consume=self.__perform_consume,
         )
 
-    def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
+    def __perform_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
         number_of_executions = 0
         should_retry = True
 

buz-2.15.11/src/buz/event/infrastructure/buz_kafka/models/kafka_delivery_context.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class KafkaDeliveryContext(DeliveryContext):
+    topic: str
+    consumer_group: str
+    partition: int
+    timestamp: int

{buz-2.15.10rc6 → buz-2.15.11}/src/buz/event/infrastructure/kombu/kombu_consumer.py

@@ -2,6 +2,8 @@ import asyncio
 from logging import Logger
 from typing import Optional, Callable, cast
 
+from buz.event.infrastructure.kombu.models.kombu_delivery_context import KombuDeliveryContext
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from kombu import Connection, Queue, Consumer as MessageConsumer, Message
 from kombu.mixins import ConsumerMixin
 from kombu.transport.pyamqp import Channel
@@ -110,12 +112,18 @@ class KombuConsumer(ConsumerMixin, Consumer):
                 # 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)
+                execution_context = ExecutionContext(delivery_context=KombuDeliveryContext())
+                self.__consume_middleware_chain_resolver.resolve(
+                    event=event,
+                    subscriber=subscriber,
+                    execution_context=execution_context,
+                    consume=self.__perform_consume,
+                )
             message.ack()
         except Exception as exc:
             self.__on_consume_exception(message, event, meta_subscribers, exc)
 
-    def __perform_consume(self, event: Event, subscriber: MetaSubscriber) -> None:
+    def __perform_consume(self, event: Event, subscriber: MetaSubscriber, execution_context: ExecutionContext) -> None:
         if isinstance(subscriber, AsyncSubscriber):
             self.__get_or_create_event_loop().run_until_complete(subscriber.consume(event))
             return

buz-2.15.11/src/buz/event/infrastructure/kombu/models/kombu_delivery_context.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class KombuDeliveryContext(DeliveryContext):
+    pass

buz-2.15.11/src/buz/event/infrastructure/models/delivery_context.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DeliveryContext:
+    pass

buz-2.15.11/src/buz/event/infrastructure/models/execution_context.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class ExecutionContext:
+    delivery_context: DeliveryContext

buz-2.15.11/src/buz/event/middleware/async_consume_middleware.py

@@ -0,0 +1,21 @@
+from abc import abstractmethod
+from typing import Awaitable, Callable
+
+from buz.event import Event
+from buz.event.async_subscriber import AsyncSubscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
+from buz.middleware import Middleware
+
+AsyncConsumeCallable = Callable[[Event, AsyncSubscriber, ExecutionContext], Awaitable[None]]
+
+
+class AsyncConsumeMiddleware(Middleware):
+    @abstractmethod
+    async def on_consume(
+        self,
+        event: Event,
+        subscriber: AsyncSubscriber,
+        consume: AsyncConsumeCallable,
+        execution_context: ExecutionContext,
+    ) -> None:
+        pass

{buz-2.15.10rc6 → buz-2.15.11}/src/buz/event/middleware/async_consume_middleware_chain_resolver.py

@@ -2,6 +2,7 @@ from typing import Sequence
 from buz.event import Event
 from buz.event.async_subscriber import AsyncSubscriber
 
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware.async_consume_middleware import AsyncConsumeCallable, AsyncConsumeMiddleware
 from buz.middleware import MiddlewareChainBuilder
 
@@ -14,16 +15,26 @@ class AsyncConsumeMiddlewareChainResolver:
         self.__middlewares = middlewares
         self.__middleware_chain_builder: MiddlewareChainBuilder[
             AsyncConsumeCallable, AsyncConsumeMiddleware
-        ] = MiddlewareChainBuilder(middlewares)
+        ] = MiddlewareChainBuilder(self.__middlewares)
 
-    async def resolve(self, event: Event, subscriber: AsyncSubscriber, consume: AsyncConsumeCallable) -> None:
+    async def resolve(
+        self,
+        event: Event,
+        subscriber: AsyncSubscriber,
+        consume: AsyncConsumeCallable,
+        execution_context: ExecutionContext,
+    ) -> None:
         chain_callable: AsyncConsumeCallable = self.__middleware_chain_builder.get_chain_callable(
             consume, self.__get_middleware_callable
         )
 
-        await chain_callable(event, subscriber)
+        await chain_callable(event, subscriber, execution_context)
 
     def __get_middleware_callable(
-        self, middleware: AsyncConsumeMiddleware, consume_callable: AsyncConsumeCallable
+        self,
+        middleware: AsyncConsumeMiddleware,
+        consume_callable: AsyncConsumeCallable,
     ) -> AsyncConsumeCallable:
-        return lambda event, subscriber: middleware.on_consume(event, subscriber, consume_callable)
+        return lambda event, subscriber, execution_context: middleware.on_consume(
+            event, subscriber, consume_callable, execution_context
+        )

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

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

buz-2.15.11/src/buz/event/middleware/base_consume_middleware.py

@@ -0,0 +1,22 @@
+from abc import abstractmethod
+
+from buz.event import Event, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
+from buz.event.middleware import ConsumeMiddleware, ConsumeCallable
+
+
+class BaseConsumeMiddleware(ConsumeMiddleware):
+    def on_consume(
+        self, event: Event, subscriber: Subscriber, consume: ConsumeCallable, execution_context: ExecutionContext
+    ) -> None:
+        self._before_on_consume(event, subscriber, execution_context)
+        consume(event, subscriber, execution_context)
+        self._after_on_consume(event, subscriber, execution_context)
+
+    @abstractmethod
+    def _before_on_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
+        pass
+
+    @abstractmethod
+    def _after_on_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
+        pass

buz-2.15.11/src/buz/event/middleware/consume_middleware.py

@@ -0,0 +1,16 @@
+from abc import abstractmethod
+from typing import Callable
+
+from buz.event import Event, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
+from buz.middleware import Middleware
+
+ConsumeCallable = Callable[[Event, Subscriber, ExecutionContext], None]
+
+
+class ConsumeMiddleware(Middleware):
+    @abstractmethod
+    def on_consume(
+        self, event: Event, subscriber: Subscriber, consume: ConsumeCallable, execution_context: ExecutionContext
+    ) -> None:
+        pass

{buz-2.15.10rc6 → buz-2.15.11}/src/buz/event/middleware/consume_middleware_chain_resolver.py

@@ -1,5 +1,6 @@
 from typing import Sequence
 from buz.event import Event, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware import ConsumeMiddleware, ConsumeCallable
 from buz.middleware import MiddlewareChainBuilder
 
@@ -9,15 +10,23 @@ class ConsumeMiddlewareChainResolver:
         self.__middlewares = middlewares
         self.__middleware_chain_builder: MiddlewareChainBuilder[
             ConsumeCallable, ConsumeMiddleware
-        ] = MiddlewareChainBuilder(middlewares)
+        ] = MiddlewareChainBuilder(self.__middlewares)
 
-    def resolve(self, event: Event, subscriber: Subscriber, consume: ConsumeCallable) -> None:
+    def resolve(
+        self,
+        event: Event,
+        subscriber: Subscriber,
+        consume: ConsumeCallable,
+        execution_context: ExecutionContext,
+    ) -> None:
         chain_callable: ConsumeCallable = self.__middleware_chain_builder.get_chain_callable(
             consume, self.__get_middleware_callable
         )
-        chain_callable(event, subscriber)
+        chain_callable(event, subscriber, execution_context)
 
     def __get_middleware_callable(
         self, middleware: ConsumeMiddleware, consume_callable: ConsumeCallable
     ) -> ConsumeCallable:
-        return lambda event, subscriber: middleware.on_consume(event, subscriber, consume_callable)
+        return lambda event, subscriber, execution_context: middleware.on_consume(
+            event, subscriber, consume_callable, execution_context
+        )

buz-2.15.11/src/buz/event/sync/models/sync_delivery_context.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+from buz.event.infrastructure.models.delivery_context import DeliveryContext
+
+
+@dataclass(frozen=True)
+class SyncDeliveryContext(DeliveryContext):
+    pass

{buz-2.15.10rc6 → buz-2.15.11}/src/buz/event/sync/sync_event_bus.py

@@ -1,12 +1,14 @@
 from typing import Optional, Iterable
 
 from buz.event import Event, EventBus, Subscriber
+from buz.event.infrastructure.models.execution_context import ExecutionContext
 from buz.event.middleware import (
     PublishMiddleware,
     ConsumeMiddleware,
     PublishMiddlewareChainResolver,
     ConsumeMiddlewareChainResolver,
 )
+from buz.event.sync.models.sync_delivery_context import SyncDeliveryContext
 from buz.locator import Locator
 
 
@@ -26,10 +28,16 @@ class SyncEventBus(EventBus):
 
     def __perform_publish(self, event: Event) -> None:
         subscribers = self.__locator.get(event)
+        execution_context = ExecutionContext(delivery_context=SyncDeliveryContext())
         for subscriber in subscribers:
-            self.__consume_middleware_chain_resolver.resolve(event, subscriber, self.__perform_consume)
+            self.__consume_middleware_chain_resolver.resolve(
+                event=event,
+                subscriber=subscriber,
+                execution_context=execution_context,
+                consume=self.__perform_consume,
+            )
 
-    def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
+    def __perform_consume(self, event: Event, subscriber: Subscriber, execution_context: ExecutionContext) -> None:
         subscriber.consume(event)
 
     def bulk_publish(self, events: Iterable[Event]) -> None:

{buz-2.15.10rc6 → buz-2.15.11}/src/buz/kafka/domain/models/kafka_poll_record.py

@@ -9,6 +9,7 @@ class KafkaPollRecord:
     key: Optional[Union[str, bytes]]
     headers: list[tuple[str, bytes]]
     value: Optional[bytes]
+    timestamp: int
     partition: int
     topic: str
     offset: int

buz-2.15.10rc6/src/buz/event/middleware/async_consume_middleware.py

@@ -1,14 +0,0 @@
-from abc import abstractmethod
-from typing import Awaitable, Callable
-
-from buz.event import Event
-from buz.event.async_subscriber import AsyncSubscriber
-from buz.middleware import Middleware
-
-AsyncConsumeCallable = Callable[[Event, AsyncSubscriber], Awaitable[None]]
-
-
-class AsyncConsumeMiddleware(Middleware):
-    @abstractmethod
-    async def on_consume(self, event: Event, subscriber: AsyncSubscriber, consume: AsyncConsumeCallable) -> None:
-        pass

buz-2.15.10rc6/src/buz/event/middleware/base_async_consume_middleware.py

@@ -1,20 +0,0 @@
-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.10rc6/src/buz/event/middleware/base_consume_middleware.py

@@ -1,19 +0,0 @@
-from abc import abstractmethod
-
-from buz.event import Event, Subscriber
-from buz.event.middleware import ConsumeMiddleware, ConsumeCallable
-
-
-class BaseConsumeMiddleware(ConsumeMiddleware):
-    def on_consume(self, event: Event, subscriber: Subscriber, consume: ConsumeCallable) -> None:
-        self._before_on_consume(event, subscriber)
-        consume(event, subscriber)
-        self._after_on_consume(event, subscriber)
-
-    @abstractmethod
-    def _before_on_consume(self, event: Event, subscriber: Subscriber) -> None:
-        pass
-
-    @abstractmethod
-    def _after_on_consume(self, event: Event, subscriber: Subscriber) -> None:
-        pass

buz-2.15.10rc6/src/buz/event/middleware/consume_middleware.py

@@ -1,13 +0,0 @@
-from abc import abstractmethod
-from typing import Callable
-
-from buz.event import Event, Subscriber
-from buz.middleware import Middleware
-
-ConsumeCallable = Callable[[Event, Subscriber], None]
-
-
-class ConsumeMiddleware(Middleware):
-    @abstractmethod
-    def on_consume(self, event: Event, subscriber: Subscriber, consume: ConsumeCallable) -> None:
-        pass