buz 2.15.10rc5__tar.gz → 2.15.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.15.10rc5
+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
@@ -22,7 +22,7 @@ Classifier: Typing :: Typed
 Provides-Extra: aiokafka
 Provides-Extra: kombu
 Provides-Extra: pypendency
-Requires-Dist: aiohttp (>=3.11.13,<4.0.0)
+Requires-Dist: aiohttp (>=3.12.15,<4.0.0)
 Requires-Dist: aiokafka[lz4] (==0.12.0) ; extra == "aiokafka"
 Requires-Dist: asgiref (>=3.8.1,<4.0.0) ; extra == "aiokafka"
 Requires-Dist: cachetools (>=5.5.0,<6.0.0)

{buz-2.15.10rc5 → buz-2.15.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "buz"
-version = "2.15.10-rc5"
+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>"]
@@ -30,7 +30,7 @@ dacite = "^1.8.1"
 aiokafka = {version = "==0.12.0", extras = ["lz4"], optional = true}
 asgiref = {version = "^3.8.1", optional = true}
 cachetools = "^5.5.0"
-aiohttp = "^3.11.13"
+aiohttp = "^3.12.15"
 
 [tool.poetry.dev-dependencies]
 black = "^23.3"

{buz-2.15.10rc5 → buz-2.15.11}/src/buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py

@@ -114,8 +114,8 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
     async def configure_http_check_server(self, health_check_port: int) -> web.TCPSite:
         self._logger.info(f"Starting health check server on port {health_check_port}")
         app = web.Application()
-        app.router.add_get("/health", lambda request: self.__health_check())
-        app.router.add_get("/ready", lambda request: self.__is_ready())
+        app.router.add_get("/health", self.__health_check)
+        app.router.add_get("/ready", self.__is_ready)
 
         runner = web.AppRunner(app)
         await runner.setup()
@@ -351,6 +351,8 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
         self._logger.info(
             f"rebalancing in progress, assigning partitions {topics_partitions} to consumer {consumer.get_consumer_group()}"
         )
+        for topic_partition in topics_partitions:
+            self.__queue_per_consumer_mapper[consumer].create_key(topic_partition)
 
     async def __on_partition_revoked(self, consumer: AIOKafkaConsumer, topics_partitions: set[TopicPartition]) -> None:
         self._logger.info(
@@ -362,7 +364,7 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
             consumer_fqn=consumer.get_consumer_group(),
         ):
             for topic_partition in topics_partitions:
-                self.__queue_per_consumer_mapper[consumer].clear(topic_partition)
+                self.__queue_per_consumer_mapper[consumer].remove_key(topic_partition)
 
         self.decrease_number_of_rebalancing_in_progress()
 
@@ -382,7 +384,7 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
     async def __manage_kafka_consumers_stopping(self) -> None:
         await gather(*[kafka_consumer.stop() for kafka_consumer in self.__queue_per_consumer_mapper.keys()])
 
-    async def __health_check(self) -> web.Response:
+    async def __health_check(self, request: web.Request) -> web.Response:
         health_information = {
             "subscribers": [subscriber.fqn() for subscriber in self.__subscribers],
             "number_of_subscribers": len(self.__subscribers),
@@ -391,7 +393,7 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
 
         return web.Response(text=json.dumps(health_information), content_type="application/json")
 
-    async def __is_ready(self) -> web.Response:
+    async def __is_ready(self, request: web.Request) -> web.Response:
         is_ready = self.__is_worked_initialized
         status_code = 200 if is_ready else 503
 

{buz-2.15.10rc5 → 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.10rc5 → 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.10rc5 → 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.10rc5 → 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.10rc5 → 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.10rc5 → 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.10rc5 → 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.10rc5 → buz-2.15.11}/src/buz/kafka/infrastructure/aiokafka/rebalance/kafka_callback_rebalancer.py

@@ -47,4 +47,6 @@ class KafkaCallbackRebalancer(ConsumerRebalanceListener):
 
         if self.__rebalancing_start_time is not None:
             elapsed_time_ms = int((datetime.now() - self.__rebalancing_start_time).total_seconds() * 1000)
-            self.__logger.info(f"Rebalancing process ended, elapsed time: {elapsed_time_ms} ms")
+            self.__logger.info(
+                f"Rebalancing for topic {set(v.topic for v in assigned)} ended, elapsed time: {elapsed_time_ms} ms"
+            )

{buz-2.15.10rc5 → buz-2.15.11}/src/buz/queue/in_memory/in_memory_multiqueue_repository.py

@@ -12,18 +12,22 @@ class InMemoryMultiqueueRepository(MultiqueueRepository[K, R]):
         self.__queues = cast(dict[K, Queue[R]], {})
         self.__last_key_index = 0
 
-    def clear(self, key: K) -> None:
-        self.__queues.pop(key, None)
+    def create_key(self, key: K) -> None:
+        self.__queues[key] = Queue[R]()
+
+    def remove_key(self, key: K) -> None:
+        if key not in self.__queues:
+            return
+
+        self.__queues.pop(key)
 
     def push(self, key: K, record: R) -> None:
         if key not in self.__queues:
-            self.__add_key(key)
+            return
+
         queue = self.__queues[key]
         queue.put(record)
 
-    def __add_key(self, key: K) -> None:
-        self.__queues[key] = Queue[R]()
-
     def pop(self) -> Optional[R]:
         if not self.__queues:
             return None

{buz-2.15.10rc5 → buz-2.15.11}/src/buz/queue/multiqueue_repository.py

@@ -7,7 +7,11 @@ R = TypeVar("R")
 
 class MultiqueueRepository(ABC, Generic[K, R]):
     @abstractmethod
-    def clear(self, key: K) -> None:
+    def create_key(self, key: K) -> None:
+        pass
+
+    @abstractmethod
+    def remove_key(self, key: K) -> None:
         pass
 
     @abstractmethod

buz-2.15.10rc5/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.10rc5/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.10rc5/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.10rc5/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