aioeventbus 0.1.0__tar.gz

aioeventbus-0.1.0/PKG-INFO

@@ -0,0 +1,281 @@
+Metadata-Version: 2.4
+Name: aioeventbus
+Version: 0.1.0
+Summary: An async event bus for RabbitMQ, Redis, and NATS
+Author-email: Lumin Core <lumincore1@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Lumin-Core/aioeventbus
+Project-URL: Bug-tracker, https://github.com/Lumin-Core/aioeventbus/issues
+Keywords: aioeventbus,eventbus,rabbitmq,redis,nats,async,microservices
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Communications
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aio-pika>=9.0.0
+Requires-Dist: redis>=5.0.0
+Requires-Dist: nats-py>=2.5.0
+Requires-Dist: pyyaml>=6.0
+
+# 📡 aioeventbus
+
+**Асинхронная шина событий для RabbitMQ, Redis и NATS**
+
+[![PyPI version](https://badge.fury.io/py/aioeventbus.svg)](https://badge.fury.io/py/aioeventbus)
+[![Python versions](https://img.shields.io/pypi/pyversions/aioeventbus.svg)](https://pypi.org/project/aioeventbus/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> Простая, гибкая и готовая к продакшену библиотека для обмена сообщениями между микросервисами.
+
+**aioeventbus** предоставляет единый асинхронный API для публикации и подписки на доменные события через популярные брокеры:
+- 🐰 **RabbitMQ** (fanout-обменники)
+- 🔴 **Redis** (Pub/Sub)
+- 🚀 **NATS** (базовая модель подписки)
+
+Смените брокер, отредактировав одну строку в конфиге – код приложения останется неизменным.
+
+---
+
+## ✨ Возможности
+
+- 🔌 **Независимость от брокера** – одинаковый интерфейс для RabbitMQ, Redis, NATS
+- ⚡ **Полностью асинхронно** – построено на `asyncio`, идеально для FastAPI / Sanic / aiohttp
+- 🧵 **Поддержка синхронных обработчиков** – ваши хендлеры могут быть обычными функциями; они выполняются в пуле потоков без блокировки event loop
+- 📝 **Простая регистрация через декоратор** – `@bus.handler(EventClass)`
+- 🔁 **Автоматическое переподключение** – надёжные соединения для всех брокеров
+- 🛠️ **CLI для генерации конфигов** – начните работу за секунды
+- 📦 **Минимальные зависимости** – только библиотеки для выбранного брокера
+- 👌 **Удобство использования** – единый интерфейс и фабрика `create_event_bus` скрывают различия между брокерами. Не нужно учить разные API для каждого брокера – достаточно знать один класс `EventBus`. Конфигурация через YAML или CLI делает переключение брокера делом одной строки, а встроенная обработка ошибок и автоматическое переподключение избавляют от рутины.
+
+---
+
+## 📦 Установка
+
+```bash
+pip install aioeventbus
+```
+
+Дополнительно установите клиентскую библиотеку для нужного брокера:
+- `aio-pika` для RabbitMQ
+- `redis` для Redis
+- `nats-py` для NATS
+
+---
+
+## 🚀 Быстрый старт
+
+### 1. Создайте конфигурационный файл
+
+Файл `config.yaml`:
+
+```yaml
+broker: rabbitmq        # rabbitmq, redis, nats
+host: localhost
+port: 5672              # порты по умолчанию: RabbitMQ=5672, Redis=6379, NATS=4222
+exchange: domain_events # для RabbitMQ
+max_workers: 10
+```
+
+Или сгенерируйте его через CLI:
+
+```bash
+aioeventbus init --broker nats --output config.yaml
+```
+
+### 2. Определите события домена
+
+```python
+from dataclasses import dataclass
+from aioeventbus import DomainEvent
+
+@dataclass
+class OrderCreated(DomainEvent):
+    __event_type__ = "OrderCreated"
+    order_id: str
+    customer_id: str
+    amount: float
+```
+
+### 3. Зарегистрируйте обработчики
+
+```python
+from aioeventbus import create_event_bus
+
+bus = create_event_bus("config.yaml")
+
+@bus.handler(OrderCreated)
+def notify_admin(event: OrderCreated):
+    print(f"[ADMIN] Новый заказ {event.order_id} от {event.customer_id}")
+
+@bus.handler(OrderCreated)
+def start_fulfillment(event: OrderCreated):
+    print(f"[FULFILLMENT] Обработка заказа {event.order_id}")
+```
+
+### 4. Запустите потребителя (например, в lifespan FastAPI)
+
+```python
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await bus.start_consuming()
+    yield
+    await bus.stop_consuming()
+
+app = FastAPI(lifespan=lifespan)
+```
+
+### 5. Публикуйте события из любого места
+
+```python
+@app.post("/orders")
+async def create_order(order_id: str, customer_id: str, amount: float):
+    event = OrderCreated(order_id, customer_id, amount)
+    await bus.publish(event)
+    return {"status": "ok"}
+```
+
+---
+
+## 📂 Конфигурация
+
+Библиотека использует YAML-файл конфигурации. Пример для каждого брокера:
+
+<details>
+<summary><b>RabbitMQ</b></summary>
+
+```yaml
+broker: rabbitmq
+host: localhost
+port: 5672
+exchange: domain_events
+max_workers: 10
+durable: false        # временная очередь (удаляется при остановке потребителя)
+```
+</details>
+
+<details>
+<summary><b>Redis</b></summary>
+
+```yaml
+broker: redis
+host: localhost
+port: 6379
+channel: domain_events
+max_workers: 10
+```
+</details>
+
+<details>
+<summary><b>NATS</b></summary>
+
+```yaml
+broker: nats
+host: localhost
+port: 4222
+subject: domain_events
+max_workers: 10
+```
+</details>
+
+Все поля, кроме `broker`, опциональны – значения по умолчанию совпадают с примерами выше.
+
+---
+
+## 🧰 CLI утилита
+
+`aioeventbus` поставляется с интерфейсом командной строки:
+
+```bash
+aioeventbus init --broker redis --output my_config.yaml
+```
+
+Опции:
+- `--broker` – выберите `rabbitmq`, `redis` или `nats`
+- `--output` – путь к выходному файлу (по умолчанию `eventbus_config.yaml`)
+- `--host`, `--port`, `--exchange`, `--channel`, `--subject`, `--max-workers` – переопределить значения по умолчанию
+
+---
+
+## 🧪 Пример с FastAPI
+
+Полный пример находится в директории [`examples/fastapi_app`](examples/fastapi_app).
+
+Запустите его:
+
+```bash
+cd examples/fastapi_app
+pip install -r requirements.txt   # fastapi, uvicorn, aioeventbus
+uvicorn main:app --reload
+```
+
+Затем выполните запросы:
+
+```bash
+curl -X POST "http://localhost:8000/orders?order_id=123&customer_id=alice&amount=99.9"
+curl -X POST "http://localhost:8000/orders/123/pay?payment_id=pay_456"
+```
+
+В терминале появятся сообщения от зарегистрированных обработчиков.
+
+---
+
+## 🏗️ Архитектура
+
+Библиотека построена вокруг абстрактного класса `EventBus`:
+
+```python
+class EventBus(ABC):
+    def handler(self, event_cls): ...
+    async def publish(self, event) -> None: ...
+    async def start_consuming(self) -> None: ...
+    async def stop_consuming(self) -> None: ...
+```
+
+Три конкретные реализации: `RabbitMQEventBus`, `RedisEventBus` и `NatsEventBus`.  
+Фабрика `create_event_bus` читает ваш конфиг и возвращает нужный экземпляр.
+
+- Потребители автоматически создают временные очереди (или подписки), так что каждый подписчик получает копию каждого события.
+- Синхронные обработчики запускаются в пуле потоков, чтобы не блокировать event loop asyncio.
+- Соединения управляются надёжно – они автоматически переподключаются при обрыве связи с брокером.
+
+---
+
+## 🤝 Участие в разработке
+
+Приветствуются любые вклады!  
+Пожалуйста, ознакомьтесь с [трекером задач](https://github.com/yourusername/aioeventbus/issues) и отправляйте pull request с понятным описанием изменений.
+
+1. Сделайте форк репозитория  
+2. Создайте ветку для новой функциональности  
+3. Установите зависимости для разработки: `pip install -e .[dev]`  
+4. Запустите тесты: `pytest`  
+5. Отправьте pull request  
+
+---
+
+## 📄 Лицензия
+
+Этот проект распространяется под лицензией **MIT** – подробности в файле [LICENSE](LICENSE).
+
+---
+
+## 🙌 Благодарности
+
+Создано с ❤️ с использованием:
+- [aio-pika](https://github.com/mosquito/aio-pika) для RabbitMQ
+- [redis-py](https://github.com/redis/redis-py) для Redis
+- [nats.py](https://github.com/nats-io/nats.py) для NATS
+
+---
+
+**Приятной событийно-ориентированной разработки!** 🚀

aioeventbus-0.1.0/README.md

@@ -0,0 +1,255 @@
+# 📡 aioeventbus
+
+**Асинхронная шина событий для RabbitMQ, Redis и NATS**
+
+[![PyPI version](https://badge.fury.io/py/aioeventbus.svg)](https://badge.fury.io/py/aioeventbus)
+[![Python versions](https://img.shields.io/pypi/pyversions/aioeventbus.svg)](https://pypi.org/project/aioeventbus/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> Простая, гибкая и готовая к продакшену библиотека для обмена сообщениями между микросервисами.
+
+**aioeventbus** предоставляет единый асинхронный API для публикации и подписки на доменные события через популярные брокеры:
+- 🐰 **RabbitMQ** (fanout-обменники)
+- 🔴 **Redis** (Pub/Sub)
+- 🚀 **NATS** (базовая модель подписки)
+
+Смените брокер, отредактировав одну строку в конфиге – код приложения останется неизменным.
+
+---
+
+## ✨ Возможности
+
+- 🔌 **Независимость от брокера** – одинаковый интерфейс для RabbitMQ, Redis, NATS
+- ⚡ **Полностью асинхронно** – построено на `asyncio`, идеально для FastAPI / Sanic / aiohttp
+- 🧵 **Поддержка синхронных обработчиков** – ваши хендлеры могут быть обычными функциями; они выполняются в пуле потоков без блокировки event loop
+- 📝 **Простая регистрация через декоратор** – `@bus.handler(EventClass)`
+- 🔁 **Автоматическое переподключение** – надёжные соединения для всех брокеров
+- 🛠️ **CLI для генерации конфигов** – начните работу за секунды
+- 📦 **Минимальные зависимости** – только библиотеки для выбранного брокера
+- 👌 **Удобство использования** – единый интерфейс и фабрика `create_event_bus` скрывают различия между брокерами. Не нужно учить разные API для каждого брокера – достаточно знать один класс `EventBus`. Конфигурация через YAML или CLI делает переключение брокера делом одной строки, а встроенная обработка ошибок и автоматическое переподключение избавляют от рутины.
+
+---
+
+## 📦 Установка
+
+```bash
+pip install aioeventbus
+```
+
+Дополнительно установите клиентскую библиотеку для нужного брокера:
+- `aio-pika` для RabbitMQ
+- `redis` для Redis
+- `nats-py` для NATS
+
+---
+
+## 🚀 Быстрый старт
+
+### 1. Создайте конфигурационный файл
+
+Файл `config.yaml`:
+
+```yaml
+broker: rabbitmq        # rabbitmq, redis, nats
+host: localhost
+port: 5672              # порты по умолчанию: RabbitMQ=5672, Redis=6379, NATS=4222
+exchange: domain_events # для RabbitMQ
+max_workers: 10
+```
+
+Или сгенерируйте его через CLI:
+
+```bash
+aioeventbus init --broker nats --output config.yaml
+```
+
+### 2. Определите события домена
+
+```python
+from dataclasses import dataclass
+from aioeventbus import DomainEvent
+
+@dataclass
+class OrderCreated(DomainEvent):
+    __event_type__ = "OrderCreated"
+    order_id: str
+    customer_id: str
+    amount: float
+```
+
+### 3. Зарегистрируйте обработчики
+
+```python
+from aioeventbus import create_event_bus
+
+bus = create_event_bus("config.yaml")
+
+@bus.handler(OrderCreated)
+def notify_admin(event: OrderCreated):
+    print(f"[ADMIN] Новый заказ {event.order_id} от {event.customer_id}")
+
+@bus.handler(OrderCreated)
+def start_fulfillment(event: OrderCreated):
+    print(f"[FULFILLMENT] Обработка заказа {event.order_id}")
+```
+
+### 4. Запустите потребителя (например, в lifespan FastAPI)
+
+```python
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await bus.start_consuming()
+    yield
+    await bus.stop_consuming()
+
+app = FastAPI(lifespan=lifespan)
+```
+
+### 5. Публикуйте события из любого места
+
+```python
+@app.post("/orders")
+async def create_order(order_id: str, customer_id: str, amount: float):
+    event = OrderCreated(order_id, customer_id, amount)
+    await bus.publish(event)
+    return {"status": "ok"}
+```
+
+---
+
+## 📂 Конфигурация
+
+Библиотека использует YAML-файл конфигурации. Пример для каждого брокера:
+
+<details>
+<summary><b>RabbitMQ</b></summary>
+
+```yaml
+broker: rabbitmq
+host: localhost
+port: 5672
+exchange: domain_events
+max_workers: 10
+durable: false        # временная очередь (удаляется при остановке потребителя)
+```
+</details>
+
+<details>
+<summary><b>Redis</b></summary>
+
+```yaml
+broker: redis
+host: localhost
+port: 6379
+channel: domain_events
+max_workers: 10
+```
+</details>
+
+<details>
+<summary><b>NATS</b></summary>
+
+```yaml
+broker: nats
+host: localhost
+port: 4222
+subject: domain_events
+max_workers: 10
+```
+</details>
+
+Все поля, кроме `broker`, опциональны – значения по умолчанию совпадают с примерами выше.
+
+---
+
+## 🧰 CLI утилита
+
+`aioeventbus` поставляется с интерфейсом командной строки:
+
+```bash
+aioeventbus init --broker redis --output my_config.yaml
+```
+
+Опции:
+- `--broker` – выберите `rabbitmq`, `redis` или `nats`
+- `--output` – путь к выходному файлу (по умолчанию `eventbus_config.yaml`)
+- `--host`, `--port`, `--exchange`, `--channel`, `--subject`, `--max-workers` – переопределить значения по умолчанию
+
+---
+
+## 🧪 Пример с FastAPI
+
+Полный пример находится в директории [`examples/fastapi_app`](examples/fastapi_app).
+
+Запустите его:
+
+```bash
+cd examples/fastapi_app
+pip install -r requirements.txt   # fastapi, uvicorn, aioeventbus
+uvicorn main:app --reload
+```
+
+Затем выполните запросы:
+
+```bash
+curl -X POST "http://localhost:8000/orders?order_id=123&customer_id=alice&amount=99.9"
+curl -X POST "http://localhost:8000/orders/123/pay?payment_id=pay_456"
+```
+
+В терминале появятся сообщения от зарегистрированных обработчиков.
+
+---
+
+## 🏗️ Архитектура
+
+Библиотека построена вокруг абстрактного класса `EventBus`:
+
+```python
+class EventBus(ABC):
+    def handler(self, event_cls): ...
+    async def publish(self, event) -> None: ...
+    async def start_consuming(self) -> None: ...
+    async def stop_consuming(self) -> None: ...
+```
+
+Три конкретные реализации: `RabbitMQEventBus`, `RedisEventBus` и `NatsEventBus`.  
+Фабрика `create_event_bus` читает ваш конфиг и возвращает нужный экземпляр.
+
+- Потребители автоматически создают временные очереди (или подписки), так что каждый подписчик получает копию каждого события.
+- Синхронные обработчики запускаются в пуле потоков, чтобы не блокировать event loop asyncio.
+- Соединения управляются надёжно – они автоматически переподключаются при обрыве связи с брокером.
+
+---
+
+## 🤝 Участие в разработке
+
+Приветствуются любые вклады!  
+Пожалуйста, ознакомьтесь с [трекером задач](https://github.com/yourusername/aioeventbus/issues) и отправляйте pull request с понятным описанием изменений.
+
+1. Сделайте форк репозитория  
+2. Создайте ветку для новой функциональности  
+3. Установите зависимости для разработки: `pip install -e .[dev]`  
+4. Запустите тесты: `pytest`  
+5. Отправьте pull request  
+
+---
+
+## 📄 Лицензия
+
+Этот проект распространяется под лицензией **MIT** – подробности в файле [LICENSE](LICENSE).
+
+---
+
+## 🙌 Благодарности
+
+Создано с ❤️ с использованием:
+- [aio-pika](https://github.com/mosquito/aio-pika) для RabbitMQ
+- [redis-py](https://github.com/redis/redis-py) для Redis
+- [nats.py](https://github.com/nats-io/nats.py) для NATS
+
+---
+
+**Приятной событийно-ориентированной разработки!** 🚀

aioeventbus-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+# Указываем инструмент, который будет собирать пакет
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# Это имя, по которому библиотеку будут устанавливать (pip install eventbus)
+name = "aioeventbus"
+# Начните с версии 0.1.0
+version = "0.1.0"
+# Краткое описание
+description = "An async event bus for RabbitMQ, Redis, and NATS"
+# Читаем описание из README.md
+readme = "README.md"
+# Укажите минимальную версию Python, которую поддерживает ваша библиотека
+requires-python = ">=3.8"
+# Лицензия
+license = { text = "MIT" }
+# Авторы
+authors = [
+    { name = "Lumin Core", email = "lumincore1@gmail.com" },
+]
+
+# Ключевые слова для поиска на PyPI
+keywords = ["aioeventbus", "eventbus", "rabbitmq", "redis", "nats", "async", "microservices"]
+
+# Зависимости, которые нужны для работы библиотеки
+dependencies = [
+    "aio-pika>=9.0.0",
+    "redis>=5.0.0",
+    "nats-py>=2.5.0",
+    "pyyaml>=6.0"
+]
+
+# Категории, помогающие найти пакет
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Communications",
+]
+
+[project.urls]
+# Ссылки на репозиторий и другие ресурсы
+Homepage = "https://github.com/Lumin-Core/aioeventbus"
+Bug-tracker = "https://github.com/Lumin-Core/aioeventbus/issues"
+
+[tool.setuptools.packages.find]
+# Указываем, где искать код библиотеки
+where = ["src"]

aioeventbus-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aioeventbus-0.1.0/src/aioeventbus.egg-info/PKG-INFO

@@ -0,0 +1,281 @@
+Metadata-Version: 2.4
+Name: aioeventbus
+Version: 0.1.0
+Summary: An async event bus for RabbitMQ, Redis, and NATS
+Author-email: Lumin Core <lumincore1@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Lumin-Core/aioeventbus
+Project-URL: Bug-tracker, https://github.com/Lumin-Core/aioeventbus/issues
+Keywords: aioeventbus,eventbus,rabbitmq,redis,nats,async,microservices
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Communications
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aio-pika>=9.0.0
+Requires-Dist: redis>=5.0.0
+Requires-Dist: nats-py>=2.5.0
+Requires-Dist: pyyaml>=6.0
+
+# 📡 aioeventbus
+
+**Асинхронная шина событий для RabbitMQ, Redis и NATS**
+
+[![PyPI version](https://badge.fury.io/py/aioeventbus.svg)](https://badge.fury.io/py/aioeventbus)
+[![Python versions](https://img.shields.io/pypi/pyversions/aioeventbus.svg)](https://pypi.org/project/aioeventbus/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> Простая, гибкая и готовая к продакшену библиотека для обмена сообщениями между микросервисами.
+
+**aioeventbus** предоставляет единый асинхронный API для публикации и подписки на доменные события через популярные брокеры:
+- 🐰 **RabbitMQ** (fanout-обменники)
+- 🔴 **Redis** (Pub/Sub)
+- 🚀 **NATS** (базовая модель подписки)
+
+Смените брокер, отредактировав одну строку в конфиге – код приложения останется неизменным.
+
+---
+
+## ✨ Возможности
+
+- 🔌 **Независимость от брокера** – одинаковый интерфейс для RabbitMQ, Redis, NATS
+- ⚡ **Полностью асинхронно** – построено на `asyncio`, идеально для FastAPI / Sanic / aiohttp
+- 🧵 **Поддержка синхронных обработчиков** – ваши хендлеры могут быть обычными функциями; они выполняются в пуле потоков без блокировки event loop
+- 📝 **Простая регистрация через декоратор** – `@bus.handler(EventClass)`
+- 🔁 **Автоматическое переподключение** – надёжные соединения для всех брокеров
+- 🛠️ **CLI для генерации конфигов** – начните работу за секунды
+- 📦 **Минимальные зависимости** – только библиотеки для выбранного брокера
+- 👌 **Удобство использования** – единый интерфейс и фабрика `create_event_bus` скрывают различия между брокерами. Не нужно учить разные API для каждого брокера – достаточно знать один класс `EventBus`. Конфигурация через YAML или CLI делает переключение брокера делом одной строки, а встроенная обработка ошибок и автоматическое переподключение избавляют от рутины.
+
+---
+
+## 📦 Установка
+
+```bash
+pip install aioeventbus
+```
+
+Дополнительно установите клиентскую библиотеку для нужного брокера:
+- `aio-pika` для RabbitMQ
+- `redis` для Redis
+- `nats-py` для NATS
+
+---
+
+## 🚀 Быстрый старт
+
+### 1. Создайте конфигурационный файл
+
+Файл `config.yaml`:
+
+```yaml
+broker: rabbitmq        # rabbitmq, redis, nats
+host: localhost
+port: 5672              # порты по умолчанию: RabbitMQ=5672, Redis=6379, NATS=4222
+exchange: domain_events # для RabbitMQ
+max_workers: 10
+```
+
+Или сгенерируйте его через CLI:
+
+```bash
+aioeventbus init --broker nats --output config.yaml
+```
+
+### 2. Определите события домена
+
+```python
+from dataclasses import dataclass
+from aioeventbus import DomainEvent
+
+@dataclass
+class OrderCreated(DomainEvent):
+    __event_type__ = "OrderCreated"
+    order_id: str
+    customer_id: str
+    amount: float
+```
+
+### 3. Зарегистрируйте обработчики
+
+```python
+from aioeventbus import create_event_bus
+
+bus = create_event_bus("config.yaml")
+
+@bus.handler(OrderCreated)
+def notify_admin(event: OrderCreated):
+    print(f"[ADMIN] Новый заказ {event.order_id} от {event.customer_id}")
+
+@bus.handler(OrderCreated)
+def start_fulfillment(event: OrderCreated):
+    print(f"[FULFILLMENT] Обработка заказа {event.order_id}")
+```
+
+### 4. Запустите потребителя (например, в lifespan FastAPI)
+
+```python
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await bus.start_consuming()
+    yield
+    await bus.stop_consuming()
+
+app = FastAPI(lifespan=lifespan)
+```
+
+### 5. Публикуйте события из любого места
+
+```python
+@app.post("/orders")
+async def create_order(order_id: str, customer_id: str, amount: float):
+    event = OrderCreated(order_id, customer_id, amount)
+    await bus.publish(event)
+    return {"status": "ok"}
+```
+
+---
+
+## 📂 Конфигурация
+
+Библиотека использует YAML-файл конфигурации. Пример для каждого брокера:
+
+<details>
+<summary><b>RabbitMQ</b></summary>
+
+```yaml
+broker: rabbitmq
+host: localhost
+port: 5672
+exchange: domain_events
+max_workers: 10
+durable: false        # временная очередь (удаляется при остановке потребителя)
+```
+</details>
+
+<details>
+<summary><b>Redis</b></summary>
+
+```yaml
+broker: redis
+host: localhost
+port: 6379
+channel: domain_events
+max_workers: 10
+```
+</details>
+
+<details>
+<summary><b>NATS</b></summary>
+
+```yaml
+broker: nats
+host: localhost
+port: 4222
+subject: domain_events
+max_workers: 10
+```
+</details>
+
+Все поля, кроме `broker`, опциональны – значения по умолчанию совпадают с примерами выше.
+
+---
+
+## 🧰 CLI утилита
+
+`aioeventbus` поставляется с интерфейсом командной строки:
+
+```bash
+aioeventbus init --broker redis --output my_config.yaml
+```
+
+Опции:
+- `--broker` – выберите `rabbitmq`, `redis` или `nats`
+- `--output` – путь к выходному файлу (по умолчанию `eventbus_config.yaml`)
+- `--host`, `--port`, `--exchange`, `--channel`, `--subject`, `--max-workers` – переопределить значения по умолчанию
+
+---
+
+## 🧪 Пример с FastAPI
+
+Полный пример находится в директории [`examples/fastapi_app`](examples/fastapi_app).
+
+Запустите его:
+
+```bash
+cd examples/fastapi_app
+pip install -r requirements.txt   # fastapi, uvicorn, aioeventbus
+uvicorn main:app --reload
+```
+
+Затем выполните запросы:
+
+```bash
+curl -X POST "http://localhost:8000/orders?order_id=123&customer_id=alice&amount=99.9"
+curl -X POST "http://localhost:8000/orders/123/pay?payment_id=pay_456"
+```
+
+В терминале появятся сообщения от зарегистрированных обработчиков.
+
+---
+
+## 🏗️ Архитектура
+
+Библиотека построена вокруг абстрактного класса `EventBus`:
+
+```python
+class EventBus(ABC):
+    def handler(self, event_cls): ...
+    async def publish(self, event) -> None: ...
+    async def start_consuming(self) -> None: ...
+    async def stop_consuming(self) -> None: ...
+```
+
+Три конкретные реализации: `RabbitMQEventBus`, `RedisEventBus` и `NatsEventBus`.  
+Фабрика `create_event_bus` читает ваш конфиг и возвращает нужный экземпляр.
+
+- Потребители автоматически создают временные очереди (или подписки), так что каждый подписчик получает копию каждого события.
+- Синхронные обработчики запускаются в пуле потоков, чтобы не блокировать event loop asyncio.
+- Соединения управляются надёжно – они автоматически переподключаются при обрыве связи с брокером.
+
+---
+
+## 🤝 Участие в разработке
+
+Приветствуются любые вклады!  
+Пожалуйста, ознакомьтесь с [трекером задач](https://github.com/yourusername/aioeventbus/issues) и отправляйте pull request с понятным описанием изменений.
+
+1. Сделайте форк репозитория  
+2. Создайте ветку для новой функциональности  
+3. Установите зависимости для разработки: `pip install -e .[dev]`  
+4. Запустите тесты: `pytest`  
+5. Отправьте pull request  
+
+---
+
+## 📄 Лицензия
+
+Этот проект распространяется под лицензией **MIT** – подробности в файле [LICENSE](LICENSE).
+
+---
+
+## 🙌 Благодарности
+
+Создано с ❤️ с использованием:
+- [aio-pika](https://github.com/mosquito/aio-pika) для RabbitMQ
+- [redis-py](https://github.com/redis/redis-py) для Redis
+- [nats.py](https://github.com/nats-io/nats.py) для NATS
+
+---
+
+**Приятной событийно-ориентированной разработки!** 🚀

aioeventbus-0.1.0/src/aioeventbus.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+src/aioeventbus.egg-info/PKG-INFO
+src/aioeventbus.egg-info/SOURCES.txt
+src/aioeventbus.egg-info/dependency_links.txt
+src/aioeventbus.egg-info/requires.txt
+src/aioeventbus.egg-info/top_level.txt
+src/eventbus/__init__.py
+src/eventbus/base.py
+src/eventbus/events.py
+src/eventbus/exceptions.py
+src/eventbus/factory.py
+src/eventbus/brokers/__init__.py
+src/eventbus/brokers/nats.py
+src/eventbus/brokers/rabbitmq.py
+src/eventbus/brokers/radis.py

aioeventbus-0.1.0/src/aioeventbus.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aioeventbus-0.1.0/src/aioeventbus.egg-info/requires.txt

@@ -0,0 +1,4 @@
+aio-pika>=9.0.0
+redis>=5.0.0
+nats-py>=2.5.0
+pyyaml>=6.0

aioeventbus-0.1.0/src/aioeventbus.egg-info/top_level.txt

@@ -0,0 +1 @@
+eventbus

aioeventbus-0.1.0/src/eventbus/__init__.py

@@ -0,0 +1,15 @@
+from .base import EventBus
+from .brokers.nats import NatsEventBus
+from .brokers.rabbitmq import RabbitMQEventBus
+from .brokers.radis import RedisEventBus
+from .factory import create_event_bus
+from .events import DomainEvent
+
+__all__ = [
+    "EventBus",
+    "create_event_bus",
+    "DomainEvent",
+    "RabbitMQEventBus",
+    "RedisEventBus",
+    "NatsEventBus",
+]

aioeventbus-0.1.0/src/eventbus/base.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+
+class EventBus(ABC):
+    @abstractmethod
+    def handler(self, event_cls):
+        pass
+
+    @abstractmethod
+    async def publish(self, event) -> None:
+        pass
+
+    @abstractmethod
+    async def start_consuming(self) -> None:
+        pass
+
+    @abstractmethod
+    async def stop_consuming(self) -> None:
+        pass

aioeventbus-0.1.0/src/eventbus/brokers/nats.py

@@ -0,0 +1,104 @@
+import asyncio
+import json
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Dict, List, Optional, Type
+import nats
+from nats.aio.client import Client as NATSClient
+
+from aioeventbus.src.eventbus.base import EventBus
+from aioeventbus.src.eventbus.events import DomainEvent
+
+
+class NatsEventBus(EventBus):
+    def __init__(
+        self,
+        servers: str = "nats://localhost:4222",
+        subject: str = "domain_events",
+        max_workers: int = 10,
+    ) -> None:
+        self.broker_name = "NATS"
+        self.servers = servers
+        self.subject = subject
+        self._subscriptions: Dict[str, List[Callable]] = defaultdict(list)
+        self._event_classes: Dict[str, Type[DomainEvent]] = {}
+
+        # Publish connection
+        self._pub_nc: Optional[NATSClient] = None
+
+        # Consumer
+        self._sub_nc: Optional[NATSClient] = None
+        self._consumer_task: Optional[asyncio.Task] = None
+        self._stop_event = asyncio.Event()
+        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+
+    def handler(self, event_cls: Type[DomainEvent]):
+        """Декоратор для регистрации обработчиков событий."""
+        event_type = event_cls.__event_type__
+        self._event_classes[event_type] = event_cls
+
+        def decorator(func: Callable):
+            self._subscriptions[event_type].append(func)
+            return func
+
+        return decorator
+
+    async def _ensure_publish_connection(self):
+        """Гарантирует, что соединение для публикации открыто."""
+        if self._pub_nc and self._pub_nc.is_connected:
+            return
+        if self._pub_nc:
+            await self._pub_nc.close()
+        self._pub_nc = await nats.connect(servers=self.servers)
+
+    async def publish(self, event: DomainEvent) -> None:
+        """Асинхронная публикация события в NATS."""
+        await self._ensure_publish_connection()
+        message = json.dumps(event.to_dict())
+        await self._pub_nc.publish(self.subject, message.encode())
+
+    async def start_consuming(self) -> None:
+        """Запускает фоновую задачу-потребителя."""
+        if self._consumer_task and not self._consumer_task.done():
+            return
+        self._stop_event.clear()
+        self._consumer_task = asyncio.create_task(self._consume_loop())
+
+    async def _consume_loop(self) -> None:
+        """Основной цикл потребления сообщений (работает в отдельной Task)."""
+        # Отдельное соединение для подписки
+        self._sub_nc = await nats.connect(servers=self.servers)
+        try:
+            async def on_message(msg):
+                raw = json.loads(msg.data.decode())
+                event_type = raw.get("event_type")
+                data = raw.get("data", {})
+                event_cls = self._event_classes.get(event_type)
+                if event_cls is None:
+                    print(f"[WARN] Unknown event type: {event_type}")
+                    return
+                event = event_cls(**data)
+
+                # Вызываем синхронные обработчики в пуле потоков
+                loop = asyncio.get_running_loop()
+                for handler in self._subscriptions.get(event_type, []):
+                    await loop.run_in_executor(self._executor, handler, event)
+
+            # Подписка на subject (получаем все сообщения на этот subject)
+            await self._sub_nc.subscribe(self.subject, cb=on_message)
+
+            # Ожидаем сигнала остановки
+            await self._stop_event.wait()
+        finally:
+            await self._sub_nc.close()
+
+    async def stop_consuming(self) -> None:
+        """Останавливает потребителя и освобождает ресурсы."""
+        self._stop_event.set()
+        if self._consumer_task:
+            await self._consumer_task
+        if self._pub_nc:
+            await self._pub_nc.close()
+        if self._sub_nc:
+            await self._sub_nc.close()
+        self._executor.shutdown(wait=False)

aioeventbus-0.1.0/src/eventbus/brokers/rabbitmq.py

@@ -0,0 +1,115 @@
+import asyncio
+import json
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Dict, List, Optional, Type
+import aio_pika
+from aio_pika import Message, ExchangeType, connect_robust
+from aioeventbus.src.eventbus.base import EventBus
+from aioeventbus.src.eventbus.events import DomainEvent
+
+
+class RabbitMQEventBus(EventBus):
+    def __init__(
+        self,
+        host: str = "localhost",
+        exchange: str = "domain_events",
+        max_workers: int = 10
+    ) -> None:
+        self.broker_name = "RabbitMQ"
+        self.host = host
+        self.exchange_name = exchange
+        self._subscriptions: Dict[str, List[Callable]] = defaultdict(list)
+        self._event_classes: Dict[str, Type[DomainEvent]] = {}
+
+        # Publish connection
+        self._pub_connection: Optional[aio_pika.RobustConnection] = None
+        self._pub_channel: Optional[aio_pika.RobustChannel] = None
+        self._pub_exchange: Optional[aio_pika.Exchange] = None
+
+        # Consumer
+        self._consumer_task: Optional[asyncio.Task] = None
+        self._stop_event = asyncio.Event()
+        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+
+    def handler(self, event_cls: Type[DomainEvent]):
+        """Декоратор для регистрации обработчиков событий."""
+        event_type = event_cls.__event_type__
+        self._event_classes[event_type] = event_cls
+
+        def decorator(func: Callable):
+            self._subscriptions[event_type].append(func)
+            return func
+
+        return decorator
+
+    async def _ensure_publish_connection(self):
+        """Гарантирует, что соединение для публикации открыто."""
+        if self._pub_connection and not self._pub_connection.is_closed:
+            return
+        if self._pub_connection:
+            await self._pub_connection.close()
+        self._pub_connection = await connect_robust(host=self.host)
+        self._pub_channel = await self._pub_connection.channel()
+        self._pub_exchange = await self._pub_channel.declare_exchange(
+            self.exchange_name, ExchangeType.FANOUT, durable=False
+        )
+
+    async def publish(self, event: DomainEvent) -> None:
+        """Асинхронная публикация события в RabbitMQ."""
+        await self._ensure_publish_connection()
+        message = json.dumps(event.to_dict())
+        await self._pub_exchange.publish(
+            Message(body=message.encode()),
+            routing_key=""
+        )
+
+    async def start_consuming(self) -> None:
+        """Запускает фоновую задачу-потребителя."""
+        if self._consumer_task and not self._consumer_task.done():
+            return
+        self._stop_event.clear()
+        self._consumer_task = asyncio.create_task(self._consume_loop())
+
+    async def _consume_loop(self) -> None:
+        """Основной цикл потребления сообщений (работает в отдельной Task)."""
+        # Отдельное соединение для потребления
+        connection = await connect_robust(host=self.host)
+        try:
+            channel = await connection.channel()
+            exchange = await channel.declare_exchange(
+                self.exchange_name, ExchangeType.FANOUT, durable=False
+            )
+            queue = await channel.declare_queue(exclusive=True)
+            await queue.bind(exchange)
+
+            async def on_message(message: aio_pika.IncomingMessage):
+                async with message.process():
+                    raw = json.loads(message.body.decode())
+                    event_type = raw.get("event_type")
+                    data = raw.get("data", {})
+                    event_cls = self._event_classes.get(event_type)
+                    if event_cls is None:
+                        print(f"[WARN] Unknown event type: {event_type}")
+                        return
+                    event = event_cls(**data)
+
+                    # Вызываем синхронные обработчики в пуле потоков
+                    loop = asyncio.get_running_loop()
+                    for handler in self._subscriptions.get(event_type, []):
+                        await loop.run_in_executor(self._executor, handler, event)
+
+            await queue.consume(on_message)
+            # Ожидаем сигнала остановки
+            await self._stop_event.wait()
+        finally:
+            await connection.close()
+
+    async def stop_consuming(self) -> None:
+        """Останавливает потребителя и освобождает ресурсы."""
+        self._stop_event.set()
+        if self._consumer_task:
+            await self._consumer_task
+        if self._pub_connection and not self._pub_connection.is_closed:
+            await self._pub_connection.close()
+        self._executor.shutdown(wait=False)

aioeventbus-0.1.0/src/eventbus/brokers/radis.py

@@ -0,0 +1,105 @@
+import asyncio
+import json
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Dict, List, Optional, Type
+import redis.asyncio as redis
+from redis.asyncio.client import PubSub
+
+from aioeventbus.src.eventbus.base import EventBus
+from aioeventbus.src.eventbus.events import DomainEvent
+
+
+class RedisEventBus(EventBus):
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 6379,
+        channel: str = "domain_events",
+        max_workers: int = 10,
+    ) -> None:
+        self.broker_name = "Redis"
+        self.host = host
+        self.port = port
+        self.channel = channel
+        self._subscriptions: Dict[str, List[Callable]] = defaultdict(list)
+        self._event_classes: Dict[str, Type[DomainEvent]] = {}
+
+        # Пул соединений для публикации (и для подписки тоже может использоваться)
+        self._pub_redis: Optional[redis.Redis] = None
+        self._sub_redis: Optional[redis.Redis] = None
+        self._pubsub: Optional[PubSub] = None
+
+        self._consumer_task: Optional[asyncio.Task] = None
+        self._stop_event = asyncio.Event()
+        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+
+    def handler(self, event_cls: Type[DomainEvent]):
+        """Декоратор для регистрации обработчиков событий."""
+        event_type = event_cls.__event_type__
+        self._event_classes[event_type] = event_cls
+
+        def decorator(func: Callable):
+            self._subscriptions[event_type].append(func)
+            return func
+
+        return decorator
+
+    async def _ensure_publish_connection(self) -> None:
+        """Гарантирует, что соединение для публикации открыто."""
+        if self._pub_redis is not None:
+            return
+        self._pub_redis = await redis.from_url(f"redis://{self.host}:{self.port}")
+
+    async def publish(self, event: DomainEvent) -> None:
+        """Асинхронная публикация события в Redis."""
+        await self._ensure_publish_connection()
+        message = json.dumps(event.to_dict())
+        await self._pub_redis.publish(self.channel, message)
+
+    async def start_consuming(self) -> None:
+        """Запускает фоновую задачу-потребителя."""
+        if self._consumer_task and not self._consumer_task.done():
+            return
+        self._stop_event.clear()
+        self._consumer_task = asyncio.create_task(self._consume_loop())
+
+    async def _consume_loop(self) -> None:
+        """Основной цикл потребления сообщений (работает в отдельной Task)."""
+        # Отдельное соединение для подписки
+        self._sub_redis = await redis.from_url(f"redis://{self.host}:{self.port}")
+        self._pubsub = self._sub_redis.pubsub()
+        await self._pubsub.subscribe(self.channel)
+
+        try:
+            async for raw_message in self._pubsub.listen():
+                if self._stop_event.is_set():
+                    break
+                if raw_message["type"] != "message":
+                    continue
+                # raw_message["data"] — это байты
+                raw = json.loads(raw_message["data"].decode())
+                event_type = raw.get("event_type")
+                data = raw.get("data", {})
+                event_cls = self._event_classes.get(event_type)
+                if event_cls is None:
+                    print(f"[WARN] Unknown event type: {event_type}")
+                    continue
+                event = event_cls(**data)
+
+                loop = asyncio.get_running_loop()
+                for handler in self._subscriptions.get(event_type, []):
+                    await loop.run_in_executor(self._executor, handler, event)
+        finally:
+            await self._pubsub.unsubscribe(self.channel)
+            await self._pubsub.close()
+            await self._sub_redis.close()
+
+    async def stop_consuming(self) -> None:
+        """Останавливает потребителя и освобождает ресурсы."""
+        self._stop_event.set()
+        if self._consumer_task:
+            await self._consumer_task
+        if self._pub_redis:
+            await self._pub_redis.close()
+        self._executor.shutdown(wait=False)

aioeventbus-0.1.0/src/eventbus/events.py

@@ -0,0 +1,13 @@
+from dataclasses import asdict
+from typing import Any
+
+
+class DomainEvent:
+    __event_type__: str
+
+    @property
+    def event_type(self) -> str:
+        return self.__event_type__
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"event_type": self.event_type, "data": asdict(self)}

aioeventbus-0.1.0/src/eventbus/factory.py

@@ -0,0 +1,42 @@
+import yaml
+from pathlib import Path
+from aioeventbus.src.eventbus.brokers.nats import NatsEventBus
+from aioeventbus.src.eventbus.brokers.rabbitmq import RabbitMQEventBus
+from aioeventbus.src.eventbus.brokers.radis import RedisEventBus
+
+
+def load_config(path: Path):
+    if not path.exists():
+        raise FileNotFoundError(f"Config file not found: {path}")
+    with open(path) as f:
+        return yaml.safe_load(f)
+
+
+def create_event_bus(config_path=None):
+    if config_path is None:
+        config_path = Path.cwd() / "config.yaml"
+    cfg = load_config(config_path)
+    broker = cfg["broker"]
+
+    if broker == "rabbitmq":
+        return RabbitMQEventBus(
+            host=cfg.get("host", "localhost"),
+            exchange=cfg.get("exchange", "domain_events"),
+            max_workers=cfg.get("max_workers", 10),
+        )
+    elif broker == "redis":
+        return RedisEventBus(
+            host=cfg.get("host", "localhost"),
+            port=cfg.get("port", 6379),
+            channel=cfg.get("channel", "domain_events"),
+            max_workers=cfg.get("max_workers", 10),
+        )
+    elif broker == "nats":
+        servers = f"nats://{cfg.get('host', 'localhost')}:{cfg.get('port', 4222)}"
+        return NatsEventBus(
+            servers=servers,
+            subject=cfg.get("subject", "domain_events"),
+            max_workers=cfg.get("max_workers", 10),
+        )
+    else:
+        raise ValueError(f"Unknown broker: {broker}")