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

buz/event/async_event_bus.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import Collection
+
+from buz.event import Event
+from buz.kafka.infrastructure.interfaces.async_connection_manager import AsyncConnectionManager
+
+
+class AsyncEventBus(AsyncConnectionManager, ABC):
+    @abstractmethod
+    async def publish(self, event: Event) -> None:
+        pass
+
+    @abstractmethod
+    async def bulk_publish(self, events: Collection[Event]) -> None:
+        pass

buz/event/event_bus.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Collection
+from typing import Iterable
 
 from buz.event import Event
 
@@ -10,5 +10,5 @@ class EventBus(ABC):
         pass
 
     @abstractmethod
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         pass

buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus.py

@@ -0,0 +1,107 @@
+from logging import Logger
+from typing import Collection, Optional
+
+from buz.event import Event
+from buz.event.async_event_bus import AsyncEventBus
+from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
+from buz.event.infrastructure.buz_kafka.exceptions.kafka_event_bus_config_not_valid_exception import (
+    KafkaEventBusConfigNotValidException,
+)
+from buz.event.infrastructure.buz_kafka.publish_strategy.publish_strategy import KafkaPublishStrategy
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware
+from buz.event.middleware.async_publish_middleware_chain_resolver import AsyncPublishMiddlewareChainResolver
+from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+
+
+class AsyncBuzKafkaEventBus(AsyncEventBus):
+    def __init__(
+        self,
+        *,
+        publish_strategy: KafkaPublishStrategy,
+        producer: AsyncKafkaProducer,
+        logger: Logger,
+        kafka_admin_client: Optional[KafkaAdminClient] = None,
+        publish_middlewares: Optional[list[AsyncPublishMiddleware]] = None,
+        auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+    ):
+        self.__publish_middleware_chain_resolver = AsyncPublishMiddlewareChainResolver(publish_middlewares or [])
+        self.__publish_strategy = publish_strategy
+        self.__producer = producer
+        self.__topics_checked: dict[str, bool] = {}
+        self.__kafka_admin_client = kafka_admin_client
+        self.__auto_create_topic_configuration = auto_create_topic_configuration
+        self.__logger = logger
+        self.__check_kafka_admin_client_is_needed()
+
+    def __check_kafka_admin_client_is_needed(self) -> None:
+        if self.__kafka_admin_client is None and self.__auto_create_topic_configuration is not None:
+            raise KafkaEventBusConfigNotValidException(
+                "A KafkaAdminClient is needed to create topics when 'auto_create_topic_configuration' is set."
+            )
+
+    async def publish(self, event: Event) -> None:
+        await self.__publish_middleware_chain_resolver.resolve(event, self.__perform_publish)
+
+    async def __perform_publish(self, event: Event) -> None:
+        try:
+            topic = self.__publish_strategy.get_topic(event)
+
+            if self.__auto_create_topic_configuration is not None and self.__is_topic_created(topic) is False:
+                try:
+                    self.__logger.info(f"Creating missing topic: {topic}..")
+                    self.__get_kafka_admin_client().create_topics(
+                        topics=[
+                            CreateKafkaTopic(
+                                name=topic,
+                                partitions=self.__auto_create_topic_configuration.partitions,
+                                replication_factor=self.__auto_create_topic_configuration.replication_factor,
+                                configs=self.__auto_create_topic_configuration.configs,
+                            )
+                        ]
+                    )
+                    self.__logger.info(f"Created missing topic: {topic}")
+                    self.__topics_checked[topic] = True
+                except KafkaTopicsAlreadyCreatedException:
+                    pass
+
+            headers = self.__get_event_headers(event)
+            await self.__producer.produce(
+                message=event,
+                headers=headers,
+                topic=topic,
+            )
+        except Exception as exc:
+            raise EventNotPublishedException(event) from exc
+
+    def __get_kafka_admin_client(self) -> KafkaAdminClient:
+        if self.__kafka_admin_client is None:
+            raise KafkaEventBusConfigNotValidException("KafkaAdminClient is not set.")
+        return self.__kafka_admin_client
+
+    def __is_topic_created(self, topic: str) -> bool:
+        is_topic_created = self.__topics_checked.get(topic, None)
+
+        if is_topic_created is not None:
+            return is_topic_created
+
+        is_topic_created = self.__get_kafka_admin_client().is_topic_created(topic)
+        self.__topics_checked[topic] = is_topic_created
+
+        return is_topic_created
+
+    async def bulk_publish(self, events: Collection[Event]) -> None:
+        for event in events:
+            await self.publish(event)
+
+    def __get_event_headers(self, event: Event) -> dict:
+        return {"id": event.id}
+
+    async def connect(self) -> None:
+        await self.__producer.connect()
+
+    async def disconnect(self) -> None:
+        await self.__producer.disconnect()

buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py

@@ -17,11 +17,9 @@ from buz.event.infrastructure.buz_kafka.consume_strategy.consume_strategy import
 from buz.event.infrastructure.buz_kafka.kafka_event_subscriber_executor import KafkaEventSubscriberExecutor
 from buz.event.infrastructure.models.consuming_task import ConsumingTask
 from buz.event.meta_subscriber import MetaSubscriber
-from buz.kafka import (
-    KafkaConnectionConfig,
-    ConsumerInitialOffsetPosition,
-)
 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.models.kafka_poll_record import KafkaPollRecord
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 from buz.kafka.infrastructure.aiokafka.aiokafka_consumer import AIOKafkaConsumer
@@ -107,12 +105,9 @@ class BaseBuzAIOKafkaAsyncConsumer(AsyncConsumer):
 
         if self.__exceptions_are_thrown(worker_errors):
             consume_events_exception, polling_task_exception = worker_errors
-            if consume_events_exception:
-                self._logger.exception(consume_events_exception)
-            if polling_task_exception:
-                self._logger.exception(polling_task_exception)
-
-            raise WorkerExecutionException("The worker was closed by an unexpected exception")
+            raise WorkerExecutionException(
+                "The worker was closed by an unexpected exception"
+            ) from consume_events_exception or polling_task_exception
 
     async def __run_worker(self) -> tuple[Optional[Exception], Optional[Exception]]:
         consume_events_task = create_task(self.__consume_events_task())

buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py

@@ -15,11 +15,10 @@ 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 import (
-    KafkaConnectionConfig,
-    ConsumerInitialOffsetPosition,
-)
+
 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.bytes_to_message_deserializer import BytesToMessageDeserializer
 from buz.kafka.infrastructure.deserializers.implementations.json_bytes_to_message_deserializer import (

buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py

@@ -15,11 +15,9 @@ from buz.event.meta_subscriber import MetaSubscriber
 from buz.event.middleware.consume_middleware import ConsumeMiddleware
 from buz.event.strategies.retry.consume_retrier import ConsumeRetrier
 from buz.event.strategies.retry.reject_callback import RejectCallback
-from buz.kafka import (
-    KafkaConnectionConfig,
-    ConsumerInitialOffsetPosition,
-)
 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.bytes_to_message_deserializer import BytesToMessageDeserializer
 from buz.kafka.infrastructure.deserializers.implementations.json_bytes_to_message_deserializer import (

buz/event/infrastructure/buz_kafka/buz_kafka_event_bus.py

@@ -1,5 +1,5 @@
 from logging import Logger
-from typing import Collection, Optional
+from typing import Optional, Iterable
 
 from buz.event import Event, EventBus
 from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
@@ -11,13 +11,11 @@ from buz.event.middleware import (
     PublishMiddleware,
 )
 from buz.event.middleware.publish_middleware_chain_resolver import PublishMiddlewareChainResolver
-from buz.kafka import (
-    KafkaPythonProducer,
-)
 from buz.kafka.domain.exceptions.topic_already_created_exception import KafkaTopicsAlreadyCreatedException
 from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.domain.services.kafka_producer import KafkaProducer
 
 
 class BuzKafkaEventBus(EventBus):
@@ -25,7 +23,7 @@ class BuzKafkaEventBus(EventBus):
         self,
         *,
         publish_strategy: KafkaPublishStrategy,
-        producer: KafkaPythonProducer,
+        producer: KafkaProducer,
         logger: Logger,
         kafka_admin_client: Optional[KafkaAdminClient] = None,
         publish_middlewares: Optional[list[PublishMiddleware]] = None,
@@ -96,7 +94,7 @@ class BuzKafkaEventBus(EventBus):
 
         return is_topic_created
 
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         for event in events:
             self.publish(event)
 

buz/event/infrastructure/buz_kafka/kafka_event_sync_subscriber_executor.py

@@ -81,13 +81,13 @@ class KafkaEventSyncSubscriberExecutor(KafkaEventSubscriberExecutor):
                 return
             except Exception as exception:
                 self.__logger.warning(f"Event {event.id} could not be consumed by the subscriber {subscriber.fqn}")
-                self.__logger.error(exception, exc_info=True)
-
                 if self.__should_retry(event, subscriber) is True:
                     self.__register_retry(event, subscriber)
                     time.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/kombu/kombu_consumer.py

@@ -135,6 +135,7 @@ class KombuConsumer(ConsumerMixin, Consumer):
             message.requeue()
             return
 
+        self.__logger.exception(exception)
         self.__reject_message(message, event, subscribers, exception)
 
     def __reject_message(

buz/event/infrastructure/kombu/kombu_event_bus.py

@@ -1,21 +1,20 @@
 from dataclasses import asdict
-from typing import Collection, Optional
+from typing import Optional, Iterable
 
 from kombu import Connection, Exchange, Producer
 from kombu.entity import PERSISTENT_DELIVERY_MODE
 
 from buz.event import Event, EventBus
-from buz.event.infrastructure.kombu.publish_strategy import PublishStrategy
+from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
 from buz.event.infrastructure.kombu.allowed_kombu_serializer import AllowedKombuSerializer
+from buz.event.infrastructure.kombu.publish_strategy import PublishStrategy
+from buz.event.infrastructure.kombu.retry_strategy.publish_retry_policy import PublishRetryPolicy
+from buz.event.infrastructure.kombu.retry_strategy.simple_publish_retry_policy import SimplePublishRetryPolicy
 from buz.event.middleware import (
     PublishMiddleware,
     PublishMiddlewareChainResolver,
 )
 
-from buz.event.exceptions.event_not_published_exception import EventNotPublishedException
-from buz.event.infrastructure.kombu.retry_strategy.publish_retry_policy import PublishRetryPolicy
-from buz.event.infrastructure.kombu.retry_strategy.simple_publish_retry_policy import SimplePublishRetryPolicy
-
 
 class KombuEventBus(EventBus):
     def __init__(
@@ -96,6 +95,6 @@ class KombuEventBus(EventBus):
     def __get_headers(self, event: Event) -> dict:
         return {"fqn": event.fqn()}
 
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         for event in events:
             self.publish(event)

buz/event/middleware/async_publish_middleware.py

@@ -0,0 +1,13 @@
+from abc import abstractmethod
+from typing import Awaitable, Callable
+
+from buz.event import Event
+from buz.middleware import Middleware
+
+AsyncPublishCallable = Callable[[Event], Awaitable[None]]
+
+
+class AsyncPublishMiddleware(Middleware):
+    @abstractmethod
+    async def on_publish(self, event: Event, publish: AsyncPublishCallable) -> None:
+        pass

buz/event/middleware/async_publish_middleware_chain_resolver.py

@@ -0,0 +1,22 @@
+from buz.event import Event
+from buz.event.middleware.async_publish_middleware import AsyncPublishCallable, AsyncPublishMiddleware
+from buz.middleware import MiddlewareChainBuilder
+
+
+class AsyncPublishMiddlewareChainResolver:
+    def __init__(self, middlewares: list[AsyncPublishMiddleware]):
+        self.__middlewares = middlewares
+        self.__middleware_chain_builder: MiddlewareChainBuilder[
+            AsyncPublishCallable, AsyncPublishMiddleware
+        ] = MiddlewareChainBuilder(middlewares)
+
+    async def resolve(self, event: Event, publish: AsyncPublishCallable) -> None:
+        chain_callable: AsyncPublishCallable = self.__middleware_chain_builder.get_chain_callable(
+            publish, self.__get_middleware_callable
+        )
+        await chain_callable(event)
+
+    def __get_middleware_callable(
+        self, middleware: AsyncPublishMiddleware, publish_callable: AsyncPublishCallable
+    ) -> AsyncPublishCallable:
+        return lambda event: middleware.on_publish(event, publish_callable)

buz/event/sync/sync_event_bus.py

@@ -1,4 +1,4 @@
-from typing import Collection, Optional
+from typing import Optional, Iterable
 
 from buz.event import Event, EventBus, Subscriber
 from buz.event.middleware import (
@@ -32,6 +32,6 @@ class SyncEventBus(EventBus):
     def __perform_consume(self, event: Event, subscriber: Subscriber) -> None:
         subscriber.consume(event)
 
-    def bulk_publish(self, events: Collection[Event]) -> None:
+    def bulk_publish(self, events: Iterable[Event]) -> None:
         for event in events:
             self.publish(event)

buz/event/transactional_outbox/outbox_repository.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Sequence
+from typing import Sequence, Iterable
 
 from buz.event.transactional_outbox import OutboxRecord
 from buz.event.transactional_outbox import OutboxCriteria
@@ -10,6 +10,10 @@ class OutboxRepository(ABC):
     def save(self, outbox_record: OutboxRecord) -> None:
         pass
 
+    @abstractmethod
+    def bulk_create(self, outbox_records: Iterable[OutboxRecord]) -> None:
+        pass
+
     @abstractmethod
     def find(self, criteria: OutboxCriteria) -> Sequence[OutboxRecord]:
         pass

buz/event/transactional_outbox/transactional_outbox_event_bus.py

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

buz/kafka/__init__.py

@@ -1,18 +1,32 @@
+from buz.kafka.domain.exceptions.not_all_partition_assigned_exception import NotAllPartitionAssignedException
+from buz.kafka.domain.exceptions.not_valid_kafka_message_exception import NotValidKafkaMessageException
 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.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.models.kafka_connection_credentials import KafkaConnectionCredentials
+from buz.kafka.domain.models.kafka_connection_plain_text_credentials import KafkaConnectionPlainTextCredentials
+from buz.kafka.domain.models.kafka_connection_sasl_credentials import KafkaConnectionSaslCredentials
 from buz.kafka.domain.models.kafka_consumer_record import KafkaConsumerRecord
+from buz.kafka.domain.models.kafka_supported_sasl_mechanisms import KafkaSupportedSaslMechanisms
 from buz.kafka.domain.models.kafka_supported_security_protocols import KafkaSupportedSecurityProtocols
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
 from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
 from buz.kafka.domain.services.kafka_admin_test_client import KafkaAdminTestClient
 from buz.kafka.domain.services.kafka_producer import KafkaProducer
-from buz.kafka.infrastructure.kafka_python.factories.kafka_python_producer_factory import KafkaPythonProducerFactory
+from buz.kafka.infrastructure.aiokafka.aiokafka_producer import AIOKafkaProducer
 from buz.kafka.infrastructure.kafka_python.kafka_python_admin_client import KafkaPythonAdminClient
 from buz.kafka.infrastructure.kafka_python.kafka_python_admin_test_client import KafkaPythonAdminTestClient
 from buz.kafka.infrastructure.kafka_python.kafka_python_producer import KafkaPythonProducer
 from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
 from buz.kafka.infrastructure.serializers.implementations.json_byte_serializer import JSONByteSerializer
+from buz.kafka.domain.models.kafka_supported_compression_type import KafkaSupportedCompressionType
+from buz.event.infrastructure.buz_kafka.exceptions.kafka_event_bus_config_not_valid_exception import (
+    KafkaEventBusConfigNotValidException,
+)
+from buz.event.infrastructure.buz_kafka.async_buz_kafka_event_bus import AsyncBuzKafkaEventBus
+from buz.event.infrastructure.buz_kafka.buz_kafka_event_bus import BuzKafkaEventBus
 
 
 __all__ = [
@@ -22,7 +36,6 @@ __all__ = [
     "KafkaAdminTestClient",
     "KafkaPythonAdminClient",
     "KafkaPythonAdminTestClient",
-    "KafkaPythonProducerFactory",
     "KafkaTopicsAlreadyCreatedException",
     "KafkaConsumerRecord",
     "CreateKafkaTopic",
@@ -31,4 +44,17 @@ __all__ = [
     "ByteSerializer",
     "JSONByteSerializer",
     "ConsumerInitialOffsetPosition",
+    "KafkaSupportedCompressionType",
+    "KafkaEventBusConfigNotValidException",
+    "AsyncBuzKafkaEventBus",
+    "BuzKafkaEventBus",
+    "AutoCreateTopicConfiguration",
+    "NotAllPartitionAssignedException",
+    "NotValidKafkaMessageException",
+    "TopicNotFoundException",
+    "KafkaConnectionCredentials",
+    "KafkaConnectionPlainTextCredentials",
+    "KafkaConnectionSaslCredentials",
+    "KafkaSupportedSaslMechanisms",
+    "AIOKafkaProducer",
 ]

buz/kafka/domain/models/kafka_supported_compression_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class KafkaSupportedCompressionType(Enum):
+    GZIP = "gzip"
+    SNAPPY = "snappy"
+    LZ4 = "lz4"
+    ZSTD = "zstd"

buz/kafka/domain/services/async_kafka_producer.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from abc import abstractmethod, ABC
+from typing import Generic, Optional, TypeVar
+
+from buz.kafka.infrastructure.interfaces.async_connection_manager import AsyncConnectionManager
+
+T = TypeVar("T")
+
+
+class AsyncKafkaProducer(AsyncConnectionManager, ABC, Generic[T]):
+    @abstractmethod
+    async def produce(
+        self,
+        *,
+        topic: str,
+        message: T,
+        partition_key: Optional[str] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> None:
+        pass

buz/kafka/domain/services/kafka_admin_client.py

@@ -5,11 +5,12 @@ from datetime import datetime
 from typing import Sequence
 
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
+from buz.kafka.infrastructure.interfaces.connection_manager import ConnectionManager
 
 DEFAULT_NUMBER_OF_MESSAGES_TO_POLLING = 999
 
 
-class KafkaAdminClient(ABC):
+class KafkaAdminClient(ConnectionManager, ABC):
     @abstractmethod
     def create_topics(
         self,

buz/kafka/domain/services/kafka_producer.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 from abc import abstractmethod, ABC
 from typing import Generic, Optional, TypeVar
 
+from buz.kafka.infrastructure.interfaces.connection_manager import ConnectionManager
+
 T = TypeVar("T")
 
 
-class KafkaProducer(ABC, Generic[T]):
+class KafkaProducer(ConnectionManager, ABC, Generic[T]):
     @abstractmethod
     def produce(
         self,

buz/kafka/infrastructure/aiokafka/aiokafka_consumer.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from logging import Logger
-from ssl import SSLContext
 from typing import Awaitable, Callable, Optional, Sequence, cast
 
 from aiokafka import AIOKafkaConsumer as AIOKafkaNativeConsumer, TopicPartition, OffsetAndMetadata
@@ -69,21 +68,25 @@ class AIOKafkaConsumer:
             )
 
     def __generate_consumer(self) -> AIOKafkaNativeConsumer:
-        sasl_mechanism: Optional[str] = None
-        ssl_context: Optional[SSLContext] = None
-
         if self.__auto_create_topic_configuration is not None:
             self.__ensure_topics_are_created(self.__auto_create_topic_configuration)
 
-        if self.__connection_config.credentials.sasl_mechanism is not None:
-            sasl_mechanism = self.__connection_config.credentials.sasl_mechanism.value
+        sasl_mechanism = (
+            self.__connection_config.credentials.sasl_mechanism.value
+            if self.__connection_config.credentials.sasl_mechanism
+            else "PLAIN"
+        )
+
+        ssl_context = (
+            create_ssl_context()
+            if self.__connection_config.credentials.security_protocol == KafkaSupportedSecurityProtocols.SASL_SSL
+            else None
+        )
 
-        if self.__connection_config.credentials.security_protocol == KafkaSupportedSecurityProtocols.SASL_SSL:
-            ssl_context = create_ssl_context()
         consumer = AIOKafkaNativeConsumer(
             None,
             ssl_context=ssl_context,
-            bootstrap_servers=self.__connection_config.bootstrap_servers,
+            bootstrap_servers=",".join(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,

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

@@ -30,18 +30,19 @@ 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,
         *,
         logger: Logger,
-        config: KafkaConnectionConfig,
+        connection_config: KafkaConnectionConfig,
         cache_ttl_seconds: int = 0,
     ):
         self._logger = logger
-        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.__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:
@@ -54,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,
         *,
@@ -70,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)
@@ -94,7 +117,7 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         self,
     ) -> set[str]:
         return self.__resolve_cached_property(
-            TOPIC_CACHE_KEY, 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:
@@ -110,7 +133,7 @@ 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)
@@ -123,18 +146,18 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         *,
         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,

buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py

@@ -27,10 +27,10 @@ class KafkaPythonAdminTestClient(KafkaPythonAdminClient, KafkaAdminTestClient):
         self,
         *,
         logger: Logger,
-        config: KafkaConnectionConfig,
+        connection_config: KafkaConnectionConfig,
     ):
         super().__init__(
-            config=config,
+            connection_config=connection_config,
             logger=logger,
         )
 

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.1rc9.dist-info → buz-2.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.13.1rc9
+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.1rc9.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=IHossnUlynEFkUvwcTyxHVwGUyDSlfH1t4UX1S09Dic,4846
+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,16 +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
@@ -144,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=tF0WJW-eCzgskpuhxzXOU5fcTIFqK0fWzMu7yTEzAdo,1118
+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
@@ -165,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=KjJciScn-WlnfF79-ZeWZWUzQKZkDiPZ_93oOwmDyiQ,8218
-buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py,sha256=g_xGakCMbv9ouzUyemmcrFQqUfKlnMWNnEPE4L9cxOI,2949
-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
@@ -232,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.1rc9.dist-info/LICENSE,sha256=Jytu2S-2SPEgsB0y6BF-_LUxIWY7402fl0JSh36TLZE,1062
-buz-2.13.1rc9.dist-info/METADATA,sha256=JDL25KyxeqMBWzF9LdEzga2tqIDmQBRGqn6ToEeZfyA,1620
-buz-2.13.1rc9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-buz-2.13.1rc9.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,,

buz/kafka/infrastructure/kafka_python/factories/kafka_python_producer_factory.py

@@ -1,20 +0,0 @@
-from buz.kafka.domain.models.kafka_connection_config import KafkaConnectionConfig
-from buz.kafka.infrastructure.kafka_python.kafka_python_producer import KafkaPythonProducer
-from buz.kafka.infrastructure.serializers.byte_serializer import ByteSerializer
-from buz.kafka.infrastructure.serializers.implementations.json_byte_serializer import JSONByteSerializer
-
-
-class KafkaPythonProducerFactory:
-    def __init__(
-        self,
-        kafka_connection_config: KafkaConnectionConfig,
-        byte_serializer: ByteSerializer = JSONByteSerializer(),
-    ):
-        self._kafka_connection_config = kafka_connection_config
-        self._byte_serializer = byte_serializer
-
-    def build(self) -> KafkaPythonProducer:
-        return KafkaPythonProducer(
-            config=self._kafka_connection_config,
-            byte_serializer=self._byte_serializer,
-        )