broadcaster-ng 0.4.0.dev0__tar.gz

broadcaster_ng-0.4.0.dev0/.gitignore

@@ -0,0 +1,15 @@
+*.pyc
+test.db
+.coverage
+.pytest_cache/
+.mypy_cache/
+*.egg-info/
+venv/
+build/
+dist/
+
+# Private design notes and work logs
+notes/
+
+# IDE
+.idea/

broadcaster_ng-0.4.0.dev0/LICENSE.md

@@ -0,0 +1,28 @@
+Copyright © 2020, [Encode OSS Ltd](https://www.encode.io/).
+Copyright © 2026, Qing Wan.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

broadcaster_ng-0.4.0.dev0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.5
+Name: broadcaster-ng
+Version: 0.4.0.dev0
+Summary: Simple broadcast channels. Maintained fork of encode/broadcaster with connection-loss fixes.
+Project-URL: Homepage, https://github.com/Redevil10/broadcaster-ng
+Project-URL: Issues, https://github.com/Redevil10/broadcaster-ng/issues
+Project-URL: Upstream, https://github.com/encode/broadcaster
+Author-email: Tom Christie <tom@tomchristie.com>, Qing Wan <juveseason@gmail.com>
+Maintainer-email: Qing Wan <juveseason@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Requires-Dist: anyio<5,>=3.4.0
+Provides-Extra: kafka
+Requires-Dist: aiokafka; extra == 'kafka'
+Provides-Extra: postgres
+Requires-Dist: asyncpg; extra == 'postgres'
+Provides-Extra: redis
+Requires-Dist: redis>=5; extra == 'redis'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Broadcaster (broadcaster-ng)
+
+> **Maintained fork of [encode/broadcaster](https://github.com/encode/broadcaster)**,
+> which is archived. Same API, same import name: replace `broadcaster` with
+> `broadcaster-ng` in your requirements and your code keeps working.
+>
+> - Install: `pip install "broadcaster-ng[redis]"` (or `[postgres]`, `[kafka]`).
+> - `broadcaster-ng` and the original `broadcaster` both install the `broadcaster`
+>   package, so they **cannot be installed together**. Uninstall `broadcaster`
+>   first, and check that none of your dependencies pulls it back in.
+> - Focus: reliable connection-loss handling (reconnect, re-subscribe,
+>   half-open detection) for the Redis pub/sub and Postgres backends. Redis
+>   Streams and Kafka are kept as is.
+> - Status: in development, not yet released.
+
+Broadcaster helps you develop realtime streaming functionality by providing
+a simple broadcast API onto a number of different backend services.
+
+It currently supports [Redis PUB/SUB](https://redis.io/topics/pubsub), [Redis Streams](https://redis.io/docs/latest/develop/data-types/streams/), [Apache Kafka](https://kafka.apache.org/), and [Postgres LISTEN/NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html), plus a simple in-memory backend, that you can use for local development or during testing.
+
+<img src="https://raw.githubusercontent.com/encode/broadcaster/master/docs/demo.gif" alt='WebSockets Demo'>
+
+Here's a complete example of the backend code for a simple websocket chat app:
+
+**app.py**
+
+```python
+# Requires: `starlette`, `uvicorn`, `jinja2`
+# Run with `uvicorn example:app`
+import anyio
+from broadcaster import Broadcast
+from starlette.applications import Starlette
+from starlette.routing import Route, WebSocketRoute
+from starlette.templating import Jinja2Templates
+
+
+broadcast = Broadcast("redis://localhost:6379")
+templates = Jinja2Templates("templates")
+
+
+async def homepage(request):
+    template = "index.html"
+    context = {"request": request}
+    return templates.TemplateResponse(template, context)
+
+
+async def chatroom_ws(websocket):
+    await websocket.accept()
+
+    async with anyio.create_task_group() as task_group:
+        # run until first is complete
+        async def run_chatroom_ws_receiver() -> None:
+            await chatroom_ws_receiver(websocket=websocket)
+            task_group.cancel_scope.cancel()
+
+        task_group.start_soon(run_chatroom_ws_receiver)
+        await chatroom_ws_sender(websocket)
+
+
+async def chatroom_ws_receiver(websocket):
+    async for message in websocket.iter_text():
+        await broadcast.publish(channel="chatroom", message=message)
+
+
+async def chatroom_ws_sender(websocket):
+    async with broadcast.subscribe(channel="chatroom") as subscriber:
+        async for event in subscriber:
+            await websocket.send_text(event.message)
+
+
+routes = [
+    Route("/", homepage),
+    WebSocketRoute("/", chatroom_ws, name='chatroom_ws'),
+]
+
+
+app = Starlette(
+    routes=routes, on_startup=[broadcast.connect], on_shutdown=[broadcast.disconnect],
+)
+```
+
+The HTML template for the front end [is available here](https://github.com/encode/broadcaster/blob/master/example/templates/index.html), and is adapted from [Pieter Noordhuis's PUB/SUB demo](https://gist.github.com/pietern/348262).
+
+## Requirements
+
+Python 3.8+
+
+## Installation
+
+* `pip install broadcaster`
+* `pip install broadcaster[redis]`
+* `pip install broadcaster[postgres]`
+* `pip install broadcaster[kafka]`
+
+## Available backends
+
+* `Broadcast('memory://')`
+* `Broadcast("redis://localhost:6379")`
+* `Broadcast("redis-stream://localhost:6379")`
+* `Broadcast("postgres://localhost:5432/broadcaster")`
+* `Broadcast("kafka://localhost:9092")`
+
+
+### Using custom backends
+
+You can create your own backend and use it with `broadcaster`.
+To do that you need to create a class which extends from `BroadcastBackend`
+and pass it to the `broadcaster` via `backend` argument.
+
+```python
+from broadcaster import Broadcaster, BroadcastBackend
+
+class MyBackend(BroadcastBackend):
+
+broadcaster = Broadcaster(backend=MyBackend())
+```
+
+## Where next?
+
+At the moment `broadcaster` is in Alpha, and should be considered a working design document.
+
+The API should be considered subject to change. If you *do* want to use Broadcaster in its current
+state, make sure to strictly pin your requirements to `broadcaster==0.3.0`.
+
+To be more capable we'd really want to add some additional backends, provide API support for reading recent event history from persistent stores, and provide a serialization/deserialization API...
+
+* Serialization / deserialization to support broadcasting structured data.
+* A backend for RabbitMQ.
+* Add support for `subscribe('chatroom', history=100)` for backends which provide persistence. (Redis Streams, Apache Kafka) This will allow applications to subscribe to channel updates, while also being given an initial window onto the most recent events. We *might* also want to support some basic paging operations, to allow applications to scan back in the event history.
+* Support for pattern subscribes in backends that support it.
+
+## Third Party Packages
+
+### MQTT backend
+[Gist](https://gist.github.com/alex-oleshkevich/68411a0e7ad24d53afd28c3fa5da468c)
+
+Integrates MQTT with Broadcaster

broadcaster_ng-0.4.0.dev0/README.md

@@ -0,0 +1,137 @@
+# Broadcaster (broadcaster-ng)
+
+> **Maintained fork of [encode/broadcaster](https://github.com/encode/broadcaster)**,
+> which is archived. Same API, same import name: replace `broadcaster` with
+> `broadcaster-ng` in your requirements and your code keeps working.
+>
+> - Install: `pip install "broadcaster-ng[redis]"` (or `[postgres]`, `[kafka]`).
+> - `broadcaster-ng` and the original `broadcaster` both install the `broadcaster`
+>   package, so they **cannot be installed together**. Uninstall `broadcaster`
+>   first, and check that none of your dependencies pulls it back in.
+> - Focus: reliable connection-loss handling (reconnect, re-subscribe,
+>   half-open detection) for the Redis pub/sub and Postgres backends. Redis
+>   Streams and Kafka are kept as is.
+> - Status: in development, not yet released.
+
+Broadcaster helps you develop realtime streaming functionality by providing
+a simple broadcast API onto a number of different backend services.
+
+It currently supports [Redis PUB/SUB](https://redis.io/topics/pubsub), [Redis Streams](https://redis.io/docs/latest/develop/data-types/streams/), [Apache Kafka](https://kafka.apache.org/), and [Postgres LISTEN/NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html), plus a simple in-memory backend, that you can use for local development or during testing.
+
+<img src="https://raw.githubusercontent.com/encode/broadcaster/master/docs/demo.gif" alt='WebSockets Demo'>
+
+Here's a complete example of the backend code for a simple websocket chat app:
+
+**app.py**
+
+```python
+# Requires: `starlette`, `uvicorn`, `jinja2`
+# Run with `uvicorn example:app`
+import anyio
+from broadcaster import Broadcast
+from starlette.applications import Starlette
+from starlette.routing import Route, WebSocketRoute
+from starlette.templating import Jinja2Templates
+
+
+broadcast = Broadcast("redis://localhost:6379")
+templates = Jinja2Templates("templates")
+
+
+async def homepage(request):
+    template = "index.html"
+    context = {"request": request}
+    return templates.TemplateResponse(template, context)
+
+
+async def chatroom_ws(websocket):
+    await websocket.accept()
+
+    async with anyio.create_task_group() as task_group:
+        # run until first is complete
+        async def run_chatroom_ws_receiver() -> None:
+            await chatroom_ws_receiver(websocket=websocket)
+            task_group.cancel_scope.cancel()
+
+        task_group.start_soon(run_chatroom_ws_receiver)
+        await chatroom_ws_sender(websocket)
+
+
+async def chatroom_ws_receiver(websocket):
+    async for message in websocket.iter_text():
+        await broadcast.publish(channel="chatroom", message=message)
+
+
+async def chatroom_ws_sender(websocket):
+    async with broadcast.subscribe(channel="chatroom") as subscriber:
+        async for event in subscriber:
+            await websocket.send_text(event.message)
+
+
+routes = [
+    Route("/", homepage),
+    WebSocketRoute("/", chatroom_ws, name='chatroom_ws'),
+]
+
+
+app = Starlette(
+    routes=routes, on_startup=[broadcast.connect], on_shutdown=[broadcast.disconnect],
+)
+```
+
+The HTML template for the front end [is available here](https://github.com/encode/broadcaster/blob/master/example/templates/index.html), and is adapted from [Pieter Noordhuis's PUB/SUB demo](https://gist.github.com/pietern/348262).
+
+## Requirements
+
+Python 3.8+
+
+## Installation
+
+* `pip install broadcaster`
+* `pip install broadcaster[redis]`
+* `pip install broadcaster[postgres]`
+* `pip install broadcaster[kafka]`
+
+## Available backends
+
+* `Broadcast('memory://')`
+* `Broadcast("redis://localhost:6379")`
+* `Broadcast("redis-stream://localhost:6379")`
+* `Broadcast("postgres://localhost:5432/broadcaster")`
+* `Broadcast("kafka://localhost:9092")`
+
+
+### Using custom backends
+
+You can create your own backend and use it with `broadcaster`.
+To do that you need to create a class which extends from `BroadcastBackend`
+and pass it to the `broadcaster` via `backend` argument.
+
+```python
+from broadcaster import Broadcaster, BroadcastBackend
+
+class MyBackend(BroadcastBackend):
+
+broadcaster = Broadcaster(backend=MyBackend())
+```
+
+## Where next?
+
+At the moment `broadcaster` is in Alpha, and should be considered a working design document.
+
+The API should be considered subject to change. If you *do* want to use Broadcaster in its current
+state, make sure to strictly pin your requirements to `broadcaster==0.3.0`.
+
+To be more capable we'd really want to add some additional backends, provide API support for reading recent event history from persistent stores, and provide a serialization/deserialization API...
+
+* Serialization / deserialization to support broadcasting structured data.
+* A backend for RabbitMQ.
+* Add support for `subscribe('chatroom', history=100)` for backends which provide persistence. (Redis Streams, Apache Kafka) This will allow applications to subscribe to channel updates, while also being given an initial window onto the most recent events. We *might* also want to support some basic paging operations, to allow applications to scan back in the event history.
+* Support for pattern subscribes in backends that support it.
+
+## Third Party Packages
+
+### MQTT backend
+[Gist](https://gist.github.com/alex-oleshkevich/68411a0e7ad24d53afd28c3fa5da468c)
+
+Integrates MQTT with Broadcaster

broadcaster_ng-0.4.0.dev0/broadcaster/__init__.py

@@ -0,0 +1,5 @@
+from ._base import Broadcast, Event
+from .backends.base import BroadcastBackend
+
+__version__ = "0.4.0.dev0"
+__all__ = ["Broadcast", "Event", "BroadcastBackend"]

broadcaster_ng-0.4.0.dev0/broadcaster/_backends/base.py

@@ -0,0 +1,3 @@
+"""Deprecated alias for `broadcaster.backends.base` (renamed upstream after 0.3.1)."""
+
+from broadcaster.backends.base import *  # noqa: F403

broadcaster_ng-0.4.0.dev0/broadcaster/_backends/kafka.py

@@ -0,0 +1,3 @@
+"""Deprecated alias for `broadcaster.backends.kafka` (renamed upstream after 0.3.1)."""
+
+from broadcaster.backends.kafka import *  # noqa: F403

broadcaster_ng-0.4.0.dev0/broadcaster/_backends/memory.py

@@ -0,0 +1,3 @@
+"""Deprecated alias for `broadcaster.backends.memory` (renamed upstream after 0.3.1)."""
+
+from broadcaster.backends.memory import *  # noqa: F403

broadcaster_ng-0.4.0.dev0/broadcaster/_backends/postgres.py

@@ -0,0 +1,3 @@
+"""Deprecated alias for `broadcaster.backends.postgres` (renamed upstream after 0.3.1)."""
+
+from broadcaster.backends.postgres import *  # noqa: F403

broadcaster_ng-0.4.0.dev0/broadcaster/_backends/redis.py

@@ -0,0 +1,3 @@
+"""Deprecated alias for `broadcaster.backends.redis` (renamed upstream after 0.3.1)."""
+
+from broadcaster.backends.redis import *  # noqa: F403

broadcaster_ng-0.4.0.dev0/broadcaster/_base.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Any, cast
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:  # pragma: no cover
+    from broadcaster.backends.base import BroadcastBackend
+
+
+class Event:
+    def __init__(self, channel: str, message: str) -> None:
+        self.channel = channel
+        self.message = message
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Event) and self.channel == other.channel and self.message == other.message
+
+    def __repr__(self) -> str:
+        return f"Event(channel={self.channel!r}, message={self.message!r})"
+
+
+class Unsubscribed(Exception):
+    pass
+
+
+class Broadcast:
+    def __init__(self, url: str | None = None, *, backend: BroadcastBackend | None = None) -> None:
+        assert url or backend, "Either `url` or `backend` must be provided."
+        self._backend = backend or self._create_backend(cast(str, url))
+        self._subscribers: dict[str, set[asyncio.Queue[Event | None]]] = {}
+
+    def _create_backend(self, url: str) -> BroadcastBackend:
+        parsed_url = urlparse(url)
+        if parsed_url.scheme in ("redis", "rediss"):
+            from broadcaster.backends.redis import RedisBackend
+
+            return RedisBackend(url)
+
+        elif parsed_url.scheme == "redis-stream":
+            from broadcaster.backends.redis import RedisStreamBackend
+
+            return RedisStreamBackend(url)
+
+        elif parsed_url.scheme in ("postgres", "postgresql"):
+            from broadcaster.backends.postgres import PostgresBackend
+
+            return PostgresBackend(url)
+
+        if parsed_url.scheme == "kafka":
+            from broadcaster.backends.kafka import KafkaBackend
+
+            return KafkaBackend(url)
+
+        elif parsed_url.scheme == "memory":
+            from broadcaster.backends.memory import MemoryBackend
+
+            return MemoryBackend(url)
+        raise ValueError(f"Unsupported backend: {parsed_url.scheme}")
+
+    async def __aenter__(self) -> Broadcast:
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        await self.disconnect()
+
+    async def connect(self) -> None:
+        await self._backend.connect()
+        self._listener_task = asyncio.create_task(self._listener())
+
+    async def disconnect(self) -> None:
+        if self._listener_task.done():
+            self._listener_task.result()
+        else:
+            self._listener_task.cancel()
+        await self._backend.disconnect()
+
+    async def _listener(self) -> None:
+        while True:
+            event = await self._backend.next_published()
+            for queue in list(self._subscribers.get(event.channel, [])):
+                await queue.put(event)
+
+    async def publish(self, channel: str, message: Any) -> None:
+        await self._backend.publish(channel, message)
+
+    @asynccontextmanager
+    async def subscribe(self, channel: str) -> AsyncIterator[Subscriber]:
+        queue: asyncio.Queue[Event | None] = asyncio.Queue()
+
+        try:
+            if not self._subscribers.get(channel):
+                await self._backend.subscribe(channel)
+                self._subscribers[channel] = {queue}
+            else:
+                self._subscribers[channel].add(queue)
+
+            yield Subscriber(queue)
+        finally:
+            self._subscribers[channel].remove(queue)
+            if not self._subscribers.get(channel):
+                del self._subscribers[channel]
+                await self._backend.unsubscribe(channel)
+            await queue.put(None)
+
+
+class Subscriber:
+    def __init__(self, queue: asyncio.Queue[Event | None]) -> None:
+        self._queue = queue
+
+    async def __aiter__(self) -> AsyncGenerator[Event | None, None]:
+        try:
+            while True:
+                yield await self.get()
+        except Unsubscribed:
+            pass
+
+    async def get(self) -> Event:
+        item = await self._queue.get()
+        if item is None:
+            raise Unsubscribed()
+        return item

broadcaster_ng-0.4.0.dev0/broadcaster/backends/base.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from .._base import Event
+
+
+class BroadcastBackend:
+    def __init__(self, url: str) -> None:
+        raise NotImplementedError()
+
+    async def connect(self) -> None:
+        raise NotImplementedError()
+
+    async def disconnect(self) -> None:
+        raise NotImplementedError()
+
+    async def subscribe(self, channel: str) -> None:
+        raise NotImplementedError()
+
+    async def unsubscribe(self, channel: str) -> None:
+        raise NotImplementedError()
+
+    async def publish(self, channel: str, message: Any) -> None:
+        raise NotImplementedError()
+
+    async def next_published(self) -> Event:
+        raise NotImplementedError()

broadcaster_ng-0.4.0.dev0/broadcaster/backends/kafka.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import asyncio
+import typing
+from urllib.parse import urlparse
+
+from aiokafka import AIOKafkaConsumer, AIOKafkaProducer
+
+from .._base import Event
+from .base import BroadcastBackend
+
+
+class KafkaBackend(BroadcastBackend):
+    def __init__(self, urls: str | list[str]) -> None:
+        urls = [urls] if isinstance(urls, str) else urls
+        self._servers = [urlparse(url).netloc for url in urls]
+        self._consumer_channels: set[str] = set()
+        self._ready = asyncio.Event()
+
+    async def connect(self) -> None:
+        self._producer = AIOKafkaProducer(bootstrap_servers=self._servers)  # pyright: ignore
+        self._consumer = AIOKafkaConsumer(bootstrap_servers=self._servers)  # pyright: ignore
+        await self._producer.start()
+        await self._consumer.start()
+
+    async def disconnect(self) -> None:
+        await self._producer.stop()
+        await self._consumer.stop()
+
+    async def subscribe(self, channel: str) -> None:
+        self._consumer_channels.add(channel)
+        self._consumer.subscribe(topics=self._consumer_channels)
+        await self._wait_for_assignment()
+
+    async def unsubscribe(self, channel: str) -> None:
+        self._consumer.unsubscribe()
+
+    async def publish(self, channel: str, message: typing.Any) -> None:
+        await self._producer.send_and_wait(channel, message.encode("utf8"))
+
+    async def next_published(self) -> Event:
+        await self._ready.wait()
+        message = await self._consumer.getone()
+        value = message.value
+
+        # for type compatibility:
+        # we declare Event.message as str, so convert None to empty string
+        if value is None:
+            value = b""
+        return Event(channel=message.topic, message=value.decode("utf8"))
+
+    async def _wait_for_assignment(self) -> None:
+        """Wait for the consumer to be assigned to the partition."""
+        while not self._consumer.assignment():
+            await asyncio.sleep(0.001)
+
+        self._ready.set()

broadcaster_ng-0.4.0.dev0/broadcaster/backends/memory.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import asyncio
+import typing
+
+from .._base import Event
+from .base import BroadcastBackend
+
+
+class MemoryBackend(BroadcastBackend):
+    def __init__(self, url: str):
+        self._subscribed: set[str] = set()
+
+    async def connect(self) -> None:
+        self._published: asyncio.Queue[Event] = asyncio.Queue()
+
+    async def disconnect(self) -> None:
+        pass
+
+    async def subscribe(self, channel: str) -> None:
+        self._subscribed.add(channel)
+
+    async def unsubscribe(self, channel: str) -> None:
+        self._subscribed.remove(channel)
+
+    async def publish(self, channel: str, message: typing.Any) -> None:
+        event = Event(channel=channel, message=message)
+        await self._published.put(event)
+
+    async def next_published(self) -> Event:
+        while True:
+            event = await self._published.get()
+            if event.channel in self._subscribed:
+                return event

broadcaster_ng-0.4.0.dev0/broadcaster/backends/postgres.py

@@ -0,0 +1,36 @@
+import asyncio
+from typing import Any
+
+import asyncpg
+
+from .._base import Event
+from .base import BroadcastBackend
+
+
+class PostgresBackend(BroadcastBackend):
+    def __init__(self, url: str):
+        self._url = url
+
+    async def connect(self) -> None:
+        self._conn = await asyncpg.connect(self._url)
+        self._listen_queue: asyncio.Queue[Event] = asyncio.Queue()
+
+    async def disconnect(self) -> None:
+        await self._conn.close()
+
+    async def subscribe(self, channel: str) -> None:
+        await self._conn.add_listener(channel, self._listener)
+
+    async def unsubscribe(self, channel: str) -> None:
+        await self._conn.remove_listener(channel, self._listener)
+
+    async def publish(self, channel: str, message: str) -> None:
+        await self._conn.execute("SELECT pg_notify($1, $2);", channel, message)
+
+    def _listener(self, *args: Any) -> None:
+        connection, pid, channel, payload = args
+        event = Event(channel=channel, message=payload)
+        self._listen_queue.put_nowait(event)
+
+    async def next_published(self) -> Event:
+        return await self._listen_queue.get()

broadcaster_ng-0.4.0.dev0/broadcaster/backends/redis.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import asyncio
+import typing
+
+from redis import asyncio as redis
+
+from .._base import Event
+from .base import BroadcastBackend
+
+
+class RedisBackend(BroadcastBackend):
+    _conn: redis.Redis
+
+    def __init__(self, url: str | None = None, *, conn: redis.Redis | None = None):
+        if url is None:
+            assert conn is not None, "conn must be provided if url is not"
+            self._conn = conn
+        else:
+            self._conn = redis.Redis.from_url(url)
+
+        self._pubsub = self._conn.pubsub()
+        self._ready = asyncio.Event()
+        self._queue: asyncio.Queue[Event] = asyncio.Queue()
+        self._listener: asyncio.Task[None] | None = None
+
+    async def connect(self) -> None:
+        self._listener = asyncio.create_task(self._pubsub_listener())
+        await self._pubsub.connect()  # type: ignore[no-untyped-call]
+
+    async def disconnect(self) -> None:
+        await self._pubsub.aclose()  # type: ignore[no-untyped-call]
+        await self._conn.aclose()
+        if self._listener is not None:
+            self._listener.cancel()
+
+    async def subscribe(self, channel: str) -> None:
+        await self._pubsub.subscribe(channel)
+        # Wake the listener only after redis-py has registered the channel:
+        # `PubSub.listen()` returns at once while `pubsub.subscribed` is False,
+        # and redis-py adds the channel only after sending SUBSCRIBE. Setting
+        # the event first let the listener exit and wait forever whenever the
+        # subscribe call yielded (seen with redis-py 8 on Python 3.10/3.11).
+        self._ready.set()
+
+    async def unsubscribe(self, channel: str) -> None:
+        await self._pubsub.unsubscribe(channel)
+
+    async def publish(self, channel: str, message: typing.Any) -> None:
+        await self._conn.publish(channel, message)
+
+    async def next_published(self) -> Event:
+        return await self._queue.get()
+
+    async def _pubsub_listener(self) -> None:
+        # redis-py does not listen to the pubsub connection if there are no channels subscribed
+        # so we need to wait until the first channel is subscribed to start listening
+        while True:
+            await self._ready.wait()
+            async for message in self._pubsub.listen():
+                if message["type"] == "message":
+                    event = Event(
+                        channel=message["channel"].decode(),
+                        message=message["data"].decode(),
+                    )
+                    await self._queue.put(event)
+
+            # when no channel subscribed, clear the event.
+            # And then in next loop, event will blocked again until
+            # the new channel subscribed.Now asyncio.Task will not exit again.
+            self._ready.clear()
+
+
+StreamMessageType = tuple[bytes, tuple[tuple[bytes, dict[bytes, bytes]]]]
+
+
+class RedisStreamBackend(BroadcastBackend):
+    def __init__(self, url: str):
+        url = url.replace("redis-stream", "redis", 1)
+        self.streams: dict[bytes | str | memoryview, int | bytes | str | memoryview] = {}
+        self._ready = asyncio.Event()
+        self._producer = redis.Redis.from_url(url)
+        self._consumer = redis.Redis.from_url(url)
+
+    async def connect(self) -> None:
+        pass
+
+    async def disconnect(self) -> None:
+        await self._producer.aclose()
+        await self._consumer.aclose()
+
+    async def subscribe(self, channel: str) -> None:
+        try:
+            info = await self._consumer.xinfo_stream(channel)
+            last_id = info["last-generated-id"]
+        except redis.ResponseError:
+            last_id = "0"
+        self.streams[channel] = last_id
+        self._ready.set()
+
+    async def unsubscribe(self, channel: str) -> None:
+        self.streams.pop(channel, None)
+
+    async def publish(self, channel: str, message: typing.Any) -> None:
+        await self._producer.xadd(channel, {"message": message})
+
+    async def wait_for_messages(self) -> list[StreamMessageType]:
+        await self._ready.wait()
+        messages = None
+        while not messages:
+            messages = await self._consumer.xread(self.streams, count=1, block=100)
+        # redis-py >= 6 types xread() as a RESP2/RESP3 union; with RESP2 it is this list.
+        return typing.cast(list[StreamMessageType], messages)
+
+    async def next_published(self) -> Event:
+        messages = await self.wait_for_messages()
+        stream, events = messages[0]
+        _msg_id, message = events[0]
+        self.streams[stream.decode("utf-8")] = _msg_id.decode("utf-8")
+        return Event(
+            channel=stream.decode("utf-8"),
+            message=message.get(b"message", b"").decode("utf-8"),
+        )

broadcaster_ng-0.4.0.dev0/pyproject.toml

@@ -0,0 +1,90 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "broadcaster-ng"
+dynamic = ["version"]
+description = "Simple broadcast channels. Maintained fork of encode/broadcaster with connection-loss fixes."
+readme = "README.md"
+license = "BSD-3-Clause"
+requires-python = ">=3.10"
+authors = [
+    { name = "Tom Christie", email = "tom@tomchristie.com" },
+    { name = "Qing Wan", email = "juveseason@gmail.com" },
+]
+maintainers = [
+    { name = "Qing Wan", email = "juveseason@gmail.com" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Topic :: Internet :: WWW/HTTP",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "anyio>=3.4.0,<5",
+]
+
+[project.optional-dependencies]
+redis = ["redis>=5"]
+postgres = ["asyncpg"]
+kafka = ["aiokafka"]
+test =  ["pytest", "pytest-asyncio"]
+
+[project.urls]
+Homepage = "https://github.com/Redevil10/broadcaster-ng"
+Issues = "https://github.com/Redevil10/broadcaster-ng/issues"
+Upstream = "https://github.com/encode/broadcaster"
+
+[tool.hatch.version]
+path = "broadcaster/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+# PyPI name is broadcaster-ng, import name stays `broadcaster`.
+packages = ["broadcaster"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/broadcaster",
+]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "FA", "UP"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+
+[tool.mypy]
+strict = true
+python_version = "3.10"
+disallow_untyped_defs = true
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "tests.*"
+disallow_untyped_defs = false
+check_untyped_defs = true
+
+[tool.pytest.ini_options]
+addopts = "-rxXs"
+asyncio_default_fixture_loop_scope = "function"
+markers = "copied_from(source, changes=None): mark test as copied from somewhere else, along with a description of changes made to accodomate e.g. our test setup"
+
+[tool.coverage.run]
+source_pkgs = ["broadcaster", "tests"]
+
+[tool.coverage.report]
+fail_under = 78
+show_missing = true
+skip_covered = true