buz 2.15.11__py3-none-any.whl → 2.16.0__py3-none-any.whl

buz/command/asynchronous/base_command_handler.py

@@ -1,27 +1,34 @@
-from typing import Type, get_type_hints, Any
+from typing import Generic, Type, TypeVar, cast, get_type_hints, Any
 
 from buz.command import Command
 from buz.command.asynchronous.command_handler import CommandHandler
 
+TCommand = TypeVar("TCommand", bound=Command)
 
-class BaseCommandHandler(CommandHandler):
+
+class BaseCommandHandler(Generic[TCommand], CommandHandler[TCommand]):
     @classmethod
     def fqn(cls) -> str:
         return f"command_handler.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         handle_types = get_type_hints(cls.handle)
 
-        if "command" not in handle_types:
+        t_command = handle_types.get("command")
+        if t_command is None:
             raise TypeError(
                 f"The method 'handle' in '{cls.fqn()}' doesn't have a parameter named 'command'. Found parameters: {cls.__get_method_parameter_names(handle_types)}"
             )
 
-        if not issubclass(handle_types["command"], Command):
+        # TypeVar mask the actual bound type
+        if hasattr(t_command, "__bound__"):
+            t_command = t_command.__bound__
+
+        if not issubclass(t_command, Command):
             raise TypeError(f"The parameter 'command' in '{cls.fqn()}.handle' is not a 'buz.command.Command' subclass")
 
-        return handle_types["command"]
+        return cast(Type[TCommand], t_command)
 
     @classmethod
     def __get_method_parameter_names(cls, handle_types: dict[str, Any]) -> list[str]:

buz/command/asynchronous/command_handler.py

@@ -1,16 +1,19 @@
-from abc import abstractmethod
-from typing import Type
+from abc import ABC, abstractmethod
+from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.command.command import Command
 
 
-class CommandHandler(Handler):
+TCommand = TypeVar("TCommand", bound=Command)
+
+
+class CommandHandler(Generic[TCommand], Handler[TCommand], ABC):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         pass
 
     @abstractmethod
-    async def handle(self, command: Command) -> None:
+    async def handle(self, command: TCommand) -> None:
         pass

buz/command/synchronous/base_command_handler.py

@@ -1,27 +1,35 @@
-from typing import Type, get_type_hints, Any
+from typing import Generic, Type, TypeVar, get_type_hints, Any, cast
 
 from buz.command import Command
 from buz.command.synchronous.command_handler import CommandHandler
 
 
-class BaseCommandHandler(CommandHandler):
+TCommand = TypeVar("TCommand", bound=Command)
+
+
+class BaseCommandHandler(Generic[TCommand], CommandHandler[TCommand]):
     @classmethod
     def fqn(cls) -> str:
         return f"command_handler.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         handle_types = get_type_hints(cls.handle)
 
-        if "command" not in handle_types:
+        t_command = handle_types.get("command")
+        if t_command is None:
             raise TypeError(
                 f"The method 'handle' in '{cls.fqn()}' doesn't have a parameter named 'command'. Found parameters: {cls.__get_method_parameter_names(handle_types)}"
             )
 
-        if not issubclass(handle_types["command"], Command):
+        # TypeVar mask the actual bound type
+        if hasattr(t_command, "__bound__"):
+            t_command = t_command.__bound__
+
+        if not issubclass(t_command, Command):
             raise TypeError(f"The parameter 'command' in '{cls.fqn()}.handle' is not a 'buz.command.Command' subclass")
 
-        return handle_types["command"]
+        return cast(Type[TCommand], t_command)
 
     @classmethod
     def __get_method_parameter_names(cls, handle_types: dict[str, Any]) -> list[str]:

buz/command/synchronous/command_handler.py

@@ -1,16 +1,18 @@
-from abc import abstractmethod
-from typing import Type
+from abc import ABC, abstractmethod
+from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.command import Command
 
+TCommand = TypeVar("TCommand", bound=Command)
 
-class CommandHandler(Handler):
+
+class CommandHandler(Generic[TCommand], Handler[TCommand], ABC):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Command]:
+    def handles(cls) -> Type[TCommand]:
         pass
 
     @abstractmethod
-    def handle(self, command: Command) -> None:
+    def handle(self, command: TCommand) -> None:
         pass

buz/event/transactional_outbox/transactional_outbox_event_bus.py

@@ -1,6 +1,8 @@
 from typing import Optional, Iterable
 
 from buz.event import Event, EventBus
+from buz.event.middleware.publish_middleware import PublishMiddleware
+from buz.event.middleware.publish_middleware_chain_resolver import PublishMiddlewareChainResolver
 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
@@ -13,22 +15,40 @@ class TransactionalOutboxEventBus(EventBus):
         outbox_repository: OutboxRepository,
         event_to_outbox_record_translator: EventToOutboxRecordTranslator,
         outbox_record_validator: Optional[OutboxRecordValidator] = None,
-    ):
+        publish_middlewares: Optional[list[PublishMiddleware]] = None,
+    ) -> None:
         self.__outbox_repository = outbox_repository
         self.__event_to_outbox_record_translator = event_to_outbox_record_translator
         self.__outbox_record_validator = outbox_record_validator
+        self.__publish_middleware_chain_resolver = PublishMiddlewareChainResolver(publish_middlewares or [])
 
     def publish(self, event: Event) -> None:
-        outbox_record = self.__translate_and_validate(event)
+        self.__publish_middleware_chain_resolver.resolve(event, self.__perform_publish)
+
+    def __perform_publish(self, event: Event) -> None:
+        outbox_record = self.__process_event(event)
         self.__outbox_repository.save(outbox_record)
 
     def bulk_publish(self, events: Iterable[Event]) -> None:
-        outbox_records = map(self.__translate_and_validate, events)
+        outbox_records: list[OutboxRecord] = []
+        for event in events:
+            self.__publish_middleware_chain_resolver.resolve(
+                event, lambda resolved_event: outbox_records.append(self.__process_event(resolved_event))
+            )
+
+        if len(outbox_records) == 0:
+            return None
+
         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)
+    def __process_event(self, event: Event) -> OutboxRecord:
+        outbox_record = self.__translate_event(event)
+        self.__validate_outbox_record(outbox_record)
+        return outbox_record
+
+    def __translate_event(self, event: Event) -> OutboxRecord:
+        return self.__event_to_outbox_record_translator.translate(event)
+
+    def __validate_outbox_record(self, outbox_record: OutboxRecord) -> None:
         if self.__outbox_record_validator is not None:
             self.__outbox_record_validator.validate(record=outbox_record)
-        return outbox_record

buz/handler.py

@@ -1,13 +1,16 @@
 from abc import ABC, abstractmethod
-from typing import Type
+from typing import Generic, Type, TypeVar
 
 from buz import Message
 
 
-class Handler(ABC):
+TMessage = TypeVar("TMessage", bound=Message)
+
+
+class Handler(Generic[TMessage], ABC):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Message]:
+    def handles(cls) -> Type[TMessage]:
         pass
 
     @classmethod

buz/query/asynchronous/base_query_handler.py

@@ -1,27 +1,36 @@
-from typing import Type, get_type_hints, Any
+from typing import Generic, Type, TypeVar, cast, get_type_hints, Any
 
 from buz.query import Query
 from buz.query.asynchronous.query_handler import QueryHandler
+from buz.query.query_response import QueryResponse
 
+TQuery = TypeVar("TQuery", bound=Query)
+TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
 
-class BaseQueryHandler(QueryHandler):
+
+class BaseQueryHandler(Generic[TQuery, TQueryResponse], QueryHandler[TQuery, TQueryResponse]):
     @classmethod
     def fqn(cls) -> str:
         return f"query_handler.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Query]:
+    def handles(cls) -> Type[TQuery]:
         handle_types = get_type_hints(cls.handle)
 
-        if "query" not in handle_types:
+        t_query = handle_types.get("query")
+        if t_query is None:
             raise TypeError(
                 f"The method 'handle' in '{cls.fqn()}' doesn't have a parameter named 'query'. Found parameters: {cls.__get_method_parameter_names(handle_types)}"
             )
 
-        if not issubclass(handle_types["query"], Query):
+        # TypeVar mask the actual bound type
+        if hasattr(t_query, "__bound__"):
+            t_query = t_query.__bound__
+
+        if not issubclass(t_query, Query):
             raise TypeError(f"The parameter 'query' in '{cls.fqn()}.handle' is not a 'buz.query.Query' subclass")
 
-        return handle_types["query"]
+        return cast(Type[TQuery], t_query)
 
     @classmethod
     def __get_method_parameter_names(cls, handle_types: dict[str, Any]) -> list[str]:

buz/query/asynchronous/query_handler.py

@@ -1,16 +1,20 @@
 from abc import abstractmethod
-from typing import Type
+from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.query import Query, QueryResponse
 
 
-class QueryHandler(Handler):
+TQuery = TypeVar("TQuery", bound=Query)
+TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
+
+
+class QueryHandler(Generic[TQuery, TQueryResponse], Handler[TQuery]):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Query]:
+    def handles(cls) -> Type[TQuery]:
         pass
 
     @abstractmethod
-    async def handle(self, query: Query) -> QueryResponse:
+    async def handle(self, query: Query) -> TQueryResponse:
         pass

buz/query/synchronous/base_query_handler.py

@@ -1,27 +1,36 @@
-from typing import Type, get_type_hints, Any
+from typing import Generic, Type, get_type_hints, Any, cast, TypeVar
 
 from buz.query import Query
+from buz.query.query_response import QueryResponse
 from buz.query.synchronous.query_handler import QueryHandler
 
+TQuery = TypeVar("TQuery", bound=Query)
+TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
 
-class BaseQueryHandler(QueryHandler):
+
+class BaseQueryHandler(Generic[TQuery, TQueryResponse], QueryHandler[TQuery, TQueryResponse]):
     @classmethod
     def fqn(cls) -> str:
         return f"query_handler.{cls.__module__}.{cls.__name__}"
 
     @classmethod
-    def handles(cls) -> Type[Query]:
+    def handles(cls) -> Type[TQuery]:
         handle_types = get_type_hints(cls.handle)
 
-        if "query" not in handle_types:
+        t_query = handle_types.get("query")
+        if t_query is None:
             raise TypeError(
                 f"The method 'handle' in '{cls.fqn()}' doesn't have a parameter named 'query'. Found parameters: {cls.__get_method_parameter_names(handle_types)}"
             )
 
-        if not issubclass(handle_types["query"], Query):
+        # TypeVar mask the actual bound type
+        if hasattr(t_query, "__bound__"):
+            t_query = t_query.__bound__
+
+        if not issubclass(t_query, Query):
             raise TypeError(f"The parameter 'query' in '{cls.fqn()}.handle' is not a 'buz.query.Query' subclass")
 
-        return handle_types["query"]
+        return cast(Type[TQuery], t_query)
 
     @classmethod
     def __get_method_parameter_names(cls, handle_types: dict[str, Any]) -> list[str]:

buz/query/synchronous/query_handler.py

@@ -1,16 +1,19 @@
-from abc import abstractmethod
-from typing import Type
+from abc import ABC, abstractmethod
+from typing import Generic, Type, TypeVar
 
 from buz import Handler
 from buz.query import Query, QueryResponse
 
+TQuery = TypeVar("TQuery", bound=Query)
+TQueryResponse = TypeVar("TQueryResponse", bound=QueryResponse)
 
-class QueryHandler(Handler):
+
+class QueryHandler(Generic[TQuery, TQueryResponse], Handler[TQuery], ABC):
     @classmethod
     @abstractmethod
-    def handles(cls) -> Type[Query]:
+    def handles(cls) -> Type[TQuery]:
         pass
 
     @abstractmethod
-    def handle(self, query: Query) -> QueryResponse:
+    def handle(self, query: TQuery) -> TQueryResponse:
         pass

{buz-2.15.11.dist-info → buz-2.16.0.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Fever
+Copyright (c) 2025 Fever
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

buz-2.16.0.dist-info/METADATA

@@ -0,0 +1,438 @@
+Metadata-Version: 2.1
+Name: buz
+Version: 2.16.0
+Summary: Buz is a set of light, simple and extensible implementations of event, command and query buses.
+License: MIT
+Author: Luis Pintado Lozano
+Author-email: luis.pintado.lozano@gmail.com
+Maintainer: Fever - Platform Squad
+Maintainer-email: platform@feverup.com
+Requires-Python: >=3.9
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Provides-Extra: aiokafka
+Provides-Extra: kombu
+Provides-Extra: pypendency
+Requires-Dist: aiohttp (>=3.12.15,<4.0.0)
+Requires-Dist: aiokafka[lz4] (==0.12.0) ; extra == "aiokafka"
+Requires-Dist: asgiref (>=3.8.1,<4.0.0) ; extra == "aiokafka"
+Requires-Dist: cachetools (>=5.5.0,<6.0.0)
+Requires-Dist: dacite (>=1.8.1,<2.0.0)
+Requires-Dist: kafka-python-ng (==2.2.3)
+Requires-Dist: kombu (>=4.6.11) ; extra == "kombu"
+Requires-Dist: orjson (>=3.10.1,<4.0.0)
+Requires-Dist: pympler (==1.0.1)
+Requires-Dist: pypendency (>=0,<1) ; extra == "pypendency"
+Requires-Dist: uuid-utils (>=0.9.0,<0.10.0)
+Description-Content-Type: text/markdown
+
+# Buz
+
+[![PyPI version](https://badge.fury.io/py/buz.svg)](https://badge.fury.io/py/buz)
+[![Python Support](https://img.shields.io/pypi/pyversions/buz.svg)](https://pypi.org/project/buz/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+**Buz** is a lightweight, simple, and extensible Python library that provides implementations of **Event**, **Command**, and **Query** buses following CQRS and Event-Driven Architecture patterns.
+
+## 📋 Table of Contents
+
+- [Buz](#buz)
+  - [📋 Table of Contents](#-table-of-contents)
+  - [✨ Key Features](#-key-features)
+  - [🚀 Quick Start](#-quick-start)
+    - [Installation](#installation)
+    - [Basic Usage](#basic-usage)
+      - [Event Bus Example](#event-bus-example)
+      - [Command Bus Example](#command-bus-example)
+      - [Query Bus Example](#query-bus-example)
+  - [🏗️ Architecture](#️-architecture)
+    - [Event Bus](#event-bus)
+    - [Command Bus](#command-bus)
+    - [Query Bus](#query-bus)
+  - [🔧 Advanced Features](#-advanced-features)
+    - [Middleware System](#middleware-system)
+    - [Transactional Outbox Pattern](#transactional-outbox-pattern)
+    - [RabbitMQ](#rabbitmq)
+    - [Kafka Integration](#kafka-integration)
+    - [Async Support](#async-support)
+  - [📦 Message Brokers](#-message-brokers)
+    - [Supported Brokers](#supported-brokers)
+  - [🧪 Testing](#-testing)
+  - [🔗 Related Projects](#-related-projects)
+  - [📋 Requirements](#-requirements)
+  - [🤝 Contributing](#-contributing)
+    - [Development Setup](#development-setup)
+  - [📄 License](#-license)
+  - [📚 Documentation](#-documentation)
+  - [🙋‍♀️ Support](#️-support)
+
+## ✨ Key Features
+
+- 🚌 **Bus Types**: Event, Command, and Query buses for clean architecture
+- 🔄 **Sync & Async Support**: Both synchronous and asynchronous implementations
+- 🔧 **Middleware System**: Extensible middleware for cross-cutting concerns
+- 📦 **Message Brokers**: Support for Kafka, RabbitMQ (via Kombu), and in-memory
+- 🔒 **Transactional Outbox**: Reliable event publishing with transactional guarantees
+- 🎯 **Dependency Injection**: Built-in locator pattern for handler resolution
+- 📝 **Type Safety**: Fully typed with mypy support
+- 🪶 **Lightweight**: Minimal dependencies, maximum flexibility
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Basic installation
+pip install buz
+
+# With Kafka support
+pip install buz[aiokafka]
+
+# With RabbitMQ support
+pip install buz[kombu]
+
+# With dependency injection
+pip install buz[pypendency]
+```
+
+### Basic Usage
+
+#### Event Bus Example
+
+```python
+from dataclasses import dataclass
+from buz import Message
+from buz.event import Event, BaseSubscriber
+from buz.event.sync import SyncEventBus
+from buz.locator.sync import InstanceLocator
+
+@dataclass(frozen=True)
+class UserCreated(Event):
+    user_id: str
+    email: str
+
+class EmailSubscriber(BaseSubscriber):
+    def consume(self, event: UserCreated) -> None:
+        print(f"Sending welcome email to {event.email}")
+
+class AnalyticsSubscriber(BaseSubscriber):
+    def consume(self, event: UserCreated) -> None:
+        print(f"Tracking user creation: {event.user_id}")
+
+# Setup
+locator: InstanceLocator = InstanceLocator()
+locator.register(EmailSubscriber())
+locator.register(AnalyticsSubscriber())
+
+event_bus = SyncEventBus(locator)
+
+# Usage
+event = UserCreated(user_id="123", email="user@example.com")
+event_bus.publish(event)
+```
+
+#### Command Bus Example
+
+```python
+from dataclasses import dataclass
+from buz.command import Command
+from buz.command.synchronous import BaseCommandHandler
+from buz.command.synchronous.self_process import SelfProcessCommandBus
+from buz.locator.sync import InstanceLocator
+
+@dataclass(frozen=True)
+class CreateUser(Command):
+    email: str
+    name: str
+
+class CreateUserCommandHandler(BaseCommandHandler):
+    def handle(self, command: CreateUser) -> None:
+        # Business logic here
+        print(f"Creating user: {command.name} ({command.email})")
+
+# Setup
+locator = InstanceLocator()
+locator.register(CreateUserCommandHandler())
+
+command_bus = SelfProcessCommandBus(locator)
+
+# Usage
+command = CreateUser(email="user@example.com", name="John Doe")
+command_bus.handle(command)
+```
+
+#### Query Bus Example
+
+```python
+from dataclasses import dataclass
+from buz.query import Query, QueryResponse
+from buz.query.synchronous import BaseQueryHandler
+from buz.query.synchronous.self_process import SelfProcessQueryBus
+from buz.locator.sync import InstanceLocator
+
+@dataclass(frozen=True)
+class GetUser(Query):
+    user_id: str
+
+@dataclass(frozen=True)
+class User:
+    user_id: str
+    name: str
+    email: str
+
+class GetUserQueryHandler(BaseQueryHandler):
+    def handle(self, query: GetUser) -> QueryResponse:
+        # Business logic here
+        return QueryResponse(
+            content=User(
+                user_id=query.user_id,
+                name="John Doe",
+                email="john@example.com"
+            )
+        )
+
+# Setup
+locator = InstanceLocator()
+locator.register(GetUserQueryHandler())
+
+query_bus = SelfProcessQueryBus(locator)
+
+# Usage
+query = GetUser(user_id="123")
+query_response = query_bus.handle(query)
+user = query_response.content
+print(f"User: {user.name}")
+```
+
+## 🏗️ Architecture
+
+Buz implements the **Command Query Responsibility Segregation (CQRS)** pattern with distinct buses:
+
+### Event Bus
+
+- **Purpose**: Publish domain events and notify multiple subscribers
+- **Pattern**: Pub/Sub with multiple handlers per event
+- **Use Cases**: Domain event broadcasting, eventual consistency, integration events
+
+### Command Bus
+
+- **Purpose**: Execute business operations and commands
+- **Pattern**: Single handler per command
+- **Use Cases**: Business logic execution, write operations, state changes
+
+### Query Bus
+
+- **Purpose**: Retrieve data and execute queries
+- **Pattern**: Single handler per query with typed responses
+- **Use Cases**: Data retrieval, read operations, projections
+
+## 🔧 Advanced Features
+
+### Middleware System
+
+Add cross-cutting concerns like logging, validation, and metrics:
+
+```python
+from datetime import datetime
+from buz.event import Event, Subscriber
+from buz.event.middleware import BasePublishMiddleware, BaseConsumeMiddleware
+from buz.event.infrastructure.models.execution_context import ExecutionContext
+
+class LoggingPublishMiddleware(BasePublishMiddleware):
+    def _before_on_publish(self, event: Event) -> None:
+        print(f"Publishing event {event}")
+
+    def _after_on_publish(self, event: Event) -> None:
+        return
+
+class MetricsConsumeMiddleware(BaseConsumeMiddleware):
+    def __init__(self) -> None:
+        self.__consumption_start_time: datetime = datetime.now()
+
+    def _before_on_consume(
+        self,
+        event: Event,
+        subscriber: Subscriber,
+        execution_context: ExecutionContext,
+    ) -> None:
+        self.__consumption_start_time = datetime.now()
+
+    def _after_on_consume(
+        self,
+        event: Event,
+        subscriber: Subscriber,
+        execution_context: ExecutionContext,
+    ) -> None:
+        consumption_time_ms = int((datetime.now() - self.__consumption_start_time).total_seconds() * 1000)
+        print(
+            f"Subscriber {subscriber.fqn()} consumed event {event.id} successfully in {consumption_time_ms} ms"
+        )
+
+# Apply middleware
+event_bus = SyncEventBus(
+    locator=locator,
+    publish_middlewares=[LoggingPublishMiddleware()],
+    consume_middlewares=[MetricsConsumeMiddleware()]
+)
+
+# Usage
+event = UserCreated(user_id="123", email="user@example.com")
+event_bus.publish(event)
+```
+
+### Transactional Outbox Pattern
+
+Ensure reliable event publishing with database transactions:
+
+```python
+from buz.event.transactional_outbox import TransactionalOutboxEventBus
+
+# Configure with your database and event bus
+transactional_outbox_bus = TransactionalOutboxEventBus(
+    outbox_repository=your_outbox_repository,
+    event_to_outbox_record_translator=your_outbox_record_translator,
+    ...
+)
+
+# Events are stored in database, published later by worker
+transactional_outbox_bus.publish(event)
+```
+
+### RabbitMQ
+
+```python
+from buz.event.infrastructure.kombu.kombu_event_bus import KombuEventBus
+
+kombu_event_bus = KombuEventBus(
+    connection=your_connection,
+    publish_strategy=your_publish_strategy,
+    publish_retry_policy=you_publish_retry_policy,
+    ...
+)
+
+# Published and consumed in RabbitMQ
+kombu_event_bus.publish(event)
+```
+
+### Kafka Integration
+
+```python
+from buz.kafka import BuzKafkaEventBus
+
+kafka_bus = KafkaEventBus(
+    publish_strategy=your_publish_strategy,
+    producer=your_producer,
+    logger=your_logger,
+    ...
+)
+
+# Published and consumed in Kafka
+kafka_bus.publish(event)
+```
+
+### Async Support
+
+```python
+from buz.event.async_event_bus import AsyncEventBus
+from buz.query.asynchronous import QueryBus as AsyncQueryBus
+from buz.command.asynchronous import CommandHandler as AsyncCommandHandler
+
+
+# Async event bus
+async_event_bus = AsyncEventBus(locator)
+await async_event_bus.publish(event)
+
+# Async query bus
+async_query_bus = AsyncQueryBus(locator)
+await async_query_bus.handle(event)
+
+# Async command bus
+async_command_bus = AsyncCommandBus(locator)
+await async_command_bus.handle(command)
+```
+
+## 📦 Message Brokers
+
+### Supported Brokers
+
+| Broker    | Sync | Async | Installation                |
+| --------- | ---- | ----- | --------------------------- |
+| In-Memory | ✅   | ✅    | Built-in                    |
+| Kafka     | ✅   | ✅    | `pip install buz[aiokafka]` |
+| RabbitMQ  | ✅   | ❌    | `pip install buz[kombu]`    |
+
+## 🧪 Testing
+
+Buz includes testing utilities for unit and integration tests:
+
+```python
+from buz.event.sync import SyncEventBus
+from buz.locator.sync import InstanceLocator
+
+test_locator = InstanceLocator()
+test_bus = SyncEventBus(test_locator)
+
+test_locator.register(EmailSubscriber())
+test_bus.publish(UserCreated(user_id="123", email="test@example.com"))
+```
+
+## 🔗 Related Projects
+
+- **[buz-fever-shared](https://github.com/Feverup/buz-fever-shared)**: Opinionated utilities and standards for Buz
+- **[buz-basic-example](https://github.com/Feverup/buz-basic-example)**: Complete example project with Docker setup
+
+## 📋 Requirements
+
+- Python 3.9+
+- Optional dependencies based on features used
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for details.
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/Feverup/buz.git
+cd buz
+
+# Install with development dependencies
+make build
+
+# Run tests
+make test
+
+# Run linting
+make lint
+
+# Format code
+make format
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 📚 Documentation
+
+- [Changelog](CHANGELOG.md) - Release notes and version history
+
+## 🙋‍♀️ Support
+
+- Create an [Issue](https://github.com/Feverup/buz/issues) for bug reports or feature requests
+
+---
+
+Made with ❤️ by the [Fever Platform Team](platform@feverup.com)
+

{buz-2.15.11.dist-info → buz-2.16.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
 buz/__init__.py,sha256=ctEyEjRm2Z2te3dZ1CLTbJw8_MmVFFqTflZowKeMSvM,109
 buz/command/__init__.py,sha256=iwaODtzgrlWc1IyD-3YPDN2jbTtwqog9_rS-P-Gmi6k,223
 buz/command/asynchronous/__init__.py,sha256=aMvcBRDvIP9SUXh1B8BTQS_VPkntem3BomBI_ypEs4U,271
-buz/command/asynchronous/base_command_handler.py,sha256=Fm5SYqoki2DXcZUhQmuDhSnZpgxyaid0PRT8rtxZVl4,1128
+buz/command/asynchronous/base_command_handler.py,sha256=8ADx07Rwtnxbmz4f0L65uI8cJRkHr3itzyykC--AmBA,1393
 buz/command/asynchronous/command_bus.py,sha256=mQPzemGvC14fRADUv6_jA8qlBLSIGmXVorM6xo_V6_A,181
-buz/command/asynchronous/command_handler.py,sha256=lHCS4FyoAwq9aDpfy1u11tAtBRxYMXwSxAWhX7-qyX8,330
+buz/command/asynchronous/command_handler.py,sha256=ffVqrE_rK_nN4Yf82A6MQxb7O4OeEfkgR2ioBVGVNCs,437
 buz/command/asynchronous/middleware/__init__.py,sha256=1CGYsALue16-2nkxg7lHhxiS5EQWX6R6Hr4Lr0qwOcQ,409
 buz/command/asynchronous/middleware/base_handle_middleware.py,sha256=xvGZW5rzPz13f08bw0QigSszzSwO16hKqL4oKW_IoSs,788
 buz/command/asynchronous/middleware/handle_middleware.py,sha256=2lCgRRqWkiJLbys4YzWSUupVt8S50vwfEWzVu8PSqjw,449
@@ -13,9 +13,9 @@ buz/command/asynchronous/self_process/self_process_command_bus.py,sha256=PjP46OI
 buz/command/command.py,sha256=wYpjD16PH23r2VapFEMa-wnm3xNjkR22FXtuLoKfnu0,193
 buz/command/more_than_one_command_handler_related_exception.py,sha256=dNCMXCAKVckKgrgROyJWqaEyWntyByQKsa6gQfaKE4U,554
 buz/command/synchronous/__init__.py,sha256=ZAH35jpte6zpxb70iQfZfGSg_OsXqVNYwNkCJy7Qnzk,268
-buz/command/synchronous/base_command_handler.py,sha256=P0tyjCh4mKKcBV67JR4m5qosXpTk6qemG-7Zpdu6PD8,1127
+buz/command/synchronous/base_command_handler.py,sha256=GkmxttA1_Wu2X5O7iR-tLRdnmT-JDgeyURPwkjLPGhg,1393
 buz/command/synchronous/command_bus.py,sha256=FHJH4lerThu5fWRISM0VIK8ebyfqgDGqNNCqItbmGPI,175
-buz/command/synchronous/command_handler.py,sha256=nswGhsUBtCHjXVHCN3pToa9WYPab0bvTcTuSPZZbxBU,316
+buz/command/synchronous/command_handler.py,sha256=pP11Njbth89NQiVPqlALtKmabVtOX4sucdbiCp-sceI,422
 buz/command/synchronous/middleware/__init__.py,sha256=wE97veOW2cCGpTZ-3bvc3aU6NdQmSOYfdX9kAUETJ0w,406
 buz/command/synchronous/middleware/base_handle_middleware.py,sha256=qHnbucL7j6Dnw7E8ACBf32pzDD9squYPp6UiK2heb5A,774
 buz/command/synchronous/middleware/handle_middleware.py,sha256=oIsmB30mu-Cd9IQc1qMKbUIaIMHipSEXOw2swVrtbkk,420
@@ -140,10 +140,10 @@ buz/event/transactional_outbox/outbox_record_validation/outbox_record_validation
 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=Sn7aWaq1G6uiKXcV09l9L1eVQ_bPUTqY-OSD12_H2jU,628
-buz/event/transactional_outbox/transactional_outbox_event_bus.py,sha256=S2VIrKCyZG8vztgBagKOJUhp2oJhbLx6oGVHPBplRZ4,1676
+buz/event/transactional_outbox/transactional_outbox_event_bus.py,sha256=9eUevDAKEwouKrSEhf5dpqFwI-FbB5z9R7gIxaFCLno,2551
 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/handler.py,sha256=W6jSTo5BNV9u9QKBaEMhLIa3tgQocd6oYEJf5K4EfEU,358
 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=1Ky6gDh_baD6cGB0MBnjbkkLcw2zQU_kFXPpDZn56z0,400
@@ -223,26 +223,26 @@ buz/middleware/middleware_chain_builder.py,sha256=D9zl5XSF5P65QpnPcbtyFaaVHqBTb6
 buz/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 buz/query/__init__.py,sha256=Eq0ppBYFYaDp-Z7uViSqhuOBxjh_q8VSCbFdpMz3FsU,274
 buz/query/asynchronous/__init__.py,sha256=YhCudd43otBYDi6ZdisSjnAZ0psCkp_ZZ_pb36fWoMY,247
-buz/query/asynchronous/base_query_handler.py,sha256=Sj2tnluRvlImHyN6MrlKftLoavVkCWKxm55p2r64ej4,1094
+buz/query/asynchronous/base_query_handler.py,sha256=148JQwx6Yvp_pCDJEdw98r1K0YSQBdNEq9GqwA_Q368,1484
 buz/query/asynchronous/middleware/__init__.py,sha256=aoei9p2Ti1biFCOAQpsDQ7H_s0Dt5hkWgALJHhfjpoE,404
 buz/query/asynchronous/middleware/base_handle_middleware.py,sha256=51FliRBVrobao3TSJnYKJz1fJPg8dxSymCFQRiClz9g,874
 buz/query/asynchronous/middleware/handle_middleware.py,sha256=LfQLKc4jIlUegbGbnMXqCSXgAl6NaRGqvKDN0GuvgY4,462
 buz/query/asynchronous/middleware/handle_middleware_chain_resolver.py,sha256=iA2faVRvNkuS5S4dB1buP25JGSqfBKBQIKg14hWis2U,1123
 buz/query/asynchronous/query_bus.py,sha256=L3VIw6VofJzJYH2oie5uFKH-dQ-M6a2VECTd6Seos_o,195
-buz/query/asynchronous/query_handler.py,sha256=E8fd49ZvguJLY7WvtbieTS_ksVt154uLVFggenTeZLw,334
+buz/query/asynchronous/query_handler.py,sha256=Me80YBdGP368WYUhEY7n5AmwacFmdqFYyiM6TyDrqKE,501
 buz/query/asynchronous/self_process/__init__.py,sha256=5y0dGgeDq0ZPCrexVjvJWT6gix8lKd-7Iw7Z3H8dirc,126
 buz/query/asynchronous/self_process/self_process_query_bus.py,sha256=2PqbJGrjv7ULEAl0yIj-Gn4ylVc3_EvJ0VXIlzUlhNc,1217
 buz/query/more_than_one_query_handler_related_exception.py,sha256=sEfShwCB1VHdUbf02NSEAyv6pXx4GO9ram0AenBF_dE,516
 buz/query/query.py,sha256=_YGlCOfywRv4JaHBweIn2AdXMwM5g9UJCWLojNg-qCA,189
 buz/query/query_response.py,sha256=XaHBi0Vw_3Tw5IxnuMgenZCRH0B-IBR86mtyYwj_eWw,153
 buz/query/synchronous/__init__.py,sha256=pc56XeFQnTbXB-HEDa2DtvYo9wgKUUHHB3lsCKjv-L4,244
-buz/query/synchronous/base_query_handler.py,sha256=0Up77CW0Zk8Dr92u-pT712cGDj5OFUxCIHd6ewZJcNY,1093
+buz/query/synchronous/base_query_handler.py,sha256=a78B0GVeAFScMbef4ii8cjJbVZR-m8WwkxBiWQ2Cfik,1483
 buz/query/synchronous/middleware/__init__.py,sha256=Yo66O_HODdEfJ-MR5FvWTu7_4UFQooYG8M2IB0crd6U,400
 buz/query/synchronous/middleware/base_handle_middleware.py,sha256=4lqJB2C-GHl3T5S5dVXp8qgwA-48Cmp8mfQy21-GxNI,846
 buz/query/synchronous/middleware/handle_middleware.py,sha256=Xr2HSlRrW3slluyUiJ6zH0Rw0oeWD3uMN-1hjuFbC_k,433
 buz/query/synchronous/middleware/handle_middleware_chain_resolver.py,sha256=OIpGLJ_2a8cGsp-LmA3Q1Lvb1pB65MIuA-geiPrQKHM,1070
 buz/query/synchronous/query_bus.py,sha256=eYl_sGH5TcELkOXc4RnV4Tkmcs-VLc1vzd-YMduQ1YI,189
-buz/query/synchronous/query_handler.py,sha256=2miSCBzVuD861mldG-XflkoKtpKO16Cdvb2bQBLQq9w,328
+buz/query/synchronous/query_handler.py,sha256=q8zqXjU9btid_q4wbL73QgaiWjMzGDFvwZ5AQN4q0CA,505
 buz/query/synchronous/self_process/__init__.py,sha256=fU1OoXXXH5dMGKz8y7mwTVvyhNj6BCKDTxuxH_q-leM,125
 buz/query/synchronous/self_process/self_process_query_bus.py,sha256=pKGJxXBWtqU4i0fzb30OCNhAVPCkUh7IlfNzgAhCUC8,1157
 buz/query/synchronous/synced_async/__init__.py,sha256=TdFmIBeFIpl3Tvmh_FJpJMXJdPdfRxOstVqnPUi23mo,125
@@ -257,7 +257,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.15.11.dist-info/LICENSE,sha256=Jytu2S-2SPEgsB0y6BF-_LUxIWY7402fl0JSh36TLZE,1062
-buz-2.15.11.dist-info/METADATA,sha256=BuIeKxWGRrmcHeBDjBgw9ZW9Et1fisfy0hbqnGjKqHU,1598
-buz-2.15.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-buz-2.15.11.dist-info/RECORD,,
+buz-2.16.0.dist-info/LICENSE,sha256=jcLgcIIVaBqaZNwe0kzGWSU99YgwMcI0IGv142wkYSM,1062
+buz-2.16.0.dist-info/METADATA,sha256=NUJDqpVmTFd9vDNXIhjiaN1N9jKAiUOisQfBFUB6q_Y,12679
+buz-2.16.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+buz-2.16.0.dist-info/RECORD,,

buz-2.15.11.dist-info/METADATA

@@ -1,41 +0,0 @@
-Metadata-Version: 2.1
-Name: buz
-Version: 2.15.11
-Summary: Buz is a set of light, simple and extensible implementations of event, command and query buses.
-License: MIT
-Author: Luis Pintado Lozano
-Author-email: luis.pintado.lozano@gmail.com
-Maintainer: Fever - Platform Squad
-Maintainer-email: platform@feverup.com
-Requires-Python: >=3.9
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Typing :: Typed
-Provides-Extra: aiokafka
-Provides-Extra: kombu
-Provides-Extra: pypendency
-Requires-Dist: aiohttp (>=3.12.15,<4.0.0)
-Requires-Dist: aiokafka[lz4] (==0.12.0) ; extra == "aiokafka"
-Requires-Dist: asgiref (>=3.8.1,<4.0.0) ; extra == "aiokafka"
-Requires-Dist: cachetools (>=5.5.0,<6.0.0)
-Requires-Dist: dacite (>=1.8.1,<2.0.0)
-Requires-Dist: kafka-python-ng (==2.2.3)
-Requires-Dist: kombu (>=4.6.11) ; extra == "kombu"
-Requires-Dist: orjson (>=3.10.1,<4.0.0)
-Requires-Dist: pympler (==1.0.1)
-Requires-Dist: pypendency (>=0,<1) ; extra == "pypendency"
-Requires-Dist: uuid-utils (>=0.9.0,<0.10.0)
-Description-Content-Type: text/markdown
-
-# Buz
-
-Buz is a set of light, simple and extensible implementations of event, command and query buses.
-