buz 2.14.0__py3-none-any.whl → 2.14.2__py3-none-any.whl

buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py

@@ -4,7 +4,6 @@ from typing import Optional, Sequence, Type, TypeVar
 from aiokafka.coordinator.assignors.abstract import AbstractPartitionAssignor
 
 from buz.event import Event
-
 from buz.event.async_subscriber import AsyncSubscriber
 from buz.event.infrastructure.buz_kafka.base_buz_aiokafka_async_consumer import BaseBuzAIOKafkaAsyncConsumer
 from buz.event.infrastructure.buz_kafka.consume_strategy.consume_strategy import KafkaConsumeStrategy
@@ -15,11 +14,11 @@ from buz.event.meta_subscriber import MetaSubscriber
 from buz.event.middleware.async_consume_middleware import AsyncConsumeMiddleware
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
 from buz.event.strategies.retry.reject_callback import RejectCallback
-
 from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
 from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
 from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.deserializers.byte_deserializer import ByteDeserializer
 from buz.kafka.infrastructure.deserializers.bytes_to_message_deserializer import BytesToMessageDeserializer
 from buz.kafka.infrastructure.deserializers.implementations.json_bytes_to_message_deserializer import (
     JSONBytesToMessageDeserializer,
@@ -84,7 +83,9 @@ class BuzAIOKafkaAsyncConsumer(BaseBuzAIOKafkaAsyncConsumer):
                 f"Subscriber {subscriber.__class__.__name__} is not a subclass of Subscriber, probably you are trying to use a synchronous subscriber"
             )
 
-        byte_deserializer = self._deserializers_per_subscriber.get(subscriber) or JSONBytesToMessageDeserializer(
+        byte_deserializer: ByteDeserializer[Event] = self._deserializers_per_subscriber.get(
+            subscriber
+        ) or JSONBytesToMessageDeserializer(
             # todo: it looks like in next python versions the inference engine is powerful enough to ensure this type, so we can remove it when we upgrade the python version of the library
             event_class=subscriber.handles()  # type: ignore
         )

buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py

@@ -19,6 +19,7 @@ from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTo
 from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
 from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.deserializers.byte_deserializer import ByteDeserializer
 from buz.kafka.infrastructure.deserializers.bytes_to_message_deserializer import BytesToMessageDeserializer
 from buz.kafka.infrastructure.deserializers.implementations.json_bytes_to_message_deserializer import (
     JSONBytesToMessageDeserializer,
@@ -83,7 +84,9 @@ class BuzAIOKafkaMultiThreadedConsumer(BaseBuzAIOKafkaAsyncConsumer):
                 f"Subscriber {subscriber.__class__.__name__} is not a subclass of Subscriber, probably you are trying to use an asynchronous subscriber"
             )
 
-        byte_deserializer = self._deserializers_per_subscriber.get(subscriber) or JSONBytesToMessageDeserializer(
+        byte_deserializer: ByteDeserializer[Event] = self._deserializers_per_subscriber.get(
+            subscriber
+        ) or JSONBytesToMessageDeserializer(
             # todo: it looks like in next python versions the inference engine is powerful enough to ensure this type, so we can remove it when we upgrade the python version of the library
             event_class=subscriber.handles()  # type: ignore
         )

buz/event/infrastructure/buz_kafka/exceptions/retry_exception.py

@@ -0,0 +1,12 @@
+class ConsumerRetryException(Exception):
+    def __init__(
+        self,
+        *,
+        event_id: str,
+        subscriber_fqn: str,
+        number_of_executions: int,
+    ) -> None:
+        super().__init__(
+            f"An exception happened during the consumption of the event '{event_id}' by the subscriber '{subscriber_fqn}' "
+            + f"during execution number '{number_of_executions}'. Retrying the consumption..."
+        )

buz/event/infrastructure/buz_kafka/kafka_event_async_subscriber_executor.py

@@ -6,6 +6,7 @@ from typing import Optional, Sequence, cast
 from buz.event import Event
 from buz.event.async_subscriber import AsyncSubscriber
 from buz.event.infrastructure.buz_kafka.consume_strategy.kafka_on_fail_strategy import KafkaOnFailStrategy
+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.middleware.async_consume_middleware import AsyncConsumeMiddleware
 from buz.event.middleware.async_consume_middleware_chain_resolver import AsyncConsumeMiddlewareChainResolver
@@ -26,7 +27,7 @@ class KafkaEventAsyncSubscriberExecutor(KafkaEventSubscriberExecutor):
         logger: Logger,
         consume_middlewares: Optional[Sequence[AsyncConsumeMiddleware]] = None,
         seconds_between_retries: float = 5,
-        byte_deserializer: ByteDeserializer,
+        byte_deserializer: ByteDeserializer[Event],
         header_deserializer: KafkaHeaderSerializer,
         on_fail_strategy: KafkaOnFailStrategy,
         consume_retrier: Optional[ConsumeRetrier] = None,
@@ -53,10 +54,17 @@ class KafkaEventAsyncSubscriberExecutor(KafkaEventSubscriberExecutor):
 
             kafka_record_value = cast(bytes, kafka_poll_record.value)
 
+            deserialized_value = self.__byte_deserializer.deserialize(kafka_record_value)
+
+            self.__logger.info(
+                f"consuming the event '{deserialized_value.id}' by the subscriber '{self.__subscriber.fqn()}', "
+                + f"topic: '{kafka_poll_record.topic}', partition: '{kafka_poll_record.partition}', offset: '{kafka_poll_record.offset}'"
+            )
+
             await self.__consumption_callback(
                 self.__subscriber,
                 KafkaConsumerRecord(
-                    value=self.__byte_deserializer.deserialize(kafka_record_value),
+                    value=deserialized_value,
                     headers=self.__header_deserializer.deserialize(kafka_poll_record.headers),
                 ),
             )
@@ -78,20 +86,28 @@ class KafkaEventAsyncSubscriberExecutor(KafkaEventSubscriberExecutor):
 
     async def __perform_consume(self, event: Event, subscriber: AsyncSubscriber) -> None:
         should_retry = True
+        number_of_executions = 0
         while should_retry is True:
             try:
+                number_of_executions += 1
                 await subscriber.consume(event)
                 return
             except Exception as exception:
-                self.__logger.exception(
-                    f"Event {event.id} could not be consumed by the subscriber, error: {traceback.format_exc()}"
-                )
-
                 if self.__should_retry(event, subscriber) is True:
+                    self.__logger.warning(
+                        ConsumerRetryException(
+                            number_of_executions=number_of_executions,
+                            event_id=event.id,
+                            subscriber_fqn=subscriber.fqn(),
+                        ),
+                        exc_info=exception,
+                    )
                     self.__register_retry(event, subscriber)
                     await sleep(self.__seconds_between_retires)
                     continue
 
+                self.__logger.exception(exception)
+
                 if self.__reject_callback:
                     self.__reject_callback.on_reject(event=event, subscribers=[subscriber], exception=exception)
 

buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py

@@ -4,6 +4,7 @@ import time
 from typing import Optional, Sequence, cast
 from buz.event import Event
 from buz.event.infrastructure.buz_kafka.consume_strategy.kafka_on_fail_strategy import KafkaOnFailStrategy
+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.middleware.consume_middleware import ConsumeMiddleware
 from buz.event.middleware.consume_middleware_chain_resolver import ConsumeMiddlewareChainResolver
@@ -25,7 +26,7 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
         logger: Logger,
         consume_middlewares: Optional[Sequence[ConsumeMiddleware]] = None,
         seconds_between_retries: float = 5,
-        byte_deserializer: ByteDeserializer,
+        byte_deserializer: ByteDeserializer[Event],
         header_deserializer: KafkaHeaderSerializer,
         on_fail_strategy: KafkaOnFailStrategy,
         consume_retrier: Optional[ConsumeRetrier] = None,
@@ -52,12 +53,19 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
 
             kafka_record_value = cast(bytes, kafka_poll_record.value)
 
+            deserialized_value = self.__byte_deserializer.deserialize(kafka_record_value)
+
+            self.__logger.info(
+                f"consuming the event '{deserialized_value.id}' by the subscriber '{self.__subscriber.fqn()}', "
+                + f"topic: '{kafka_poll_record.topic}', partition: '{kafka_poll_record.partition}', offset: '{kafka_poll_record.offset}'"
+            )
+
             await get_running_loop().run_in_executor(
                 None,
                 lambda: self.__execution_callback(
                     self.__subscriber,
                     KafkaConsumerRecord(
-                        value=self.__byte_deserializer.deserialize(kafka_record_value),
+                        value=deserialized_value,
                         headers=self.__header_deserializer.deserialize(kafka_poll_record.headers),
                     ),
                 ),
@@ -75,13 +83,22 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
 
     def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
         should_retry = True
+        execution_number = 0
         while should_retry is True:
             try:
+                execution_number += 1
                 subscriber.consume(event)
                 return
             except Exception as exception:
-                self.__logger.warning(f"Event {event.id} could not be consumed by the subscriber {subscriber.fqn}")
                 if self.__should_retry(event, subscriber) is True:
+                    self.__logger.warning(
+                        ConsumerRetryException(
+                            number_of_executions=execution_number,
+                            event_id=event.id,
+                            subscriber_fqn=subscriber.fqn(),
+                        ),
+                        exc_info=exception,
+                    )
                     self.__register_retry(event, subscriber)
                     time.sleep(self.__seconds_between_retires)
                     continue

buz/event/meta_subscriber.py

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

buz/kafka/domain/exceptions/not_all_partition_assigned_exception.py

@@ -2,7 +2,12 @@ from __future__ import annotations
 
 
 class NotAllPartitionAssignedException(Exception):
-    def __init__(self, topic_name: str) -> None:
+    def __init__(
+        self,
+        *,
+        topic_name: str,
+        consumer_group: str,
+    ) -> None:
         super().__init__(
-            f'Not all the partition were assigned for the topic "{topic_name}", please disconnect the rest of subscribers'
+            f'Not all the partitions in the consumer group "{consumer_group}" were assigned in the topic "{topic_name}". Please disconnect the rest of subscribers'
         )

buz/kafka/domain/exceptions/not_valid_partition_number_exception.py

@@ -0,0 +1,10 @@
+class NotValidPartitionNumberException(Exception):
+    def __init__(
+        self,
+        *,
+        partition_number: int,
+        min_partition_number: int,
+    ) -> None:
+        super().__init__(
+            f'"{partition_number}" is not a valid partition number, the minimum partition number is "{min_partition_number}"'
+        )

buz/kafka/domain/services/kafka_admin_client.py

@@ -40,6 +40,10 @@ class KafkaAdminClient(ConnectionManager, ABC):
     ) -> set[str]:
         pass
 
+    @abstractmethod
+    def get_number_of_partitions(self, topic: str) -> int:
+        pass
+
     # This function moves the following offset from the provided date
     # if there are no messages with a date greater than the provided offset
     # the offset will be moved to the end
@@ -52,3 +56,12 @@ class KafkaAdminClient(ConnectionManager, ABC):
         target_datetime: datetime,
     ) -> None:
         pass
+
+    @abstractmethod
+    def increase_topic_partitions_and_set_offset_of_related_consumer_groups_to_the_beginning_of_the_new_ones(
+        self,
+        *,
+        topic: str,
+        new_number_of_partitions: int,
+    ) -> None:
+        pass

buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py

@@ -8,10 +8,12 @@ from typing import Any, Callable, Optional, Sequence, cast
 from cachetools import TTLCache
 from kafka import KafkaClient, KafkaConsumer
 from kafka.admin import KafkaAdminClient as KafkaPythonLibraryAdminClient, NewTopic
+from kafka.admin.new_partitions import NewPartitions
 from kafka.errors import TopicAlreadyExistsError
 from kafka.structs import TopicPartition, OffsetAndTimestamp
 
 from buz.kafka.domain.exceptions.not_all_partition_assigned_exception import NotAllPartitionAssignedException
+from buz.kafka.domain.exceptions.not_valid_partition_number_exception import NotValidPartitionNumberException
 from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
 from buz.kafka.domain.exceptions.topic_not_found_exception import TopicNotFoundException
 from buz.kafka.domain.models.consumer_initial_offset_position import ConsumerInitialOffsetPosition
@@ -150,10 +152,10 @@ class KafkaPythonAdminClient(KafkaAdminClient):
             group_ids=subscription_groups,
         )
 
-    def get_subscription_groups(
+    def get_cluster_consumer_groups(
         self,
     ) -> set[str]:
-        return set(self._get_kafka_admin().list_consumer_groups())
+        return set([consumer_group_tuple[0] for consumer_group_tuple in self._get_kafka_admin().list_consumer_groups()])
 
     def _wait_for_cluster_update(self) -> None:
         future = self._get_kafka_client().cluster.request_update()
@@ -166,6 +168,46 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         topic: str,
         target_datetime: datetime,
     ) -> None:
+        (consumer, topic_partitions) = self.__get_consumer_with_all_partitions_assigned(
+            consumer_group=consumer_group,
+            topic=topic,
+        )
+
+        offsets_for_date = self.__get_first_offset_after_date(
+            consumer=consumer,
+            topic_partitions=topic_partitions,
+            target_datetime=target_datetime,
+        )
+
+        try:
+            end_offsets = consumer.end_offsets(topic_partitions)
+
+            if end_offsets is None or len(end_offsets.keys()) != len(topic_partitions):
+                raise Exception(f'There was an error extracting the end offsets of the topic "{topic}"')
+
+            for topic_partition in topic_partitions:
+                offset_and_timestamp = offsets_for_date.get(topic_partition)
+                if offset_and_timestamp:
+                    self._logger.info(f'moving "{topic_partition}" to the offset "{offset_and_timestamp.offset}"')
+                    consumer.seek(topic_partition, offset_and_timestamp.offset)
+                else:
+                    self._logger.info(
+                        f'moving "{topic_partition}" to the end of the topic because there are no messages later than "{target_datetime}"'
+                    )
+                    consumer.seek(topic_partition, end_offsets[topic_partition])
+
+            consumer.commit()
+        except Exception as exception:
+            consumer.close()
+            raise exception
+
+        consumer.close()
+
+    def __get_consumer_with_all_partitions_assigned(
+        self,
+        consumer_group: str,
+        topic: str,
+    ) -> tuple[KafkaConsumer, Sequence[TopicPartition]]:
         consumer = KafkaConsumer(
             group_id=consumer_group,
             enable_auto_commit=False,
@@ -175,44 +217,32 @@ class KafkaPythonAdminClient(KafkaAdminClient):
             **self._config_in_library_format,
         )
 
-        partitions = consumer.partitions_for_topic(topic)
-
-        if partitions is None:
-            raise TopicNotFoundException(topic)
+        try:
+            partitions = self.get_number_of_partitions(topic)
 
-        topic_partitions = [TopicPartition(topic, p) for p in partitions]
-        consumer.subscribe(topics=[topic])
+            topic_partitions = [TopicPartition(topic=topic, partition=partition) for partition in range(partitions)]
 
-        self.__force_partition_assignment(consumer)
+            consumer.subscribe(topic)
 
-        # We need all the partitions in order to update the offsets
-        if len(consumer.assignment()) != len(topic_partitions):
-            raise NotAllPartitionAssignedException(topic)
+            self.__force_partition_assignment(consumer)
 
-        offsets_for_date = self.__get_first_offset_after_date(
-            consumer=consumer,
-            topic_partitions=topic_partitions,
-            target_datetime=target_datetime,
-        )
-
-        end_offsets = consumer.end_offsets(topic_partitions)
-
-        if end_offsets is None or len(end_offsets.keys()) != len(topic_partitions):
-            raise Exception(f'There was an error extracting the end offsets of the topic "{topic}"')
-
-        for topic_partition in topic_partitions:
-            offset_and_timestamp = offsets_for_date.get(topic_partition)
-            if offset_and_timestamp:
-                self._logger.info(f'moving "{topic_partition}" to the offset "{offset_and_timestamp.offset}"')
-                consumer.seek(topic_partition, offset_and_timestamp.offset)
-            else:
-                self._logger.info(
-                    f'moving "{topic_partition}" to the end of the topic because there are no messages later than "{target_datetime}"'
+            # We need all the partitions in order to update the offsets
+            if len(consumer.assignment()) != len(topic_partitions):
+                raise NotAllPartitionAssignedException(
+                    topic_name=topic,
+                    consumer_group=consumer_group,
                 )
-                consumer.seek(topic_partition, end_offsets[topic_partition])
 
-        consumer.commit()
-        consumer.close()
+            # This could produce a race condition, but it is a limitation of kafka admin (we are not able to check if all the partition are assigned using the manual assignment)
+            # https://github.com/dpkp/kafka-python/blob/master/kafka/consumer/group.py#L430
+            consumer.unsubscribe()
+            consumer.assign(topic_partitions)
+            self.__force_partition_assignment(consumer)
+
+            return (consumer, topic_partitions)
+        except Exception as exception:
+            consumer.close()
+            raise exception
 
     def __get_first_offset_after_date(
         self,
@@ -235,3 +265,138 @@ class KafkaPythonAdminClient(KafkaAdminClient):
     # We are not to commit the new offset, but we need to execute a polling in order to start the partition assignment
     def __force_partition_assignment(self, consumer: KafkaConsumer) -> None:
         consumer.poll(max_records=1, timeout_ms=0)
+
+    def increase_topic_partitions_and_set_offset_of_related_consumer_groups_to_the_beginning_of_the_new_ones(
+        self,
+        *,
+        topic: str,
+        new_number_of_partitions: int,
+    ) -> None:
+        self._logger.info(
+            f'Increasing topic "{topic}" partitions: Verifying the new number of partitions "{new_number_of_partitions}"'
+        )
+
+        previous_partitions_number = self.get_number_of_partitions(topic)
+        topic_partitions = [
+            TopicPartition(topic=topic, partition=partition) for partition in range(previous_partitions_number)
+        ]
+
+        if previous_partitions_number >= new_number_of_partitions:
+            raise NotValidPartitionNumberException(
+                partition_number=new_number_of_partitions,
+                min_partition_number=len(topic_partitions),
+            )
+
+        self._logger.info(f'Increasing topic "{topic}" partitions: Extracting related consumer groups')
+        related_consumer_groups = self.__get_consumer_groups_related_to_a_topic(topic_partitions)
+
+        self._logger.info(
+            f'Increasing topic "{topic}" partitions: The following consumer groups will be updated:"{related_consumer_groups}"'
+        )
+
+        consumers_to_update: list[KafkaConsumer] = []
+        new_partitions_consumer: Optional[KafkaConsumer] = None
+
+        try:
+            for consumer_group in related_consumer_groups:
+                self._logger.info(
+                    f'Increasing topic "{topic}" partitions: Requesting the assignment of the partitions of the group "{consumer_group}"'
+                )
+                (consumer_with_all_partitions, _) = self.__get_consumer_with_all_partitions_assigned(
+                    consumer_group=consumer_group,
+                    topic=topic,
+                )
+                consumers_to_update.append(consumer_with_all_partitions)
+
+            self._logger.info(
+                f'Increasing topic "{topic}" partitions: Incrementing the partition to "{new_number_of_partitions}"'
+            )
+
+            self._get_kafka_admin().create_partitions(
+                {
+                    topic: NewPartitions(total_count=new_number_of_partitions),
+                }
+            )
+
+            new_partitions = [
+                TopicPartition(
+                    topic=topic,
+                    partition=partition_index,
+                )
+                for partition_index in range(previous_partitions_number, new_number_of_partitions)
+            ]
+
+            for consumer_group in related_consumer_groups:
+                self._logger.info(
+                    f'Increasing topic "{topic}" partitions: Moving the offset of the consumer group "{consumer_group}" to the beginning of the new partitions'
+                )
+                # We need to create a new consumer because kafka-python has a limitation that does not allow to assign specific partitions to a consumer subscribed to an entire topic
+                new_partitions_consumer = KafkaConsumer(
+                    group_id=consumer_group,
+                    enable_auto_commit=False,
+                    auto_offset_reset=KafkaPythonConsumerInitialOffsetPositionTranslator.to_kafka_supported_format(
+                        ConsumerInitialOffsetPosition.BEGINNING
+                    ),
+                    **self._config_in_library_format,
+                )
+                new_partitions_consumer.assign(new_partitions)
+                for new_partition in new_partitions:
+                    new_partitions_consumer.seek(new_partition, 0)
+                new_partitions_consumer.commit()
+                new_partitions_consumer.close()
+
+            self._logger.info(f'Increasing topic "{topic}" partitions: Process complete')
+
+        except Exception as exception:
+            for consumer_with_all_partitions in consumers_to_update:
+                consumer_with_all_partitions.close()
+
+            if new_partitions_consumer is not None:
+                new_partitions_consumer.close()
+
+            self._logger.error(f'Increasing topic "{topic}" partitions: unexpected error {exception}')
+            raise exception
+
+        return
+
+    def get_number_of_partitions(self, topic: str) -> int:
+        consumer = KafkaConsumer(
+            enable_auto_commit=False,
+            auto_offset_reset=KafkaPythonConsumerInitialOffsetPositionTranslator.to_kafka_supported_format(
+                ConsumerInitialOffsetPosition.BEGINNING
+            ),
+            **self._config_in_library_format,
+        )
+
+        try:
+            partitions = consumer.partitions_for_topic(topic)
+            if partitions is None:
+                raise TopicNotFoundException(topic_name=topic)
+
+            return len(partitions)
+        except Exception as exception:
+            consumer.close()
+            raise exception
+
+    # The purpose of this function is to get all the consumer groups that are consuming from the topic
+    # It is a heavy tasks because we need to get the offset of all the partitions of the topic
+    def __get_consumer_groups_related_to_a_topic(self, topic_partitions: Sequence[TopicPartition]) -> set[str]:
+        cluster_consumer_groups = self.get_cluster_consumer_groups()
+
+        related_consumer_groups: set[str] = set()
+
+        for consumer_group in cluster_consumer_groups:
+            partitions_offsets = list(
+                self._get_kafka_admin()
+                .list_consumer_group_offsets(consumer_group, partitions=topic_partitions)
+                .values()
+            )
+
+            partitions_with_valid_offsets = [partition for partition in partitions_offsets if partition.offset != -1]
+
+            if len(partitions_with_valid_offsets) == 0:
+                continue
+
+            related_consumer_groups.add(consumer_group)
+
+        return related_consumer_groups

buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py

@@ -88,5 +88,5 @@ class KafkaPythonAdminTestClient(KafkaPythonAdminClient, KafkaAdminTestClient):
         self,
     ) -> None:
         self.delete_topics(topics=self.get_topics())
-        self.delete_subscription_groups(subscription_groups=self.get_subscription_groups())
+        self.delete_subscription_groups(subscription_groups=self.get_cluster_consumer_groups())
         self._wait_for_cluster_update()

{buz-2.14.0.dist-info → buz-2.14.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.14.0
+Version: 2.14.2
 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.0.dist-info → buz-2.14.2.dist-info}/RECORD

@@ -48,8 +48,8 @@ buz/event/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 buz/event/infrastructure/buz_kafka/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus.py,sha256=SyLblUVlwWOaNfZzK7vL6Ee4m-85vZVCH0rjOgqVAww,4913
 buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py,sha256=E9Sy6IDZrywowcO9qIOJF5zjFvnE4CncTiZD3VC-554,13793
-buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py,sha256=J_9NhImjlotueksFQ5mJ80Uto3BSgCJvOxJ29pzbW-U,5601
-buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py,sha256=ECuWXI2Es5W6mEplZ783JCGx6VvvG3VLp8TzobwuH_8,5542
+buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py,sha256=u69_YYDsztq4cZDKQPo4x8FPIx-NRzHJe1SCq0GaCjg,5732
+buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py,sha256=Si7bqWfsKqOjH6PIxnqtOgO_fSviVJbt2G9avv2DgiM,5675
 buz/event/infrastructure/buz_kafka/buz_kafka_event_bus.py,sha256=ymRSvcYVgbVCPgHN6rMBVBHQ5heCSwCDl6EffyqGVX8,4601
 buz/event/infrastructure/buz_kafka/consume_strategy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/infrastructure/buz_kafka/consume_strategy/consume_strategy.py,sha256=RqlXe5W2S6rH3FTr--tcxzFJTAVLb-Dhl7m6qjgNz2M,331
@@ -57,9 +57,10 @@ buz/event/infrastructure/buz_kafka/consume_strategy/kafka_on_fail_strategy.py,sh
 buz/event/infrastructure/buz_kafka/consume_strategy/topic_and_subscription_group_per_subscriber_kafka_consumer_strategy.py,sha256=LX9mARKCLKyyo4loxegxR_s4qNP1QfabXXYp4Keusts,634
 buz/event/infrastructure/buz_kafka/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/infrastructure/buz_kafka/exceptions/kafka_event_bus_config_not_valid_exception.py,sha256=VUKZXA2ygjg21P4DADFl_Tace6RwSXia1MRYvJypxbM,135
-buz/event/infrastructure/buz_kafka/kafka_event_async_subscriber_executor.py,sha256=ULM5I35hmgUAYJobTYyCgMXYYhDvLNhRd5S_7tMUMog,5073
+buz/event/infrastructure/buz_kafka/exceptions/retry_exception.py,sha256=Fq9kvI3DpFsGD3x2icmQ1fYIsuKZAFqI3tCibAuEtSQ,441
+buz/event/infrastructure/buz_kafka/kafka_event_async_subscriber_executor.py,sha256=OGPuoFGKkaV0pLyBKqv_kHz-xCRFWcqHmJBGOfmJTfc,5845
 buz/event/infrastructure/buz_kafka/kafka_event_subscriber_executor.py,sha256=EyG2vsFYErWAyqxdXqSwxx5Zi_y0d6i0h05XavJMnxg,254
-buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py,sha256=S24FMC4oEilO1kx5q1f-_p2Jl54ATQhINPwHeU_ZyME,4835
+buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py,sha256=S9ECzWpUQm7YKEtOFuzZMZvRVaiAMyMVfNksJ7Jno9A,5600
 buz/event/infrastructure/buz_kafka/publish_strategy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/infrastructure/buz_kafka/publish_strategy/publish_strategy.py,sha256=zIkgMnUU7ueG6QHEubMzdTHOtqdldIbS7k5FDLNmqVk,178
 buz/event/infrastructure/buz_kafka/publish_strategy/topic_per_event_kafka_publish_strategy.py,sha256=aLKj6GyLJNcMbuDA1QBa-RzWKBHEorBuPFkkqo_H60k,405
@@ -79,7 +80,7 @@ buz/event/infrastructure/kombu/retry_strategy/simple_publish_retry_policy.py,sha
 buz/event/infrastructure/models/consuming_task.py,sha256=GJvn6fGTN5ZQJaOuQCX17JP7SInIGvTLTk7DLoqnLQ4,302
 buz/event/infrastructure/queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/meta_base_subscriber.py,sha256=IP2Siol98OmoeCoOISiaCJxgxJG2SCrhmbAN4t01aWg,698
-buz/event/meta_subscriber.py,sha256=ieCOtOD2JTXizyFxisBZ4-d_4MvCmIW4BksstngV8oI,265
+buz/event/meta_subscriber.py,sha256=JPhhRqHkDOBWhuqtPmseUtAoYde1OmTBViqVbLBhvME,359
 buz/event/middleware/__init__.py,sha256=1_33sdvRejCF4mHuKVkbldeJde6Y2jYtSrB5vMs0Rfo,773
 buz/event/middleware/async_consume_middleware.py,sha256=314z7ZyhvQIvi90kEO0t-FlnHSyRjArk3RqKOdDE6bM,459
 buz/event/middleware/async_consume_middleware_chain_resolver.py,sha256=Hw75JAs5pyZVDi7-nD4I1nbUXjwYpHQW9PctafGS4ks,1193
@@ -136,8 +137,9 @@ buz/event/worker.py,sha256=BL9TXB_kyr0Avql9fIcFm3CDNnXPvZB6O6BxVwjtCdA,942
 buz/handler.py,sha256=cZqV1NDPGVZQgJ3YSBDhOQ1sdJGdUopxi57yQ6fbPvc,272
 buz/kafka/__init__.py,sha256=R3fcyET-SNEAvk_XlBQbHIbQVb63Qiz6lVrif3nDhNU,3435
 buz/kafka/domain/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-buz/kafka/domain/exceptions/not_all_partition_assigned_exception.py,sha256=9zDWoh0SbHLRuCvpfIGcvrmcscKsXpbAPIxr5-z-GYg,296
+buz/kafka/domain/exceptions/not_all_partition_assigned_exception.py,sha256=1Ky6gDh_baD6cGB0MBnjbkkLcw2zQU_kFXPpDZn56z0,400
 buz/kafka/domain/exceptions/not_valid_kafka_message_exception.py,sha256=Dn6I_-eGQnOuu5WW24oKGOdKOu4EdM8ByH3DLAbz5SY,57
+buz/kafka/domain/exceptions/not_valid_partition_number_exception.py,sha256=YZyGbblHk6ON9sBtjRQTDa-nC88i4oe14_VSO8vSTm0,337
 buz/kafka/domain/exceptions/topic_already_created_exception.py,sha256=UrisdveZGa2BB0ko4mS7-5fwy8eGsIu409_grtq1r9k,333
 buz/kafka/domain/exceptions/topic_not_found_exception.py,sha256=kLuqGqfsb6YTCe5UCKpMwBm_QAnU9Udfb8bWajPoA8k,201
 buz/kafka/domain/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -155,7 +157,7 @@ buz/kafka/domain/models/kafka_supported_sasl_mechanisms.py,sha256=ASyDaFgseQRcUJ
 buz/kafka/domain/models/kafka_supported_security_protocols.py,sha256=ffY2-9sOj4XIkJTSQVkqeOb4KnuqEYXISDarfDN8r9Q,161
 buz/kafka/domain/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/domain/services/async_kafka_producer.py,sha256=gSq3WwEVux_gp3EKDAMN1WsM027uklB58E-WnKpyhPs,533
-buz/kafka/domain/services/kafka_admin_client.py,sha256=XE6H-4JWsjygKjdtLtGMX5ELhWkJcpR7ai9CO2kB98Y,1222
+buz/kafka/domain/services/kafka_admin_client.py,sha256=Kh_w-qWEY8rsrlYjnJT1FrJLVZrO3l2LeRAWFyc_nOg,1558
 buz/kafka/domain/services/kafka_admin_test_client.py,sha256=91l_vFIo1yhJLQQCC_OmeXZ5F429zP7Hx5g4FNllpfE,1625
 buz/kafka/domain/services/kafka_producer.py,sha256=8bLTV328orrPHcARzkc6no4vyJzrArVtCsjmSRXDjos,506
 buz/kafka/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -180,8 +182,8 @@ buz/kafka/infrastructure/interfaces/async_connection_manager.py,sha256=JbaLu5UVV
 buz/kafka/infrastructure/interfaces/connection_manager.py,sha256=EWnvShJHOg8QYe6a3ma0urjKjmVMDBi7q8T2cv_i_MQ,200
 buz/kafka/infrastructure/kafka_python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/kafka_python/exception/consumer_interrupted_exception.py,sha256=fqhgV7HILdVdv-p1CsOIaaESKY2ZXBtRGYbrVSdPLg0,164
-buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py,sha256=7HbwkaoedXbxZ4LcGWytU2q_GTdLm_c1ziyGTBoKgF0,9038
-buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py,sha256=wLhnrHzyFJ9ETWNUfd-dmwm_CwZyiImaAP97cEdRgzE,2982
+buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py,sha256=_zTOY3ihiXESUlDj0SECEvixt9MMny0xBGzFPix0ZYM,16241
+buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py,sha256=5xP23dQ7FDuy7dIWNw39C3bMVmaUj9ZQhEEJISRv9ec,2986
 buz/kafka/infrastructure/kafka_python/kafka_python_producer.py,sha256=DkqqLSSXHBf4SXXf-IZwwLhxWrGE95Jg4MO_3RDsikU,3594
 buz/kafka/infrastructure/kafka_python/translators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/kafka_python/translators/consumer_initial_offset_position_translator.py,sha256=hJ48_eyMcnbFL_Y5TOiMbGXrQSryuKk9CvP59MdqNOY,620
@@ -243,7 +245,7 @@ buz/serializer/message_to_json_bytes_serializer.py,sha256=RGZJ64t4t4Pz2FCASZZCv-
 buz/wrapper/__init__.py,sha256=GnRdJFcncn-qp0hzDG9dBHLmTJSbHFVjE_yr-MdW_n4,77
 buz/wrapper/async_to_sync.py,sha256=OfK-vrVUhuN-LLLvekLdMbQYtH0ue5lfbvuasj6ovMI,698
 buz/wrapper/event_loop.py,sha256=pfBJ1g-8A2a3YgW8Gf9Fg0kkewoh3-wgTy2KIFDyfHk,266
-buz-2.14.0.dist-info/LICENSE,sha256=Jytu2S-2SPEgsB0y6BF-_LUxIWY7402fl0JSh36TLZE,1062
-buz-2.14.0.dist-info/METADATA,sha256=f8tigTI_Ee1HBkPHTPfsYHjkOyuBZwlCX6dTeDpjzCQ,1617
-buz-2.14.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-buz-2.14.0.dist-info/RECORD,,
+buz-2.14.2.dist-info/LICENSE,sha256=Jytu2S-2SPEgsB0y6BF-_LUxIWY7402fl0JSh36TLZE,1062
+buz-2.14.2.dist-info/METADATA,sha256=LIxzwAWa6gNGKmz32C5UzoI6hMr-g1lc9AWIEoguWno,1617
+buz-2.14.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+buz-2.14.2.dist-info/RECORD,,