buz 2.24.0__py3-none-any.whl → 2.26.0__py3-none-any.whl

buz/event/async_event_bus_with_publish_result.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from typing import Collection
+
+from buz.event import Event
+from buz.event.event_bus_publish_result import EventBusPublishResult
+from buz.kafka.infrastructure.interfaces.async_connection_manager import AsyncConnectionManager
+
+
+class AsyncEventBusWithPublishResult(AsyncConnectionManager, ABC):
+    """
+    Event bus with publish result tracking capabilities.
+
+    Unlike AsyncEventBus which returns None, this event bus returns
+    EventBusPublishResult to report which events succeeded and which failed.
+
+    This enables:
+    - Partial success tracking
+    - Fail-fast behavior with precise tracking
+    - Application-level retry control
+    - Better observability
+    """
+
+    @abstractmethod
+    async def publish(self, event: Event) -> None:
+        pass
+
+    @abstractmethod
+    async def bulk_publish(self, events: Collection[Event]) -> EventBusPublishResult:
+        """
+        Publish multiple events and return detailed results.
+
+        Returns:
+            EventBusPublishResult containing published_events and failed_events
+        """
+        pass

buz/event/event.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass
 
-from buz import Message
+from buz.message import Message, MessageId
+
+EventId = MessageId
 
 
 @dataclass(frozen=True)

buz/event/event_bus_publish_result.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import Collection
+
+from buz.event import Event
+
+
+@dataclass
+class EventBusPublishResult:
+    published_events: Collection[Event]
+    failed_events: Collection[Event]

buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus.py

@@ -3,21 +3,24 @@ 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.base_async_buz_kafka_event_bus import BaseAsyncBuzKafkaEventBus
 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
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
 
 
-class AsyncBuzKafkaEventBus(AsyncEventBus):
+class AsyncBuzKafkaEventBus(BaseAsyncBuzKafkaEventBus, AsyncEventBus):
+    """
+    Async Kafka event bus with simple behavior (consistent with sync version).
+
+    - Returns None from bulk_publish
+    - Raises exception on failure
+    - No retry logic
+    """
+
     def __init__(
         self,
         *,
@@ -27,82 +30,19 @@ class AsyncBuzKafkaEventBus(AsyncEventBus):
         kafka_admin_client: Optional[KafkaAdminClient] = None,
         publish_middlewares: Optional[list[AsyncPublishMiddleware]] = None,
         auto_create_topic_configuration: Optional[AutoCreateTopicConfiguration] = None,
+        partition_key_generator: Optional[PartitionKeySerializer] = 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,
-                partition_key=event.partition_key(),
-            )
-        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
+        super().__init__(
+            publish_strategy=publish_strategy,
+            producer=producer,
+            logger=logger,
+            kafka_admin_client=kafka_admin_client,
+            publish_middlewares=publish_middlewares,
+            auto_create_topic_configuration=auto_create_topic_configuration,
+            partition_key_generator=partition_key_generator,
+        )
 
     async def bulk_publish(self, events: Collection[Event]) -> None:
+        """Publish all events sequentially. Raises exception on first failure."""
         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/async_buz_kafka_event_bus_with_publish_result.py

@@ -0,0 +1,80 @@
+from logging import Logger
+from typing import Collection, Optional
+
+from buz.event import Event
+from buz.event.async_event_bus_with_publish_result import AsyncEventBusWithPublishResult
+from buz.event.event_bus_publish_result import EventBusPublishResult
+from buz.event.infrastructure.buz_kafka.base_async_buz_kafka_event_bus import BaseAsyncBuzKafkaEventBus
+from buz.event.infrastructure.buz_kafka.publish_strategy.publish_strategy import KafkaPublishStrategy
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware
+from buz.kafka.domain.models.auto_create_topic_configuration import AutoCreateTopicConfiguration
+from buz.kafka.domain.services.async_kafka_producer import AsyncKafkaProducer
+from buz.kafka.domain.services.kafka_admin_client import KafkaAdminClient
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
+
+
+class AsyncBuzKafkaEventBusWithPublishResult(BaseAsyncBuzKafkaEventBus, AsyncEventBusWithPublishResult):
+    """
+    Kafka event bus with publish result tracking and fail-fast behavior.
+
+    Features:
+    - Returns EventBusPublishResult with published/failed events
+    - Fail-fast behavior (stops on first failure)
+    - Partial success tracking for external state management
+    """
+
+    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,
+        partition_key_generator: Optional[PartitionKeySerializer] = None,
+    ):
+        super().__init__(
+            publish_strategy=publish_strategy,
+            producer=producer,
+            logger=logger,
+            kafka_admin_client=kafka_admin_client,
+            publish_middlewares=publish_middlewares,
+            auto_create_topic_configuration=auto_create_topic_configuration,
+            partition_key_generator=partition_key_generator,
+        )
+
+    async def bulk_publish(self, events: Collection[Event]) -> EventBusPublishResult:
+        """
+        Publish events one by one with fail-fast behavior.
+
+        Publishes events sequentially. If any event fails, stops immediately and returns the result with:
+        - published_events: All events successfully published before the failure
+        - failed_events: The first event that failed (only one event)
+
+        This allows the caller to track which events were sent and which were not,
+        enabling proper state management in external systems.
+
+        Note: Kafka automatically handles partition assignment based on partition_key.
+        Events with the same partition_key will go to the same partition and maintain order.
+
+        Returns:
+            EventBusPublishResult with published_events and failed_events
+        """
+        published_events: list[Event] = []
+        failed_events: list[Event] = []
+
+        # FAIL-FAST: Stop on first failure
+        for event in events:
+            try:
+                await self.publish(event)
+                published_events.append(event)
+            except Exception as exc:
+                self._logger.error(f"Failed to publish event {event.id}. Error: {exc}")
+                failed_events.append(event)
+                break
+
+        return EventBusPublishResult(
+            published_events=published_events,
+            failed_events=failed_events,
+        )

buz/event/infrastructure/buz_kafka/base_async_buz_kafka_event_bus.py

@@ -0,0 +1,118 @@
+from logging import Logger
+from typing import Optional
+
+from buz.event import Event
+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
+from buz.kafka.infrastructure.serializers.implementations.cdc_partition_key_serializer import CDCPartitionKeySerializer
+from buz.kafka.infrastructure.serializers.partitiion_key_generator import PartitionKeySerializer
+
+
+class BaseAsyncBuzKafkaEventBus:
+    """
+    Base class for async Kafka event buses with common functionality.
+
+    Provides:
+    - Event publishing with middleware support
+    - Topic auto-creation
+    - Partition key generation
+    - Connection management
+    """
+
+    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,
+        partition_key_generator: Optional[PartitionKeySerializer] = 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._partition_key_generator: PartitionKeySerializer = partition_key_generator or CDCPartitionKeySerializer()
+        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:
+        """Publish a single event through the middleware chain."""
+        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,
+                partition_key=self._partition_key_generator.generate_key(event),
+            )
+        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
+
+    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/middleware/__init__.py

@@ -1,10 +1,12 @@
 from buz.event.middleware.base_async_consume_middleware import BaseAsyncConsumeMiddleware
+from buz.event.middleware.base_async_publish_middleware import BaseAsyncPublishMiddleware
 from buz.event.middleware.publish_middleware import PublishMiddleware, PublishCallable
 from buz.event.middleware.base_publish_middleware import BasePublishMiddleware
 from buz.event.middleware.publish_middleware_chain_resolver import PublishMiddlewareChainResolver
 from buz.event.middleware.consume_middleware import ConsumeMiddleware, ConsumeCallable
 from buz.event.middleware.base_consume_middleware import BaseConsumeMiddleware
 from buz.event.middleware.consume_middleware_chain_resolver import ConsumeMiddlewareChainResolver
+from buz.event.middleware.async_publish_middleware import AsyncPublishMiddleware, AsyncPublishCallable
 
 __all__ = [
     "PublishMiddleware",
@@ -16,4 +18,7 @@ __all__ = [
     "BaseConsumeMiddleware",
     "ConsumeMiddlewareChainResolver",
     "BaseAsyncConsumeMiddleware",
+    "BaseAsyncPublishMiddleware",
+    "AsyncPublishMiddleware",
+    "AsyncPublishCallable",
 ]

buz/event/middleware/base_async_publish_middleware.py

@@ -0,0 +1,27 @@
+from abc import abstractmethod
+
+from buz.event import Event
+from buz.event.middleware.async_publish_middleware import AsyncPublishCallable, AsyncPublishMiddleware
+
+
+class BaseAsyncPublishMiddleware(AsyncPublishMiddleware):
+    """
+    Base class for async publish middlewares with before/after hooks.
+    Provides a template pattern for middleware that need to execute logic
+    before and after event publishing.
+    """
+
+    async def on_publish(self, event: Event, publish: AsyncPublishCallable) -> None:
+        await self._before_on_publish(event)
+        await publish(event)
+        await self._after_on_publish(event)
+
+    @abstractmethod
+    async def _before_on_publish(self, event: Event) -> None:
+        """Hook executed before publishing the event."""
+        pass
+
+    @abstractmethod
+    async def _after_on_publish(self, event: Event) -> None:
+        """Hook executed after publishing the event."""
+        pass

buz/kafka/__init__.py

@@ -22,10 +22,10 @@ from buz.kafka.infrastructure.kafka_python.kafka_python_producer import KafkaPyt
 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
 
 
@@ -46,7 +46,6 @@ __all__ = [
     "ConsumerInitialOffsetPosition",
     "KafkaSupportedCompressionType",
     "KafkaEventBusConfigNotValidException",
-    "AsyncBuzKafkaEventBus",
     "BuzKafkaEventBus",
     "AutoCreateTopicConfiguration",
     "NotAllPartitionAssignedException",

buz/kafka/domain/services/kafka_admin_client.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from abc import abstractmethod, ABC
 from datetime import datetime
-from typing import Sequence, Any
+from typing import Sequence, Any, Optional
 
 from buz.kafka.domain.models.create_kafka_topic import CreateKafkaTopic
 from buz.kafka.infrastructure.interfaces.connection_manager import ConnectionManager
@@ -63,6 +63,7 @@ class KafkaAdminClient(ConnectionManager, ABC):
         *,
         topic: str,
         new_number_of_partitions: int,
+        consumer_groups_to_ignore: Optional[set[str]] = None,
     ) -> None:
         pass
 

buz/kafka/infrastructure/aiokafka/aiokafka_producer.py

@@ -52,6 +52,7 @@ class AIOKafkaProducer(AsyncKafkaProducer, Generic[T]):
         self.__kafka_producer = NativeAIOKafkaProducer(
             client_id=self.__connection_config.client_id,
             bootstrap_servers=",".join(self.__connection_config.bootstrap_servers),
+            security_protocol=self.__connection_config.credentials.security_protocol.value,
             sasl_mechanism=sasl_mechanism,
             ssl_context=ssl_context,
             sasl_plain_username=self.__connection_config.credentials.user,
@@ -91,8 +92,3 @@ class AIOKafkaProducer(AsyncKafkaProducer, Generic[T]):
             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/kafka_python/kafka_python_admin_client.py

@@ -271,6 +271,7 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         *,
         topic: str,
         new_number_of_partitions: int,
+        consumer_groups_to_ignore: Optional[set[str]] = None,
     ) -> None:
         self._logger.info(
             f'Increasing topic "{topic}" partitions: Verifying the new number of partitions "{new_number_of_partitions}"'
@@ -290,6 +291,10 @@ class KafkaPythonAdminClient(KafkaAdminClient):
         self._logger.info(f'Increasing topic "{topic}" partitions: Extracting related consumer groups')
         related_consumer_groups = self.__get_consumer_groups_related_to_a_topic(topic_partitions)
 
+        if consumer_groups_to_ignore:
+            consumer_groups_to_ignore_set = set[str](consumer_groups_to_ignore)
+            related_consumer_groups = related_consumer_groups - consumer_groups_to_ignore_set
+
         self._logger.info(
             f'Increasing topic "{topic}" partitions: The following consumer groups will be updated:"{related_consumer_groups}"'
         )

buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py

@@ -79,8 +79,7 @@ class KafkaPythonAdminTestClient(KafkaPythonAdminClient, KafkaAdminTestClient):
         )
 
         consumer.close()
-
-        topic_records = records[0] if len(records) > 0 else []
+        topic_records = list(sum(records, []))
 
         return topic_records
 

buz/message.py

@@ -3,7 +3,7 @@ from dataclasses import field, dataclass
 from datetime import datetime
 from inspect import signature, Parameter
 from types import MappingProxyType
-from typing import Any, ClassVar, get_origin, get_args, Union
+from typing import Any, ClassVar, NewType, get_origin, get_args, Union
 from typing_extensions import Self
 
 from uuid_utils.compat import uuid7
@@ -11,6 +11,9 @@ from uuid_utils.compat import uuid7
 from buz.metadata import Metadata
 
 
+MessageId = NewType("MessageId", str)
+
+
 @dataclass(frozen=True)
 class Message(ABC):
     DATE_TIME_FORMAT: ClassVar[str] = "%Y-%m-%d %H:%M:%S.%f"

{buz-2.24.0.dist-info → buz-2.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buz
-Version: 2.24.0
+Version: 2.26.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.24.0.dist-info → buz-2.26.0.dist-info}/RECORD

@@ -27,6 +27,7 @@ buz/command/synchronous/synced_async/synced_async_command_bus.py,sha256=8tvD1zR8
 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_event_bus_with_publish_result.py,sha256=_pPhjkVcu9lYfAu6Xysz8Us4TmH2FpGphlpnN7cGsHM,1098
 buz/event/async_subscriber.py,sha256=FNW5qtPlImcw2i7Ic1VcSpeai0RyPFAx4yRUn_NmpwQ,357
 buz/event/async_worker.py,sha256=OR7g6cYWOWTh9DbfAfWwS6U6bZ1CDzScJHfH52PYj_k,881
 buz/event/base_async_subscriber.py,sha256=66qxsFgBSSc4-dG0YsjkvYFFKOOIDA9nP8NuZ7kN2tw,362
@@ -36,8 +37,9 @@ buz/event/dead_letter_queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 buz/event/dead_letter_queue/dlq_criteria.py,sha256=hxcV-BMayKTEc5suEfQZhEYkc14H7kZo_4YfDzcJTTY,290
 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=Fz23ehyHyAsS5IN3mEElzArsAefs0GNz-vLIu3bpquk,254
+buz/event/event.py,sha256=zs1cL-zu6lkLFKVn8_DPqH8R0JiQaPqubz-x9p_VUHg,294
 buz/event/event_bus.py,sha256=QnvZD_bKsv628TZ58s5uLntLJCA9Ngir_YHOwb4_UaU,289
+buz/event/event_bus_publish_result.py,sha256=ca13xIPND2_wIcUk16enyNUpRLEH-yOushhqz9Td7cg,212
 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
@@ -46,7 +48,9 @@ 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/async_buz_kafka_event_bus.py,sha256=kxqXCf80LgQiB464jA9TENejT5FlGT7mRZsy0BsPctk,4966
+buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus.py,sha256=UMWkG8XzFo4np5YayWqFzc212rcFpfmeCoad2rRJZDo,2106
+buz/event/infrastructure/buz_kafka/async_buz_kafka_event_bus_with_publish_result.py,sha256=hWyQW5oaxtPd4ts4AeAhBZiYnAgaef4SEzqMuV4GNg8,3556
+buz/event/infrastructure/buz_kafka/base_async_buz_kafka_event_bus.py,sha256=XPmfQ4qBkEcyrA_NDlQDXshN27NRCyV2KgPFCTUbM7s,5457
 buz/event/infrastructure/buz_kafka/base_buz_aiokafka_async_consumer.py,sha256=7ZhaKaFXBpD3HVkuQMpAJvY8lfy7__1wxftLIwCmnMQ,21284
 buz/event/infrastructure/buz_kafka/buz_aiokafka_async_consumer.py,sha256=GmmuAZboDkrpNOLF8cE_F0t4I7ZnMiGsiGw4SYIvKGc,7303
 buz/event/infrastructure/buz_kafka/buz_aiokafka_multi_threaded_consumer.py,sha256=ZRLRoBRomqrXAiePSMn4gePF59AWPn6VQpQui1UVnyM,7246
@@ -89,12 +93,13 @@ buz/event/infrastructure/models/process_context.py,sha256=rPdirnYF_G_3Rdqj2us24G
 buz/event/infrastructure/queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/event/meta_base_subscriber.py,sha256=cqB-iDtN4iuAVBZs2UwrrrAVB2t-u1VvzZw1aSClkwg,817
 buz/event/meta_subscriber.py,sha256=yH2_2OGqionoC86a3xc4K9kewiuNJs5UtiXdRAMViNM,451
-buz/event/middleware/__init__.py,sha256=vbmskMeXurTSgwXqPsRQBydHhNAYnbEoqFc1pqemI7Y,897
+buz/event/middleware/__init__.py,sha256=IlPWwkWQmo0QuW_tQgyQ3fyVFo8cRGr7SuwKZSWZBEA,1182
 buz/event/middleware/async_consume_middleware.py,sha256=n_EsDMNFgOIu7UVPGRC0iaxCIfGL-p_3xo5Avq43zYA,640
 buz/event/middleware/async_consume_middleware_chain_resolver.py,sha256=dIiyob5TYavjcD5QL31_Yqya9x3ujWtL7cUZK4bEVvk,1459
 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_async_consume_middleware.py,sha256=9IAY-c57PlUq93rAUB3aVDXBVCNH_UO57xHOTiYeWvw,1167
+buz/event/middleware/base_async_publish_middleware.py,sha256=b9dCJk8mszSNSZdh154NdMqBJUmd24Mr8zVU73KeA3Q,930
 buz/event/middleware/base_consume_middleware.py,sha256=GQxuAjHFVs_nKZXvYjBn9h4EZyUFHz1xdwl6qW5TVo8,912
 buz/event/middleware/base_publish_middleware.py,sha256=vtM8oA4LZjbZn4omPy-cIAUxQQwL-_Xb4ScU85DwjMU,531
 buz/event/middleware/consume_middleware.py,sha256=MEzfXfV1hMI0TKHU9f4zqWZsNykgu02X2lr9ZM1WLaw,511
@@ -146,7 +151,7 @@ buz/event/transactional_outbox/transactional_outbox_event_bus.py,sha256=Z9YTfixQ
 buz/event/transactional_outbox/transactional_outbox_worker.py,sha256=x6kf-Oc4oYKu9S4MTcCqd3VqPNURScTReYJ3Ahx4rKA,2221
 buz/event/worker.py,sha256=BL9TXB_kyr0Avql9fIcFm3CDNnXPvZB6O6BxVwjtCdA,942
 buz/handler.py,sha256=W6jSTo5BNV9u9QKBaEMhLIa3tgQocd6oYEJf5K4EfEU,358
-buz/kafka/__init__.py,sha256=R3fcyET-SNEAvk_XlBQbHIbQVb63Qiz6lVrif3nDhNU,3435
+buz/kafka/__init__.py,sha256=eaxgfmtoq3_q_kYpKQYEryNj9ApZbuD78RR3psPdrcQ,3312
 buz/kafka/domain/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/domain/exceptions/consumer_group_not_found_exception.py,sha256=8My8lM7DZ7JARfHY1MmuW5BWOB1YadiKhnc3cSTPlaI,225
 buz/kafka/domain/exceptions/not_all_partition_assigned_exception.py,sha256=1Ky6gDh_baD6cGB0MBnjbkkLcw2zQU_kFXPpDZn56z0,400
@@ -169,13 +174,13 @@ buz/kafka/domain/models/kafka_supported_sasl_mechanisms.py,sha256=ASyDaFgseQRcUJ
 buz/kafka/domain/models/kafka_supported_security_protocols.py,sha256=ffY2-9sOj4XIkJTSQVkqeOb4KnuqEYXISDarfDN8r9Q,161
 buz/kafka/domain/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/domain/services/async_kafka_producer.py,sha256=gSq3WwEVux_gp3EKDAMN1WsM027uklB58E-WnKpyhPs,533
-buz/kafka/domain/services/kafka_admin_client.py,sha256=6WJzMPTYSKTUq0Dtxj1rzGAWK-GAYGolW_LFDB_faVU,2042
+buz/kafka/domain/services/kafka_admin_client.py,sha256=Q89JY0Yjp2KqhXmP7IFZkoDXT8A9CsNqPxTy0oywsdI,2114
 buz/kafka/domain/services/kafka_admin_test_client.py,sha256=91l_vFIo1yhJLQQCC_OmeXZ5F429zP7Hx5g4FNllpfE,1625
 buz/kafka/domain/services/kafka_producer.py,sha256=8bLTV328orrPHcARzkc6no4vyJzrArVtCsjmSRXDjos,506
 buz/kafka/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/aiokafka/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/aiokafka/aiokafka_consumer.py,sha256=3-73e2CJhSjHONsCH_kZB1x5EwhnzLG2cCKGmkU4q0s,10008
-buz/kafka/infrastructure/aiokafka/aiokafka_producer.py,sha256=LteHKIHpT6MKplwmwsPYMsd2GWNJCzus65XDHCIdoN8,3823
+buz/kafka/infrastructure/aiokafka/aiokafka_producer.py,sha256=u1mpXjFzYz5DK5C8FbZZoWNX5ARn5_CROiDp7nyvGJM,3745
 buz/kafka/infrastructure/aiokafka/rebalance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/aiokafka/rebalance/kafka_callback_rebalancer.py,sha256=0IMc_TH4cHjIQiBWOFei_yMx6GbhO58CS-daKzffly4,2259
 buz/kafka/infrastructure/aiokafka/translators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -199,8 +204,8 @@ buz/kafka/infrastructure/interfaces/async_connection_manager.py,sha256=JbaLu5UVV
 buz/kafka/infrastructure/interfaces/connection_manager.py,sha256=EWnvShJHOg8QYe6a3ma0urjKjmVMDBi7q8T2cv_i_MQ,200
 buz/kafka/infrastructure/kafka_python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/kafka/infrastructure/kafka_python/exception/consumer_interrupted_exception.py,sha256=fqhgV7HILdVdv-p1CsOIaaESKY2ZXBtRGYbrVSdPLg0,164
-buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py,sha256=ikNTLUp3CrLgctvQDEcYTCjz8eRBTffg6cQFP8n0MNY,17571
-buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py,sha256=5xP23dQ7FDuy7dIWNw39C3bMVmaUj9ZQhEEJISRv9ec,2986
+buz/kafka/infrastructure/kafka_python/kafka_python_admin_client.py,sha256=rvyjRmafKJZL68TxRpT0lENNU1dpQXU0Rv8E8M2rEzc,17846
+buz/kafka/infrastructure/kafka_python/kafka_python_admin_test_client.py,sha256=vbklV4pPsx2-lTLaaEplw1dk7uj44V4GIFVlC5jJsvM,2969
 buz/kafka/infrastructure/kafka_python/kafka_python_producer.py,sha256=McH_YNQcte7HzNRvS_4bgaz1ng7v4ESoi4mUkrQFLYw,3627
 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
@@ -223,7 +228,7 @@ buz/locator/sync/__init__.py,sha256=OljGqPXBPuxHzWcn-tQ0P-ObLRHbhoCmmXhsSIgVxJM,
 buz/locator/sync/handler_already_registered_exception.py,sha256=7DAnkGD97OIC9gc7604dTMBtVUl8KereUvTMicK7FD0,245
 buz/locator/sync/handler_not_registered_exception.py,sha256=cYKtKET1fHXaMvbBFJNLtvNF6-yp8pixUV62_CdTS54,234
 buz/locator/sync/instance_locator.py,sha256=HGQ6uRIwrTruhax2i8L6clfJUywgHCHC3k2rwYqjApo,2076
-buz/message.py,sha256=d9CMiVSlQVX7xXHi60NSHwqd9cLFoulKIlmlBqLqzaA,2779
+buz/message.py,sha256=kBJvA1eKpdHQJiIhxlvDA1sXRpMe8Z8Ex8ceQb-gTXo,2828
 buz/metadata.py,sha256=F0-zp_6Tplr2L3euZtuZR3jZ1qb2mW0X99I5ZvQE9Yg,250
 buz/middleware/__init__.py,sha256=ndg9oGa4p8zOYC3i0nikfmSe3Ny5ug9RBwb9vZ7YhKM,176
 buz/middleware/middleware.py,sha256=XNSlfSTyBAfHzvuFrjM0IOVtz35lP_f-xWbkfdMYltA,54
@@ -265,7 +270,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.24.0.dist-info/LICENSE,sha256=jcLgcIIVaBqaZNwe0kzGWSU99YgwMcI0IGv142wkYSM,1062
-buz-2.24.0.dist-info/METADATA,sha256=rE4uNgOa5TqPQI5T9PUEtMSM_r2ecmyGp-4TyR14qj4,12580
-buz-2.24.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-buz-2.24.0.dist-info/RECORD,,
+buz-2.26.0.dist-info/LICENSE,sha256=jcLgcIIVaBqaZNwe0kzGWSU99YgwMcI0IGv142wkYSM,1062
+buz-2.26.0.dist-info/METADATA,sha256=j6esCho8yx3WMGYuCrI9lrVKNxrNiBAh_FjRhDaZlyE,12580
+buz-2.26.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+buz-2.26.0.dist-info/RECORD,,