streambus 0.1.0__tar.gz

streambus-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,23 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v4
+
+      - run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

streambus-0.1.0/AGENTS.md

@@ -0,0 +1,116 @@
+# streambus
+
+Librería Python para consumir y publicar eventos sobre Redis Streams. Agnóstica de framework.
+
+<!-- rule:framework-agnostic -->
+## Sin dependencias de framework
+
+streambus no importa Django, FastAPI, Celery ni ningún otro framework. Solo depende de `redis-py`.
+
+El caller es responsable de resolver los valores de configuración (variables de entorno, Django settings, archivos de config) y pasarlos como tipos primitivos a los objetos de streambus. La librería no sabe de dónde vienen.
+
+Nunca añadir imports de frameworks externos al paquete `streambus/`.
+<!-- /rule:framework-agnostic -->
+
+<!-- rule:event-contract -->
+## Contrato de eventos
+
+Todo evento debe extender `StreamBusEvent`. El publisher rechaza cualquier objeto que no sea una instancia de `StreamBusEvent`. El listener valida en construcción que `event_class` sea una subclase.
+
+```python
+from dataclasses import dataclass
+from streambus import StreamBusEvent
+
+@dataclass(kw_only=True)
+class ClientEvent(StreamBusEvent):
+    client_id: str
+    name: str
+```
+
+`StreamBusEvent` define dos campos base:
+- `event_type: str` — obligatorio, identifica el tipo de evento.
+- `occurred_at: str` — timestamp ISO 8601, se genera automáticamente si no se pasa.
+
+Cualquier campo adicional lo define la subclase. Los campos del stream que no estén declarados en la subclase se descartan en `from_dict`.
+<!-- /rule:event-contract -->
+
+<!-- rule:no-field-defaults -->
+## Sin valores por defecto en campos de dominio
+
+Los campos de las subclases de `StreamBusEvent` no llevan valor por defecto. El caller debe pasarlos explícitamente. Esto fuerza que los eventos sean siempre completos y evita estados ambiguos.
+
+Correcto:
+```python
+@dataclass(kw_only=True)
+class ClientEvent(StreamBusEvent):
+    client_id: str
+    name: str
+    is_active: str
+```
+
+Incorrecto:
+```python
+@dataclass(kw_only=True)
+class ClientEvent(StreamBusEvent):
+    client_id: str = ""   # ← no
+    name: str = ""        # ← no
+```
+
+La excepción son los campos de configuración interna de la librería: `occurred_at` en `StreamBusEvent` y los timeouts de socket en `RedisConfig`. Estos tienen defaults porque son detalles de infraestructura, no datos de dominio.
+<!-- /rule:no-field-defaults -->
+
+<!-- rule:kw-only -->
+## kw_only=True obligatorio en todas las clases de evento
+
+`StreamBusEvent` usa `@dataclass(kw_only=True)`. Todas las subclases deben declararse también con `@dataclass(kw_only=True)`.
+
+Esto es necesario porque `StreamBusEvent` tiene `occurred_at` con default. Sin `kw_only=True`, Python rechaza subclases que añadan campos requeridos después de un campo con default.
+
+```python
+@dataclass(kw_only=True)          # obligatorio
+class ClientEvent(StreamBusEvent):
+    client_id: str
+    name: str
+```
+<!-- /rule:kw-only -->
+
+<!-- rule:config-naming -->
+## Nombres de campos en objetos de configuración
+
+Los campos dentro de un objeto de configuración tipado no repiten el contexto que ya da el nombre de la clase.
+
+Correcto: `RedisConfig.url` — el tipo ya establece que es Redis.
+
+Incorrecto: `RedisConfig.redis_url` — repite "redis" innecesariamente.
+
+Aplicar esta regla a cualquier objeto de configuración nuevo que se añada a la librería.
+<!-- /rule:config-naming -->
+
+<!-- rule:local-event-class -->
+## Cada consumer define su propia clase de evento
+
+Los consumers no comparten la definición de `ClientEvent` con el publisher ni entre sí. Cada uno declara únicamente los campos que necesita. Los campos del stream que no aparezcan en la clase local se descartan automáticamente en `from_dict`.
+
+Esto mantiene el acoplamiento al mínimo: un consumer de studio no necesita conocer que curly publica `slug` si no lo usa.
+
+```python
+# studio solo necesita estos tres
+@dataclass(kw_only=True)
+class ClientEvent(StreamBusEvent):
+    client_id: str
+    name: str
+    is_active: str
+```
+<!-- /rule:local-event-class -->
+
+<!-- rule:exceptions -->
+## Jerarquía de excepciones
+
+Usar siempre las excepciones del módulo `streambus.exceptions`:
+
+- `StreambusError` — base de todas las excepciones de la librería.
+- `ConfigurationError` — parámetros inválidos o ausentes en construcción de `EventListener` o `EventPublisher`.
+- `EventValidationError` — evento inválido en `publish()` (no es `StreamBusEvent`, `event_type` vacío).
+
+No lanzar `ValueError` ni `TypeError` directamente desde código de la librería. Si se añade nueva lógica de validación, subclasificar desde `StreambusError`.
+<!-- /rule:exceptions -->

streambus-0.1.0/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

streambus-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jose Meira
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

streambus-0.1.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.5
+Name: streambus
+Version: 0.1.0
+Summary: Lightweight Redis Streams event listener with a clean callback API
+Project-URL: Homepage, https://github.com/jmeiracorbal/streambus
+Project-URL: Repository, https://github.com/jmeiracorbal/streambus
+Project-URL: Issues, https://github.com/jmeiracorbal/streambus/issues
+Author-email: Jose Meira <jmeiracorbal@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Jose Meira
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: consumer,event-bus,events,producer,pubsub,redis,streams
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.11
+Requires-Dist: redis>=5.0
+Description-Content-Type: text/markdown
+
+# streambus
+
+[![PyPI version](https://img.shields.io/pypi/v/streambus?color=e8445a&label=pypi)](https://pypi.org/project/streambus/)
+[![Python](https://img.shields.io/badge/python-3.11%2B-4584b6?logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-22c55e)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-18%20passed-22c55e)](#development)
+
+Lightweight event bus over Redis Streams. Define typed events, publish from one service, consume in others without boilerplate or framework dependencies.
+
+## Install
+
+```bash
+pip install streambus
+```
+
+```bash
+uv add streambus
+```
+
+## Quick start
+
+Define an event:
+
+```python
+from dataclasses import dataclass
+from streambus import StreamBusEvent
+
+@dataclass(kw_only=True)
+class OrderCreated(StreamBusEvent):
+    order_id: str
+    customer_id: str
+    total: str
+```
+
+Publish it:
+
+```python
+from streambus import EventPublisher, RedisConfig
+
+publisher = EventPublisher(
+    stream="orders:events",
+    config=RedisConfig(url="redis://localhost:6379"),
+)
+
+publisher.publish(
+    OrderCreated(
+        event_type="order.created",
+        order_id="ord_123",
+        customer_id="cust_456",
+        total="99.90",
+    )
+)
+```
+
+Consume it:
+
+```python
+from streambus import EventListener, RedisConfig
+
+def handle_order(event: OrderCreated) -> None:
+    print(f"New order {event.order_id}: total {event.total}")
+
+EventListener(
+    stream="orders:events",
+    group="notifications",
+    handler=handle_order,
+    event_class=OrderCreated,
+    config=RedisConfig(url="redis://localhost:6379"),
+).run()
+```
+
+## How it works
+
+streambus uses [Redis Streams](https://redis.io/docs/data-types/streams/) for transport: persistent storage, consumer groups, and at-least-once delivery. The library manages group creation, the blocking read loop, message acknowledgement, and automatic reconnection on connection loss.
+
+Each consumer group processes events independently. A message published to a stream reaches every group exactly once.
+
+## Events
+
+All events extend `StreamBusEvent`:
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `event_type` | `str` | yes | Identifies the event. Convention: `noun.verb` |
+| `occurred_at` | `str` | no | ISO 8601 timestamp. Auto-set on creation. |
+
+Subclasses declare only the fields they need. Unknown fields arriving from the stream are silently discarded — each consumer maps what it uses, nothing more.
+
+Both `StreamBusEvent` and its subclasses must use `@dataclass(kw_only=True)`. This is required: the base class has a field with a default (`occurred_at`), and `kw_only=True` prevents the ordering conflict that would otherwise block subclasses from adding required fields.
+
+## Configuration
+
+**RedisConfig**
+
+```python
+RedisConfig(
+    url="redis://localhost:6379",  # required
+    socket_timeout=None,           # None = no timeout (correct for blocking reads)
+    socket_connect_timeout=5.0,    # seconds to wait on initial connect
+)
+```
+
+**EventListener**
+
+```python
+EventListener(
+    stream="stream:name",     # required
+    group="consumer-group",   # required
+    handler=my_handler,       # required — callable(event) -> None
+    event_class=MyEvent,      # required — must subclass StreamBusEvent
+    config=RedisConfig(...),  # required
+    consumer=None,            # defaults to "{group}-1"
+    batch_size=10,
+    block_ms=5000,
+    retry_delay=3.0,
+)
+```
+
+**EventPublisher**
+
+```python
+EventPublisher(
+    stream="stream:name",    # required
+    config=RedisConfig(...), # required
+)
+```
+
+## Exceptions
+
+| Exception | When |
+|---|---|
+| `ConfigurationError` | Invalid or missing parameters at construction time |
+| `EventValidationError` | `publish()` receives a non-`StreamBusEvent` or empty `event_type` |
+| `StreambusError` | Base class for all streambus exceptions |
+
+## Development
+
+```bash
+git clone https://github.com/yourorg/streambus
+cd streambus
+uv sync --group dev
+uv run pytest tests/ -v
+```
+
+Run the example (requires Docker):
+
+```bash
+cd example
+docker compose up -d        # start Redis
+uv sync
+uv run python consume.py    # terminal 1
+uv run python publish.py    # terminal 2
+```
+
+## License
+
+MIT

streambus-0.1.0/README.md

@@ -0,0 +1,157 @@
+# streambus
+
+[![PyPI version](https://img.shields.io/pypi/v/streambus?color=e8445a&label=pypi)](https://pypi.org/project/streambus/)
+[![Python](https://img.shields.io/badge/python-3.11%2B-4584b6?logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-22c55e)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-18%20passed-22c55e)](#development)
+
+Lightweight event bus over Redis Streams. Define typed events, publish from one service, consume in others without boilerplate or framework dependencies.
+
+## Install
+
+```bash
+pip install streambus
+```
+
+```bash
+uv add streambus
+```
+
+## Quick start
+
+Define an event:
+
+```python
+from dataclasses import dataclass
+from streambus import StreamBusEvent
+
+@dataclass(kw_only=True)
+class OrderCreated(StreamBusEvent):
+    order_id: str
+    customer_id: str
+    total: str
+```
+
+Publish it:
+
+```python
+from streambus import EventPublisher, RedisConfig
+
+publisher = EventPublisher(
+    stream="orders:events",
+    config=RedisConfig(url="redis://localhost:6379"),
+)
+
+publisher.publish(
+    OrderCreated(
+        event_type="order.created",
+        order_id="ord_123",
+        customer_id="cust_456",
+        total="99.90",
+    )
+)
+```
+
+Consume it:
+
+```python
+from streambus import EventListener, RedisConfig
+
+def handle_order(event: OrderCreated) -> None:
+    print(f"New order {event.order_id}: total {event.total}")
+
+EventListener(
+    stream="orders:events",
+    group="notifications",
+    handler=handle_order,
+    event_class=OrderCreated,
+    config=RedisConfig(url="redis://localhost:6379"),
+).run()
+```
+
+## How it works
+
+streambus uses [Redis Streams](https://redis.io/docs/data-types/streams/) for transport: persistent storage, consumer groups, and at-least-once delivery. The library manages group creation, the blocking read loop, message acknowledgement, and automatic reconnection on connection loss.
+
+Each consumer group processes events independently. A message published to a stream reaches every group exactly once.
+
+## Events
+
+All events extend `StreamBusEvent`:
+
+| Field | Type | Required | Notes |
+|---|---|---|---|
+| `event_type` | `str` | yes | Identifies the event. Convention: `noun.verb` |
+| `occurred_at` | `str` | no | ISO 8601 timestamp. Auto-set on creation. |
+
+Subclasses declare only the fields they need. Unknown fields arriving from the stream are silently discarded — each consumer maps what it uses, nothing more.
+
+Both `StreamBusEvent` and its subclasses must use `@dataclass(kw_only=True)`. This is required: the base class has a field with a default (`occurred_at`), and `kw_only=True` prevents the ordering conflict that would otherwise block subclasses from adding required fields.
+
+## Configuration
+
+**RedisConfig**
+
+```python
+RedisConfig(
+    url="redis://localhost:6379",  # required
+    socket_timeout=None,           # None = no timeout (correct for blocking reads)
+    socket_connect_timeout=5.0,    # seconds to wait on initial connect
+)
+```
+
+**EventListener**
+
+```python
+EventListener(
+    stream="stream:name",     # required
+    group="consumer-group",   # required
+    handler=my_handler,       # required — callable(event) -> None
+    event_class=MyEvent,      # required — must subclass StreamBusEvent
+    config=RedisConfig(...),  # required
+    consumer=None,            # defaults to "{group}-1"
+    batch_size=10,
+    block_ms=5000,
+    retry_delay=3.0,
+)
+```
+
+**EventPublisher**
+
+```python
+EventPublisher(
+    stream="stream:name",    # required
+    config=RedisConfig(...), # required
+)
+```
+
+## Exceptions
+
+| Exception | When |
+|---|---|
+| `ConfigurationError` | Invalid or missing parameters at construction time |
+| `EventValidationError` | `publish()` receives a non-`StreamBusEvent` or empty `event_type` |
+| `StreambusError` | Base class for all streambus exceptions |
+
+## Development
+
+```bash
+git clone https://github.com/yourorg/streambus
+cd streambus
+uv sync --group dev
+uv run pytest tests/ -v
+```
+
+Run the example (requires Docker):
+
+```bash
+cd example
+docker compose up -d        # start Redis
+uv sync
+uv run python consume.py    # terminal 1
+uv run python publish.py    # terminal 2
+```
+
+## License
+
+MIT

streambus-0.1.0/example/compose.yml

@@ -0,0 +1,5 @@
+services:
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"

streambus-0.1.0/example/consume.py

@@ -0,0 +1,38 @@
+"""
+Listen for client events and print them.
+
+Usage:
+    python consume.py
+"""
+import logging
+from dataclasses import dataclass
+
+from streambus import EventListener, RedisConfig, StreamBusEvent
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+
+@dataclass
+class ClientEvent(StreamBusEvent):
+    client_id: str = ""
+    name: str = ""
+    slug: str = ""
+    is_active: str = ""
+
+
+def handle(event: ClientEvent) -> None:
+    print(f"  client_id : {event.client_id}")
+    print(f"  name      : {event.name}")
+    print(f"  slug      : {event.slug}")
+    print(f"  is_active : {event.is_active}")
+    print(f"  occurred  : {event.occurred_at}")
+    print()
+
+
+EventListener(
+    stream="mynps:clients:events",
+    group="example",
+    handler=handle,
+    event_class=ClientEvent,
+    config=RedisConfig(url="redis://localhost:6379"),
+).run()

streambus-0.1.0/example/publish.py

@@ -0,0 +1,42 @@
+"""
+Send test client events to the Redis stream.
+
+Usage:
+    python publish.py                   # sends 3 predefined events
+    python publish.py "My Client" my-client
+"""
+import sys
+import uuid
+from datetime import datetime, timezone
+
+import redis
+
+STREAM = "mynps:clients:events"
+r = redis.from_url("redis://localhost:6379")
+
+
+def publish(name: str, slug: str, is_active: bool = True) -> bytes:
+    payload = {
+        "event_type": "client.updated",
+        "client_id": str(uuid.uuid4()),
+        "name": name,
+        "slug": slug,
+        "is_active": str(is_active),
+        "occurred_at": datetime.now(timezone.utc).isoformat(),
+    }
+    return r.xadd(STREAM, payload)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 3:
+        events = [(sys.argv[1], sys.argv[2])]
+    else:
+        events = [
+            ("Acme Corp", "acme-corp"),
+            ("Beta Ltd", "beta-ltd"),
+            ("Gamma SA", "gamma-sa"),
+        ]
+
+    for name, slug in events:
+        msg_id = publish(name, slug)
+        print(f"→ {name}  [{msg_id.decode()}]")

streambus-0.1.0/example/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "streambus-example"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = ["streambus", "redis>=5.0"]
+
+[tool.uv.sources]
+streambus = { path = "..", editable = true }

streambus-0.1.0/example/uv.lock

@@ -0,0 +1,57 @@
+version = 1
+revision = 2
+requires-python = ">=3.11"
+
+[[package]]
+name = "async-timeout"
+version = "5.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" },
+]
+
+[[package]]
+name = "redis"
+version = "8.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/99/604f0b666d4c616d891cf77ebb9db6bb21601344c051aebf1b72b9ff915f/redis-8.1.0.tar.gz", hash = "sha256:6e1a19beef9225c83efd689c7e6b7da2d5215b1f42cd13b7fc3714d0a09c7b25", size = 5254356, upload-time = "2026-07-30T08:51:00.269Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/9d/c5731f6e3608663d4d3656fd8d3aecee8b509c3082818f5a13eae925baea/redis-8.1.0-py3-none-any.whl", hash = "sha256:a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb", size = 560618, upload-time = "2026-07-30T08:50:58.497Z" },
+]
+
+[[package]]
+name = "streambus"
+version = "0.1.0"
+source = { editable = "../" }
+dependencies = [
+    { name = "redis" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "redis", specifier = ">=5.0" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "fakeredis" },
+    { name = "pytest" },
+    { name = "pytest-mock" },
+]
+
+[[package]]
+name = "streambus-example"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "redis" },
+    { name = "streambus" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "redis", specifier = ">=5.0" },
+    { name = "streambus", editable = "../" },
+]

streambus-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "streambus"
+version = "0.1.0"
+description = "Lightweight Redis Streams event listener with a clean callback API"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+authors = [{ name = "Jose Meira", email = "jmeiracorbal@gmail.com" }]
+keywords = ["redis", "streams", "event-bus", "events", "pubsub", "consumer", "producer"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: System :: Distributed Computing",
+]
+dependencies = ["redis>=5.0"]
+
+[project.urls]
+Homepage = "https://github.com/jmeiracorbal/streambus"
+Repository = "https://github.com/jmeiracorbal/streambus"
+Issues = "https://github.com/jmeiracorbal/streambus/issues"
+
+[dependency-groups]
+dev = ["pytest", "pytest-mock", "fakeredis"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+

streambus-0.1.0/streambus/__init__.py

@@ -0,0 +1,16 @@
+from .config import RedisConfig
+from .event import StreamBusEvent
+from .exceptions import ConfigurationError, EventValidationError, StreambusError
+from .listener import EventListener
+from .publisher import EventPublisher
+
+__all__ = [
+    "EventListener",
+    "EventPublisher",
+    "RedisConfig",
+    "StreamBusEvent",
+    "StreambusError",
+    "ConfigurationError",
+    "EventValidationError",
+]
+__version__ = "0.1.0"

streambus-0.1.0/streambus/config.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class RedisConfig:
+    url: str
+    socket_timeout: float | None = field(default=None)
+    socket_connect_timeout: float | None = field(default=5.0)

streambus-0.1.0/streambus/event.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass, asdict, field, fields as dc_fields
+from datetime import datetime, timezone
+
+
+@dataclass(kw_only=True)
+class StreamBusEvent:
+    event_type: str
+    occurred_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+    def to_dict(self) -> dict[str, str]:
+        return {k: str(v) for k, v in asdict(self).items()}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, str]) -> "StreamBusEvent":
+        known = {f.name for f in dc_fields(cls)}
+        return cls(**{k: v for k, v in data.items() if k in known})

streambus-0.1.0/streambus/exceptions.py

@@ -0,0 +1,10 @@
+class StreambusError(Exception):
+    pass
+
+
+class ConfigurationError(StreambusError):
+    pass
+
+
+class EventValidationError(StreambusError):
+    pass

streambus-0.1.0/streambus/listener.py

@@ -0,0 +1,94 @@
+import logging
+import time
+from typing import Callable
+
+import redis as redis_lib
+
+from streambus.config import RedisConfig
+from streambus.event import StreamBusEvent
+from streambus.exceptions import ConfigurationError
+
+logger = logging.getLogger(__name__)
+
+
+class EventListener:
+    def __init__(
+        self,
+        stream: str,
+        group: str,
+        handler: Callable[[StreamBusEvent], None],
+        event_class: type[StreamBusEvent],
+        config: RedisConfig,
+        consumer: str | None = None,
+        batch_size: int = 10,
+        block_ms: int = 5000,
+        retry_delay: float = 3.0,
+    ):
+        if not stream:
+            raise ConfigurationError("stream is required")
+        if not group:
+            raise ConfigurationError("group is required")
+        if not callable(handler):
+            raise ConfigurationError("handler must be callable")
+        if not (isinstance(event_class, type) and issubclass(event_class, StreamBusEvent)):
+            raise ConfigurationError("event_class must be a subclass of StreamBusEvent")
+        if not isinstance(config, RedisConfig):
+            raise ConfigurationError("config must be a RedisConfig instance")
+        if not config.url:
+            raise ConfigurationError("config.url is required")
+
+        self.stream = stream
+        self.group = group
+        self.handler = handler
+        self.event_class = event_class
+        self.config = config
+        self.consumer = consumer or f"{group}-1"
+        self.batch_size = batch_size
+        self.block_ms = block_ms
+        self.retry_delay = retry_delay
+
+    def run(self) -> None:
+        r = self._connect()
+        self._ensure_group(r)
+        logger.info("[%s] listening on %s", self.group, self.stream)
+
+        while True:
+            try:
+                results = r.xreadgroup(
+                    self.group,
+                    self.consumer,
+                    {self.stream: ">"},
+                    count=self.batch_size,
+                    block=self.block_ms,
+                )
+                for _stream, messages in (results or []):
+                    for msg_id, data in messages:
+                        try:
+                            event = self.event_class.from_dict(data)
+                            self.handler(event)
+                            r.xack(self.stream, self.group, msg_id)
+                        except Exception:
+                            logger.exception("error processing message %s", msg_id)
+            except redis_lib.exceptions.ConnectionError:
+                logger.warning(
+                    "[%s] redis connection lost, retrying in %.1fs",
+                    self.group,
+                    self.retry_delay,
+                )
+                time.sleep(self.retry_delay)
+                r = self._connect()
+
+    def _connect(self) -> redis_lib.Redis:
+        return redis_lib.from_url(
+            self.config.url,
+            decode_responses=True,
+            socket_timeout=self.config.socket_timeout,
+            socket_connect_timeout=self.config.socket_connect_timeout,
+        )
+
+    def _ensure_group(self, r: redis_lib.Redis) -> None:
+        try:
+            r.xgroup_create(self.stream, self.group, id="0", mkstream=True)
+        except redis_lib.exceptions.ResponseError as exc:
+            if "BUSYGROUP" not in str(exc):
+                raise

streambus-0.1.0/streambus/publisher.py

@@ -0,0 +1,40 @@
+import logging
+
+import redis as redis_lib
+
+from streambus.config import RedisConfig
+from streambus.event import StreamBusEvent
+from streambus.exceptions import ConfigurationError, EventValidationError
+
+logger = logging.getLogger(__name__)
+
+
+class EventPublisher:
+    def __init__(self, stream: str, config: RedisConfig):
+        if not stream:
+            raise ConfigurationError("stream is required")
+        if not isinstance(config, RedisConfig):
+            raise ConfigurationError("config must be a RedisConfig instance")
+        if not config.url:
+            raise ConfigurationError("config.url is required")
+
+        self.stream = stream
+        self.config = config
+        self._redis: redis_lib.Redis | None = None
+
+    def publish(self, event: StreamBusEvent) -> None:
+        if not isinstance(event, StreamBusEvent):
+            raise EventValidationError("event must be a StreamBusEvent instance")
+        if not event.event_type:
+            raise EventValidationError("event.event_type is required")
+
+        self._connect().xadd(self.stream, event.to_dict())
+
+    def _connect(self) -> redis_lib.Redis:
+        if self._redis is None:
+            self._redis = redis_lib.from_url(
+                self.config.url,
+                socket_timeout=self.config.socket_timeout,
+                socket_connect_timeout=self.config.socket_connect_timeout,
+            )
+        return self._redis

streambus-0.1.0/tests/test_event.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+
+import pytest
+
+from streambus import StreamBusEvent
+
+
+@dataclass(kw_only=True)
+class SampleEvent(StreamBusEvent):
+    name: str
+    value: str
+
+
+class TestStreamBusEvent:
+    def test_to_dict_returns_all_fields_as_strings(self):
+        event = SampleEvent(event_type="sample.created", name="Acme", value="42")
+        d = event.to_dict()
+        assert d["event_type"] == "sample.created"
+        assert d["name"] == "Acme"
+        assert d["value"] == "42"
+        assert all(isinstance(v, str) for v in d.values())
+
+    def test_to_dict_includes_occurred_at(self):
+        event = SampleEvent(event_type="sample.created", name="Acme", value="1")
+        d = event.to_dict()
+        assert "occurred_at" in d
+        assert d["occurred_at"] != ""
+
+    def test_from_dict_maps_known_fields(self):
+        data = {"event_type": "sample.created", "name": "Acme", "value": "42", "occurred_at": "2026-01-01T00:00:00+00:00"}
+        event = SampleEvent.from_dict(data)
+        assert isinstance(event, SampleEvent)
+        assert event.event_type == "sample.created"
+        assert event.name == "Acme"
+        assert event.value == "42"
+
+    def test_from_dict_ignores_unknown_fields(self):
+        data = {"event_type": "sample.created", "name": "Acme", "value": "1", "unknown": "ignored"}
+        event = SampleEvent.from_dict(data)
+        assert not hasattr(event, "unknown")
+
+    def test_from_dict_missing_required_field_raises(self):
+        data = {"event_type": "sample.created", "name": "Acme"}  # value missing
+        with pytest.raises(TypeError):
+            SampleEvent.from_dict(data)

streambus-0.1.0/tests/test_listener.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass
+from unittest.mock import patch
+
+import fakeredis
+import pytest
+
+from streambus import EventListener, RedisConfig, StreamBusEvent
+from streambus.exceptions import ConfigurationError
+
+
+@dataclass(kw_only=True)
+class SampleEvent(StreamBusEvent):
+    name: str
+
+
+@pytest.fixture
+def config():
+    return RedisConfig(url="redis://localhost:6379")
+
+
+@pytest.fixture
+def fake_redis():
+    return fakeredis.FakeRedis(decode_responses=True)
+
+
+class TestEventListenerValidation:
+    def test_empty_stream_raises(self, config):
+        with pytest.raises(ConfigurationError, match="stream"):
+            EventListener(stream="", group="g", handler=lambda e: None, event_class=SampleEvent, config=config)
+
+    def test_empty_group_raises(self, config):
+        with pytest.raises(ConfigurationError, match="group"):
+            EventListener(stream="s", group="", handler=lambda e: None, event_class=SampleEvent, config=config)
+
+    def test_handler_not_callable_raises(self, config):
+        with pytest.raises(ConfigurationError, match="handler"):
+            EventListener(stream="s", group="g", handler="not_callable", event_class=SampleEvent, config=config)
+
+    def test_event_class_not_subclass_raises(self, config):
+        with pytest.raises(ConfigurationError, match="StreamBusEvent"):
+            EventListener(stream="s", group="g", handler=lambda e: None, event_class=dict, config=config)
+
+    def test_invalid_config_type_raises(self):
+        with pytest.raises(ConfigurationError, match="config"):
+            EventListener(stream="s", group="g", handler=lambda e: None, event_class=SampleEvent, config="bad")
+
+    def test_empty_config_url_raises(self):
+        with pytest.raises(ConfigurationError, match="config.url"):
+            EventListener(stream="s", group="g", handler=lambda e: None, event_class=SampleEvent, config=RedisConfig(url=""))
+
+
+class TestEventListenerIntegration:
+    def test_handler_receives_typed_event(self, config, fake_redis):
+        received: list[SampleEvent] = []
+
+        listener = EventListener(
+            stream="test:events",
+            group="test",
+            handler=received.append,
+            event_class=SampleEvent,
+            config=config,
+        )
+
+        fake_redis.xadd("test:events", {"event_type": "sample.created", "name": "Acme", "occurred_at": "2026-01-01T00:00:00+00:00"})
+
+        with patch.object(listener, "_connect", return_value=fake_redis):
+            listener._ensure_group(fake_redis)
+            results = fake_redis.xreadgroup("test", "test-1", {"test:events": ">"}, count=1, block=0)
+            for _stream, messages in (results or []):
+                for msg_id, data in messages:
+                    event = listener.event_class.from_dict(data)
+                    listener.handler(event)
+                    fake_redis.xack("test:events", "test", msg_id)
+
+        assert len(received) == 1
+        assert isinstance(received[0], SampleEvent)
+        assert received[0].name == "Acme"
+
+    def test_unknown_stream_fields_are_ignored(self, config, fake_redis):
+        received: list[SampleEvent] = []
+
+        listener = EventListener(
+            stream="test:events",
+            group="test",
+            handler=received.append,
+            event_class=SampleEvent,
+            config=config,
+        )
+
+        fake_redis.xadd("test:events", {"event_type": "sample.created", "name": "Beta", "occurred_at": "2026-01-01T00:00:00+00:00", "extra_field": "ignored"})
+
+        with patch.object(listener, "_connect", return_value=fake_redis):
+            listener._ensure_group(fake_redis)
+            results = fake_redis.xreadgroup("test", "test-1", {"test:events": ">"}, count=1, block=0)
+            for _stream, messages in (results or []):
+                for msg_id, data in messages:
+                    event = listener.event_class.from_dict(data)
+                    listener.handler(event)
+
+        assert received[0].name == "Beta"
+        assert not hasattr(received[0], "extra_field")

streambus-0.1.0/tests/test_publisher.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+from unittest.mock import MagicMock
+
+import pytest
+
+from streambus import EventPublisher, RedisConfig, StreamBusEvent
+from streambus.exceptions import ConfigurationError, EventValidationError
+
+
+@dataclass(kw_only=True)
+class SampleEvent(StreamBusEvent):
+    name: str
+
+
+@pytest.fixture
+def config():
+    return RedisConfig(url="redis://localhost:6379")
+
+
+class TestEventPublisherValidation:
+    def test_empty_stream_raises(self, config):
+        with pytest.raises(ConfigurationError, match="stream"):
+            EventPublisher(stream="", config=config)
+
+    def test_invalid_config_raises(self):
+        with pytest.raises(ConfigurationError, match="config"):
+            EventPublisher(stream="s", config="bad")
+
+    def test_non_event_raises_on_publish(self, config):
+        publisher = EventPublisher(stream="test:events", config=config)
+        with pytest.raises(EventValidationError, match="StreamBusEvent"):
+            publisher.publish({"event_type": "bad"})  # type: ignore
+
+    def test_missing_event_type_raises_on_publish(self, config):
+        publisher = EventPublisher(stream="test:events", config=config)
+        with pytest.raises(EventValidationError, match="event_type"):
+            publisher.publish(SampleEvent(event_type="", name="Acme"))
+
+
+class TestEventPublisherIntegration:
+    def test_publish_calls_xadd(self, config):
+        mock_redis = MagicMock()
+        publisher = EventPublisher(stream="test:events", config=config)
+        publisher._redis = mock_redis
+
+        event = SampleEvent(event_type="sample.created", name="Acme")
+        publisher.publish(event)
+
+        mock_redis.xadd.assert_called_once_with("test:events", event.to_dict())

streambus-0.1.0/uv.lock

@@ -0,0 +1,144 @@
+version = 1
+revision = 2
+requires-python = ">=3.11"
+
+[[package]]
+name = "async-timeout"
+version = "5.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "fakeredis"
+version = "2.37.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "redis" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/95/5e/fce3355d20d37dc18f7f4c422653ac69cabffa019afaaf607e26704fb829/fakeredis-2.37.1.tar.gz", hash = "sha256:9045851b0a9fe56312696aadc82435141aa43a193cab462d372c8fb583a7c087", size = 238182, upload-time = "2026-08-18T15:22:01.676Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/e0/fe1c760abd9e9cb5dfbce057b6582cb1ac36dfd8b5ce202e1445605c922d/fakeredis-2.37.1-py3-none-any.whl", hash = "sha256:f15c41be151c1e9206416dece764369a4dedb6b1341df3734c3c2c000e405508", size = 152738, upload-time = "2026-08-18T15:22:00.1Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-mock"
+version = "3.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },
+]
+
+[[package]]
+name = "redis"
+version = "8.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "async-timeout", marker = "python_full_version < '3.11.3'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/99/604f0b666d4c616d891cf77ebb9db6bb21601344c051aebf1b72b9ff915f/redis-8.1.0.tar.gz", hash = "sha256:6e1a19beef9225c83efd689c7e6b7da2d5215b1f42cd13b7fc3714d0a09c7b25", size = 5254356, upload-time = "2026-07-30T08:51:00.269Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/9d/c5731f6e3608663d4d3656fd8d3aecee8b509c3082818f5a13eae925baea/redis-8.1.0-py3-none-any.whl", hash = "sha256:a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb", size = 560618, upload-time = "2026-07-30T08:50:58.497Z" },
+]
+
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
+]
+
+[[package]]
+name = "streambus"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "redis" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "fakeredis" },
+    { name = "pytest" },
+    { name = "pytest-mock" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "redis", specifier = ">=5.0" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "fakeredis" },
+    { name = "pytest" },
+    { name = "pytest-mock" },
+]