buz 2.13.1rc8__py3-none-any.whl → 2.14.0__py3-none-any.whl

buz/kafka/infrastructure/aiokafka/aiokafka_producer.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from ssl import SSLContext
+from typing import Generic, Optional, TypeVar
+
+from aiokafka import AIOKafkaProducer as NativeAIOKafkaProducer
+from aiokafka.helpers import create_ssl_context
+
+from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
+from buz.kafka.domain.models.kafka_supported_compression_type import KafkaSupportedCompressionType
+from buz.kafka.domain.models.kafka_supported_security_protocols import KafkaSupportedSecurityProtocols
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
+from buz.kafka.infrastructure.serializers.kafka_header_serializer import KafkaHeaderSerializer
+
+T = TypeVar("T")
+
+
+class AIOKafkaProducer(AsyncKafkaProducer, Generic[T]):
+    __DEFAULT_REQUEST_TIMEOUT_MS = 5000
+    __kafka_producer: Optional[NativeAIOKafkaProducer] = None
+
+    def __init__(
+        self,
+        *,
+        connection_config: KafkaConnectionConfig,
+        byte_serializer: ByteSerializer[T],
+        compression_type: Optional[KafkaSupportedCompressionType] = None,
+        retry_backoff_ms: int = 100,
+    ) -> None:
+        self.__connection_config = connection_config
+        self.__byte_serializer = byte_serializer
+        self.__header_serializer = KafkaHeaderSerializer()
+        self.__compression_type = compression_type
+        self.__retry_backoff_ms = retry_backoff_ms
+
+    async def _get_aiokafka_producer(self) -> NativeAIOKafkaProducer:
+        if self.__kafka_producer:
+            return self.__kafka_producer
+
+        ssl_context: Optional[SSLContext] = None
+
+        sasl_mechanism = (
+            self.__connection_config.credentials.sasl_mechanism.value
+            if self.__connection_config.credentials.sasl_mechanism
+            else "PLAIN"
+        )
+
+        if self.__connection_config.credentials.security_protocol == KafkaSupportedSecurityProtocols.SASL_SSL:
+            ssl_context = create_ssl_context()
+
+        self.__kafka_producer = NativeAIOKafkaProducer(
+            client_id=self.__connection_config.client_id,
+            bootstrap_servers=",".join(self.__connection_config.bootstrap_servers),
+            sasl_mechanism=sasl_mechanism,
+            ssl_context=ssl_context,
+            sasl_plain_username=self.__connection_config.credentials.user,
+            sasl_plain_password=self.__connection_config.credentials.password,
+            retry_backoff_ms=self.__retry_backoff_ms,
+            request_timeout_ms=self.__DEFAULT_REQUEST_TIMEOUT_MS,
+            compression_type=self.__compression_type.value if self.__compression_type else None,
+        )
+
+        await self.__kafka_producer.start()
+
+        return self.__kafka_producer
+
+    async def connect(self) -> None:
+        await self._get_aiokafka_producer()
+
+    async def disconnect(self) -> None:
+        if self.__kafka_producer is None:
+            return None
+        await self.__kafka_producer.stop()
+        self.__kafka_producer = None
+
+    async def produce(
+        self,
+        *,
+        topic: str,
+        message: T,
+        partition_key: Optional[str] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> None:
+        serialized_headers = self.__header_serializer.serialize(headers) if headers is not None else None
+        kafka_producer = await self._get_aiokafka_producer()
+
+        await kafka_producer.send_and_wait(
+            topic=topic,
+            value=self.__byte_serializer.serialize(message),
+            headers=serialized_headers,
+            key=partition_key.encode("utf-8") if partition_key else None,
+        )
+
+    async def close(self) -> None:
+        if self.__kafka_producer is not None:
+            await self.__kafka_producer.stop()
+            self.__kafka_producer = None

buz/kafka/infrastructure/interfaces/async_connection_manager.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class AsyncConnectionManager(ABC):
+    @abstractmethod
+    async def connect(self) -> None:
+        pass
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        pass

buz/kafka/infrastructure/interfaces/connection_manager.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class ConnectionManager(ABC):
+    @abstractmethod
+    def connect(self) -> None:
+        pass
+
+    @abstractmethod
+    def disconnect(self) -> None:
+        pass

buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py

@@ -1,34 +1,48 @@
 from __future__ import annotations
 
+from datetime import datetime
+from logging import Logger
 import re
-from typing import Any, Callable, Sequence
+from typing import Any, Callable, Optional, Sequence, cast
 
 from cachetools import TTLCache
-from kafka import KafkaClient
+from kafka import KafkaClient, KafkaConsumer
 from kafka.admin import KafkaAdminClient as KafkaPythonLibraryAdminClient, NewTopic
 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.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
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
 from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 
+from buz.kafka.infrastructure.kafka_python.translators.consumer_initial_offset_position_translator import (
+    KafkaPythonConsumerInitialOffsetPositionTranslator,
+)
+
 INTERNAL_KAFKA_TOPICS = {"__consumer_offsets", "_schema"}
+TOPIC_CACHE_KEY = "topics"
 
 
 class KafkaPythonAdminClient(KafkaAdminClient):
     __PYTHON_KAFKA_DUPLICATED_TOPIC_ERROR_CODE = 36
 
+    _kafka_admin: Optional[KafkaPythonLibraryAdminClient] = None
+    _kafka_client: Optional[KafkaClient] = None
+
     def __init__(
         self,
         *,
-        config: KafkaConnectionConfig,
+        logger: Logger,
+        connection_config: KafkaConnectionConfig,
         cache_ttl_seconds: int = 0,
     ):
-        self._config = config
-        self._config_in_library_format = self.__get_kafka_config_in_library_format(config)
-        self._kafka_admin = KafkaPythonLibraryAdminClient(**self._config_in_library_format)
-        self._kafka_client = KafkaClient(**self._config_in_library_format)
+        self._logger = logger
+        self.__connection_config = connection_config
+        self._config_in_library_format = self.__get_kafka_config_in_library_format(self.__connection_config)
         self.__ttl_cache: TTLCache[str, Any] = TTLCache(maxsize=1, ttl=cache_ttl_seconds)
 
     def __get_kafka_config_in_library_format(self, config: KafkaConnectionConfig) -> dict:
@@ -41,6 +55,28 @@ class KafkaPythonAdminClient(KafkaAdminClient):
             "sasl_plain_password": config.credentials.password,
         }
 
+    def connect(self):
+        self._get_kafka_admin()
+        self._get_kafka_client()
+
+    def disconnect(self):
+        if self._kafka_admin is not None:
+            self._kafka_admin.close()
+            self._kafka_admin = None
+        if self._kafka_client is not None:
+            self._kafka_client.close()
+            self._kafka_client = None
+
+    def _get_kafka_admin(self) -> KafkaPythonLibraryAdminClient:
+        if not self._kafka_admin:
+            self._kafka_admin = KafkaPythonLibraryAdminClient(**self._config_in_library_format)
+        return self._kafka_admin
+
+    def _get_kafka_client(self) -> KafkaClient:
+        if not self._kafka_client:
+            self._kafka_client = KafkaClient(**self._config_in_library_format)
+        return self._kafka_client
+
     def create_topics(
         self,
         *,
@@ -57,7 +93,7 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         ]
 
         try:
-            self._kafka_admin.create_topics(new_topics=new_topics)
+            self._get_kafka_admin().create_topics(new_topics=new_topics)
         except TopicAlreadyExistsError as error:
             topic_names = self.__get_list_of_kafka_topics_from_topic_already_exists_error(error)
             raise KafkaTopicsAlreadyCreatedException(topic_names=topic_names)
@@ -75,14 +111,13 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         self,
         topic: str,
     ) -> bool:
-        topics = self.get_topics()
-        return topic in topics
+        return topic in self.get_topics()
 
     def get_topics(
         self,
     ) -> set[str]:
         return self.__resolve_cached_property(
-            "topics", lambda: set(self._kafka_admin.list_topics()) - INTERNAL_KAFKA_TOPICS
+            TOPIC_CACHE_KEY, lambda: set(self._get_kafka_admin().list_topics()) - INTERNAL_KAFKA_TOPICS
         )
 
     def __resolve_cached_property(self, property_key: str, callback: Callable) -> Any:
@@ -98,24 +133,105 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         *,
         topics: set[str],
     ) -> None:
-        self._kafka_admin.delete_topics(
+        self._get_kafka_admin().delete_topics(
             topics=topics,
         )
+        self.__remove_cache_property(TOPIC_CACHE_KEY)
+
+    def __remove_cache_property(self, property_key: str) -> None:
+        self.__ttl_cache.pop(property_key, None)
 
     def delete_subscription_groups(
         self,
         *,
         subscription_groups: set[str],
     ) -> None:
-        self._kafka_admin.delete_consumer_groups(
+        self._get_kafka_admin().delete_consumer_groups(
             group_ids=subscription_groups,
         )
 
     def get_subscription_groups(
         self,
     ) -> set[str]:
-        return set(self._kafka_admin.list_consumer_groups())
+        return set(self._get_kafka_admin().list_consumer_groups())
 
     def _wait_for_cluster_update(self) -> None:
-        future = self._kafka_client.cluster.request_update()
-        self._kafka_client.poll(future=future)
+        future = self._get_kafka_client().cluster.request_update()
+        self._get_kafka_client().poll(future=future)
+
+    def move_offsets_to_datetime(
+        self,
+        *,
+        consumer_group: str,
+        topic: str,
+        target_datetime: datetime,
+    ) -> None:
+        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,
+        )
+
+        partitions = consumer.partitions_for_topic(topic)
+
+        if partitions is None:
+            raise TopicNotFoundException(topic)
+
+        topic_partitions = [TopicPartition(topic, p) for p in partitions]
+        consumer.subscribe(topics=[topic])
+
+        self.__force_partition_assignment(consumer)
+
+        # We need all the partitions in order to update the offsets
+        if len(consumer.assignment()) != len(topic_partitions):
+            raise NotAllPartitionAssignedException(topic)
+
+        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}"'
+                )
+                consumer.seek(topic_partition, end_offsets[topic_partition])
+
+        consumer.commit()
+        consumer.close()
+
+    def __get_first_offset_after_date(
+        self,
+        *,
+        consumer: KafkaConsumer,
+        topic_partitions: Sequence[TopicPartition],
+        target_datetime: datetime,
+    ) -> dict[TopicPartition, Optional[OffsetAndTimestamp]]:
+        offset_for_times: dict[TopicPartition, Optional[int]] = {}
+        timestamp_ms = int(target_datetime.timestamp() * 1000)
+
+        for topic_partition in topic_partitions:
+            offset_for_times[topic_partition] = timestamp_ms
+
+        return cast(
+            dict[TopicPartition, Optional[OffsetAndTimestamp]],
+            consumer.offsets_for_times(offset_for_times),
+        )
+
+    # 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)

buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import Logger
 from typing import Optional
 
 from kafka import KafkaConsumer, KafkaProducer
@@ -22,8 +23,16 @@ CONSUMER_POLL_TIMEOUT_MS = 1000
 
 
 class KafkaPythonAdminTestClient(KafkaPythonAdminClient, KafkaAdminTestClient):
-    def __init__(self, *, config: KafkaConnectionConfig):
-        super().__init__(config=config)
+    def __init__(
+        self,
+        *,
+        logger: Logger,
+        connection_config: KafkaConnectionConfig,
+    ):
+        super().__init__(
+            connection_config=connection_config,
+            logger=logger,
+        )
 
     def send_message_to_topic(
         self,

buz/kafka/infrastructure/kafka_python/kafka_python_producer.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
-from typing import Generic, Optional, TypeVar
+from typing import Generic, Optional, TypeVar, cast
 
 from kafka import KafkaProducer as KafkaPythonLibraryProducer
+from kafka.producer.future import FutureRecordMetadata
 
 from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
+from buz.kafka.domain.models.kafka_supported_compression_type import KafkaSupportedCompressionType
 from buz.kafka.domain.services.kafka_producer import KafkaProducer
 from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
 from buz.kafka.infrastructure.serializers.kafka_header_serializer import KafkaHeaderSerializer
@@ -13,33 +15,55 @@ T = TypeVar("T")
 
 
 class KafkaPythonProducer(KafkaProducer, Generic[T]):
+    __kafka_producer: Optional[KafkaPythonLibraryProducer] = None
+    __SEND_TIMEOUT_SECONDS = 5
+
     def __init__(
         self,
         *,
-        config: KafkaConnectionConfig,
+        connection_config: KafkaConnectionConfig,
         byte_serializer: ByteSerializer[T],
         retries: int = 0,
         retry_backoff_ms: int = 100,
+        compression_type: Optional[KafkaSupportedCompressionType] = None,
     ) -> None:
-        self.__config = config
+        self.__connection_config = connection_config
         self.__byte_serializer = byte_serializer
         self.__header_serializer = KafkaHeaderSerializer()
+        self.__retries = retries
+        self.__retry_backoff_ms = retry_backoff_ms
+        self.__compression_type = compression_type
 
-        sasl_mechanism: Optional[str] = None
+    def _get_kafka_producer(self) -> KafkaPythonLibraryProducer:
+        if self.__kafka_producer is None:
+            sasl_mechanism = (
+                self.__connection_config.credentials.sasl_mechanism.value
+                if self.__connection_config.credentials.sasl_mechanism
+                else None
+            )
+            compression_type = self.__compression_type.value if self.__compression_type else None
 
-        if self.__config.credentials.sasl_mechanism is not None:
-            sasl_mechanism = self.__config.credentials.sasl_mechanism.value
+            self.__kafka_producer = KafkaPythonLibraryProducer(
+                client_id=self.__connection_config.client_id,
+                bootstrap_servers=self.__connection_config.bootstrap_servers,
+                security_protocol=self.__connection_config.credentials.security_protocol.value,
+                sasl_mechanism=sasl_mechanism,
+                sasl_plain_username=self.__connection_config.credentials.user,
+                sasl_plain_password=self.__connection_config.credentials.password,
+                retries=self.__retries,
+                retry_backoff_ms=self.__retry_backoff_ms,
+                compression_type=compression_type,
+            )
 
-        self.__kafka_producer = KafkaPythonLibraryProducer(
-            client_id=self.__config.client_id,
-            bootstrap_servers=self.__config.bootstrap_servers,
-            security_protocol=self.__config.credentials.security_protocol.value,
-            sasl_mechanism=sasl_mechanism,
-            sasl_plain_username=self.__config.credentials.user,
-            sasl_plain_password=self.__config.credentials.password,
-            retries=retries,
-            retry_backoff_ms=retry_backoff_ms,
-        )
+        return self.__kafka_producer
+
+    def connect(self):
+        self._get_kafka_producer()
+
+    def disconnect(self) -> None:
+        if self.__kafka_producer is not None:
+            self.__kafka_producer.close()
+            self.__kafka_producer = None
 
     def produce(
         self,
@@ -50,12 +74,17 @@ class KafkaPythonProducer(KafkaProducer, Generic[T]):
         headers: Optional[dict[str, str]] = None,
     ) -> None:
         serialized_headers = self.__header_serializer.serialize(headers) if headers is not None else None
+        kafka_producer = self._get_kafka_producer()
 
-        self.__kafka_producer.send(
-            topic=topic,
-            value=self.__byte_serializer.serialize(message),
-            headers=serialized_headers,
-            key=partition_key,
+        message_future = cast(
+            FutureRecordMetadata,
+            kafka_producer.send(
+                topic=topic,
+                value=self.__byte_serializer.serialize(message),
+                headers=serialized_headers,
+                key=partition_key,
+            ),
         )
+
         # We are forcing a flush because the task related with the send is asynchronous, and we want that the event to be sent after call produce
-        self.__kafka_producer.flush()
+        message_future.get(self.__SEND_TIMEOUT_SECONDS)

{buz-2.13.1rc8.dist-info → buz-2.14.0.dist-info}/METADATA

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

@@ -26,6 +26,7 @@ buz/command/synchronous/synced_async/__init__.py,sha256=GXPmTcVC0ouP5bvpLXqcrzmy
 buz/command/synchronous/synced_async/synced_async_command_bus.py,sha256=8tvD1zR8j9AE6AmgkYfP5wDSPNHxr1Nx2X7CC74c3Q0,459
 buz/event/__init__.py,sha256=ey3c3fY85XpcWFlmIlbpanJfxv1BZI42Ia1njAtjcEs,588
 buz/event/async_consumer.py,sha256=k6v_WqQ8A8vWJzO_sMcjU75mroA_Il9D-rE-E-pu_lM,200
+buz/event/async_event_bus.py,sha256=l627YtPplBprVO0Ccepgt4hkwtMJyI8uaqx6TzCQ9Lw,430
 buz/event/async_subscriber.py,sha256=GNenWsj1CZj1F1nJV0KQ_7L1elYToyT9K8sY7O4Gayk,248
 buz/event/async_worker.py,sha256=OR7g6cYWOWTh9DbfAfWwS6U6bZ1CDzScJHfH52PYj_k,881
 buz/event/base_async_subscriber.py,sha256=QCVSD36lR_FuX_B4R32nOZrGmq_Y24otb_GCrH_fL8k,218
@@ -36,7 +37,7 @@ buz/event/dead_letter_queue/dlq_criteria.py,sha256=hxcV-BMayKTEc5suEfQZhEYkc14H7
 buz/event/dead_letter_queue/dlq_record.py,sha256=wEa9CdWkHmxHQVwoHFjWeEU6sjNOi7X8dLr1E-gVmDc,1341
 buz/event/dead_letter_queue/dlq_repository.py,sha256=8XsXSfO2OzEq4qfQ_v0E0OExintDYI1g55Qu3PtoxKI,630
 buz/event/event.py,sha256=x1MCBydn3qk3AkvamsAwCG-nfxR9OyP4l1UNXtnhUwU,189
-buz/event/event_bus.py,sha256=DNr1cRLxYcn9qCu4_BKecpQHAx9D_PTxLnWXN2qVhFE,293
+buz/event/event_bus.py,sha256=QnvZD_bKsv628TZ58s5uLntLJCA9Ngir_YHOwb4_UaU,289
 buz/event/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/exceptions/event_not_published_exception.py,sha256=gGEiRFGdKIS-VTKg8SN54vSS10WeSkgBhlO2Gpcll_0,215
 buz/event/exceptions/event_restore_exception.py,sha256=dYHp5i1E-VCUYYhOAVYR-eJfZ3CqPpR9gm1bZ1EFXfE,245
@@ -45,10 +46,11 @@ buz/event/exceptions/term_signal_interruption_exception.py,sha256=RkRRF0v_K9Hg48
 buz/event/exceptions/worker_execution_exception.py,sha256=6mgztvXOCG_9VZ_Jptkk72kZtNWQ2CPuQ3TjXEWFE14,123
 buz/event/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/infrastructure/buz_kafka/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py,sha256=GfJ51noIkMfJ7DOQSUikphHEr6rvfvI2Np1k2mtAai4,13823
-buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py,sha256=dqQDv7taAmINE9G2geMDExbcvSlntP09_rQ0JRbc4Rw,5507
-buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py,sha256=yrEU51OBjvLjCfYJFJPxux1bcIhoTVMw1Jf0HJMWbb0,5449
-buz/event/infrastructure/buz_kafka/buz_kafka_event_bus.py,sha256=sB8Cj_yTxqe8M9PT-HR4TcR9Mr39AnkIj3mVObKAe4U,4595
+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_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
 buz/event/infrastructure/buz_kafka/consume_strategy/kafka_on_fail_strategy.py,sha256=elNeyTubDuhHsLlTtDA1Nqz2hZe12PUcO9kz8upPby8,136
@@ -57,7 +59,7 @@ buz/event/infrastructure/buz_kafka/exceptions/__init__.py,sha256=47DEQpj8HBSa-_T
 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/kafka_event_subscriber_executor.py,sha256=EyG2vsFYErWAyqxdXqSwxx5Zi_y0d6i0h05XavJMnxg,254
-buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py,sha256=gM9hBMgCpS86vg1WunUaNP_-b5rr27hXP6gAH3RQ39M,5090
+buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py,sha256=S24FMC4oEilO1kx5q1f-_p2Jl54ATQhINPwHeU_ZyME,4835
 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
@@ -66,8 +68,8 @@ buz/event/infrastructure/kombu/allowed_kombu_serializer.py,sha256=LQ6futYsInawTC
 buz/event/infrastructure/kombu/consume_strategy/__init__.py,sha256=6dnAv-bOxoDL31gQD1dErRocdJvkLHTgdqeb4S33eWc,302
 buz/event/infrastructure/kombu/consume_strategy/consume_strategy.py,sha256=Zsv7QVpZXRLYvlV2nRbSdSwT_FgEELLyzUxdT6DyX8Q,179
 buz/event/infrastructure/kombu/consume_strategy/queue_per_subscriber_consume_strategy.py,sha256=Vsa1uC7dwS3jJ-dp_lvrE-hVWnN91-ma8oVqdLuXHMo,786
-buz/event/infrastructure/kombu/kombu_consumer.py,sha256=8mvpQ6ePOrhpJFCU46xqIwX9I_fy5HXN6lbWLN2WnPQ,6440
-buz/event/infrastructure/kombu/kombu_event_bus.py,sha256=OLZXkXmHBSRCu3T3N70ZicZl4TXmFgc5cj4PT2CHDYU,4022
+buz/event/infrastructure/kombu/kombu_consumer.py,sha256=7EhNo_YZdXNpoVIuSm7Thk-Kv-wh3LtFP256g-IzljA,6483
+buz/event/infrastructure/kombu/kombu_event_bus.py,sha256=VSLBtamp-YOta4KyqmfXvDurvPiHZSL9QPCozMK3Qyw,4017
 buz/event/infrastructure/kombu/publish_strategy/__init__.py,sha256=96ssn7ydJwLXYoVyrhfGcwCpXr4_5Sl0DbN6UCoeNc8,315
 buz/event/infrastructure/kombu/publish_strategy/fanout_exchange_per_event_publish_strategy.py,sha256=Pw85A1oI-cPtzHCQTr0XHQjb7-u9LVmKR3eBIonHsUU,397
 buz/event/infrastructure/kombu/publish_strategy/publish_strategy.py,sha256=mcpXSRPbIYedt1vsoiBBAzqzR3E6o77ZzF6IOFsVRUw,309
@@ -81,6 +83,8 @@ buz/event/meta_subscriber.py,sha256=ieCOtOD2JTXizyFxisBZ4-d_4MvCmIW4BksstngV8oI,
 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
+buz/event/middleware/async_publish_middleware.py,sha256=JIxbRx7HVf_Q1iEziN_5RKGVJ-Oen_f1c3OL9QLmoxE,358
+buz/event/middleware/async_publish_middleware_chain_resolver.py,sha256=Hqj8CRZXJD6h9KuJaKl88iToOFN7BijoatoDo66En8w,1016
 buz/event/middleware/base_consume_middleware.py,sha256=9G1jsr_Wm-avsTfWAndi5_tf4WW6dSLwQ3rN0-jc7AE,651
 buz/event/middleware/base_publish_middleware.py,sha256=vtM8oA4LZjbZn4omPy-cIAUxQQwL-_Xb4ScU85DwjMU,531
 buz/event/middleware/consume_middleware.py,sha256=BCcs1LgIc5YZx5nf7nE_bMuiiXxscqBE4LqD-nd4JS0,363
@@ -105,7 +109,7 @@ buz/event/strategies/retry/max_retries_negative_exception.py,sha256=UdM5T4cxRv_a
 buz/event/strategies/retry/reject_callback.py,sha256=TnmUt0AkB2DEQMieec9TtB7IAkRHdFAFepAclbiCRns,316
 buz/event/subscriber.py,sha256=WxppO8PFP5zO-gwLZNg1DKSY_uFdsF8JgWIJa6nTTds,237
 buz/event/sync/__init__.py,sha256=uJmU80PGVNNL2HoRFXp4loQTn1VK8gLo-hMEvgVPpBQ,91
-buz/event/sync/sync_event_bus.py,sha256=4yI1gLbaS7e0DI8a6I9I_a7PJcUUe0cJ_3OP4EJmQ4Q,1407
+buz/event/sync/sync_event_bus.py,sha256=nXNJqoaWQWV3asYCAIReH2nN5AOjvJH2OFODHOrWM6M,1403
 buz/event/transactional_outbox/__init__.py,sha256=k8ZBWCi12pWKXchHfgW_Raw4sVR8XkBLuPNW9jB9X2k,1381
 buz/event/transactional_outbox/event_to_outbox_record_translator.py,sha256=oSn1iQuW-cZLvlXYIJPnSwm3JYUwGMm9f1pqnlF0cJI,534
 buz/event/transactional_outbox/fqn_to_event_mapper.py,sha256=ujcq6CfYqRJtM8f3SEEltbWN0Ru7NM5JfrbNdh4nvhQ,773
@@ -125,14 +129,18 @@ buz/event/transactional_outbox/outbox_record_validation/outbox_record_size_not_a
 buz/event/transactional_outbox/outbox_record_validation/outbox_record_validation_exception.py,sha256=rwG2f8KTfLc2xEpGXlEkWVoqf3ECUny4n5wcualiuIE,134
 buz/event/transactional_outbox/outbox_record_validation/outbox_record_validator.py,sha256=XGHTT1dH2CJOqhYYnyPJHmZsAuVXuDOeqgJzK7mRidc,328
 buz/event/transactional_outbox/outbox_record_validation/size_outbox_record_validator.py,sha256=f8sQ5IHfO4J8m5l7rS3JYUoBvx0B1EAFMRsJ0HPQKG8,2436
-buz/event/transactional_outbox/outbox_repository.py,sha256=nJ3p8jI0GmAJPLm5es6FcH4EooLM0iOH1fIdwG4_Lx0,509
-buz/event/transactional_outbox/transactional_outbox_event_bus.py,sha256=5Mv4wqbPZIJfewUdYnf3n5Fm0tIyrzLZAGYqblLNR3M,1436
+buz/event/transactional_outbox/outbox_repository.py,sha256=Sn7aWaq1G6uiKXcV09l9L1eVQ_bPUTqY-OSD12_H2jU,628
+buz/event/transactional_outbox/transactional_outbox_event_bus.py,sha256=S2VIrKCyZG8vztgBagKOJUhp2oJhbLx6oGVHPBplRZ4,1676
 buz/event/transactional_outbox/transactional_outbox_worker.py,sha256=x6kf-Oc4oYKu9S4MTcCqd3VqPNURScTReYJ3Ahx4rKA,2221
 buz/event/worker.py,sha256=BL9TXB_kyr0Avql9fIcFm3CDNnXPvZB6O6BxVwjtCdA,942
 buz/handler.py,sha256=cZqV1NDPGVZQgJ3YSBDhOQ1sdJGdUopxi57yQ6fbPvc,272
-buz/kafka/__init__.py,sha256=3rLTvjxQsZlTRfy7_XG6ojkVfxStlaS7y87oGvx5RfI,1826
+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_valid_kafka_message_exception.py,sha256=Dn6I_-eGQnOuu5WW24oKGOdKOu4EdM8ByH3DLAbz5SY,57
 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
 buz/kafka/domain/models/auto_create_topic_configuration.py,sha256=naeArywtxwTXyLzguFitBqU8nRkDo4Ttd1DjPVYJY-Q,231
 buz/kafka/domain/models/consumer_initial_offset_position.py,sha256=mhnN7LaRhqnzODV6GFewQ5TbIYwCfVbtWaSTYvbGMU0,111
 buz/kafka/domain/models/create_kafka_topic.py,sha256=Ut6_Xh5finrPlqz2Unw3EP31lR0y8c55zRp8kXxUj7U,224
@@ -142,14 +150,18 @@ buz/kafka/domain/models/kafka_connection_plain_text_credentials.py,sha256=DzhJCl
 buz/kafka/domain/models/kafka_connection_sasl_credentials.py,sha256=SG45bU8EFlV0cUObkW_a0wvfRuZU6HelqQVPVu-EV0o,591
 buz/kafka/domain/models/kafka_consumer_record.py,sha256=2oJvTBAr8jQq4FglsSgtkno29XLmxgC49O6uriKCdqw,230
 buz/kafka/domain/models/kafka_poll_record.py,sha256=Yt55L6rGM_taJ615_YyO1gBJIgpVruD0VG0rgSLXSq4,305
+buz/kafka/domain/models/kafka_supported_compression_type.py,sha256=ZEY1kPzYQlkPhEg0y2EMdZXUQ_oSHhjbGj9MIQvU09E,141
 buz/kafka/domain/models/kafka_supported_sasl_mechanisms.py,sha256=ASyDaFgseQRcUJA2kubQSdCkG6KhGmpMAzTFj5NwK5w,212
 buz/kafka/domain/models/kafka_supported_security_protocols.py,sha256=ffY2-9sOj4XIkJTSQVkqeOb4KnuqEYXISDarfDN8r9Q,161
-buz/kafka/domain/services/kafka_admin_client.py,sha256=rQdn_ZrhbC2PsbFKXEyxRjWEZBX0_WE5Mi3aKWAQsjU,708
+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_test_client.py,sha256=91l_vFIo1yhJLQQCC_OmeXZ5F429zP7Hx5g4FNllpfE,1625
-buz/kafka/domain/services/kafka_producer.py,sha256=CTiwGYwuzdJY5aeb2WFbJlyCpZ0YyhzcgKQYyogKzUM,401
+buz/kafka/domain/services/kafka_producer.py,sha256=8bLTV328orrPHcARzkc6no4vyJzrArVtCsjmSRXDjos,506
 buz/kafka/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/aiokafka/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-buz/kafka/infrastructure/aiokafka/aiokafka_consumer.py,sha256=9bzCq18xTMCNN7IKoEygdA8xQ235qIza1rU6OnMnq9o,8725
+buz/kafka/infrastructure/aiokafka/aiokafka_consumer.py,sha256=i6h4EeEyH3YdxWrQ-zQF3koni9AurdhKf0Va0K1dqBw,8695
+buz/kafka/infrastructure/aiokafka/aiokafka_producer.py,sha256=LteHKIHpT6MKplwmwsPYMsd2GWNJCzus65XDHCIdoN8,3823
 buz/kafka/infrastructure/aiokafka/rebalance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/aiokafka/rebalance/kafka_callback_rebalancer.py,sha256=3l7NkTrCt3rBktVIS73cTmCOvv6eFguoCbGMYIUfCFc,1774
 buz/kafka/infrastructure/aiokafka/translators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -163,13 +175,14 @@ buz/kafka/infrastructure/deserializers/implementations/cdc/cdc_record_bytes_to_e
 buz/kafka/infrastructure/deserializers/implementations/cdc/not_valid_cdc_message_exception.py,sha256=hgLLwTcC-C2DuJSOWUhmQsrd1bO9I1469869IqfAPOk,414
 buz/kafka/infrastructure/deserializers/implementations/json_byte_deserializer.py,sha256=L4b164-KweiQUwyRONhTMIGnAz48UPk0btLqjGOTNdk,373
 buz/kafka/infrastructure/deserializers/implementations/json_bytes_to_message_deserializer.py,sha256=YwugXkmOudMNtkVfCC4BFe3pFVpbM8rAL9bT88bZMRk,756
+buz/kafka/infrastructure/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+buz/kafka/infrastructure/interfaces/async_connection_manager.py,sha256=JbaLu5UVV2ZPRLI_FGj1ijX1QekFysPts45G-F-oBkA,217
+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/factories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-buz/kafka/infrastructure/kafka_python/factories/kafka_python_producer_factory.py,sha256=rn-ZUuzHZfAMGon_lKl7gQ-gwijW1nYOHlGTCIjfDE4,858
-buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py,sha256=mSbRnsX0sh0WXHUTR6obbTvTj_lGwYIWY8cJvY59n0k,4350
-buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py,sha256=IPwpANcS7nESo9cbLqwJPY7TfnidOshuh3DfF1UPK4Q,2817
-buz/kafka/infrastructure/kafka_python/kafka_python_producer.py,sha256=CMkpTkrC10wy574Nc9t-TKvWO-6XCgj8F5EkWlwP0-U,2275
+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_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
 buz/kafka/infrastructure/serializers/byte_serializer.py,sha256=T83sLdX9V5Oh1mzjRwHi_1DsTFI7KefFj7kmnz7JVy4,207
@@ -230,7 +243,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.13.1rc8.dist-info/LICENSE,sha256=Jytu2S-2SPEgsB0y6BF-_LUxIWY7402fl0JSh36TLZE,1062
-buz-2.13.1rc8.dist-info/METADATA,sha256=4ptRnjIHu5NspLmq0nUXRlSCplcfjYT5CgrdjHpTp9o,1620
-buz-2.13.1rc8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-buz-2.13.1rc8.dist-info/RECORD,,
+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,,