fastapi-startkit 0.31.0__tar.gz → 0.32.0__tar.gz

{fastapi_startkit-0.31.0 → fastapi_startkit-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.31.0
+Version: 0.32.0
 Summary: Fastapi Starter kit components
 Author: Bedram Tamang
 Author-email: Bedram Tamang <tmgbedu@gmail.com>

{fastapi_startkit-0.31.0 → fastapi_startkit-0.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.31.0"
+version = "0.32.0"
 description = "Fastapi Starter kit components"
 authors = [
     {name = "Bedram Tamang", email = "tmgbedu@gmail.com"}

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/__init__.py

@@ -0,0 +1,14 @@
+from .channels import Channel, PrivateChannel, PresenceChannel
+from .event import BroadcastEvent, ShouldBroadcast
+from .provider import ReverbProvider
+from .helpers import broadcast
+
+__all__ = [
+    "Channel",
+    "PrivateChannel",
+    "PresenceChannel",
+    "BroadcastEvent",
+    "ShouldBroadcast",
+    "ReverbProvider",
+    "broadcast",
+]

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/channels.py

@@ -0,0 +1,16 @@
+class Channel:
+    def __init__(self, name: str):
+        self.name = name
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.name!r})"
+
+
+class PrivateChannel(Channel):
+    def __init__(self, name: str):
+        super().__init__(f"private-{name}")
+
+
+class PresenceChannel(Channel):
+    def __init__(self, name: str):
+        super().__init__(f"presence-{name}")

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/config.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+from fastapi_startkit.environment import env
+
+
+@dataclass
+class BroadcastingConfig:
+    default: str = field(default_factory=lambda: env("BROADCAST_DRIVER", "log"))
+
+    connections: dict = field(
+        default_factory=lambda: {
+            "reverb": {
+                "driver": "reverb",
+                "key": env("REVERB_APP_KEY", "local"),
+                "secret": env("REVERB_APP_SECRET", "secret"),
+                "app_id": env("REVERB_APP_ID", "1"),
+                "host": env("REVERB_HOST", "0.0.0.0"),
+                "port": int(env("REVERB_PORT", 8080)),
+                "scheme": env("REVERB_SCHEME", "http"),
+            },
+            "log": {
+                "driver": "log",
+            },
+        }
+    )

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/drivers/__init__.py

@@ -0,0 +1,4 @@
+from .log_driver import LogDriver
+from .reverb_driver import ReverbDriver
+
+__all__ = ["LogDriver", "ReverbDriver"]

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/drivers/log_driver.py

@@ -0,0 +1,11 @@
+import logging
+
+logger = logging.getLogger("reverb")
+
+
+class LogDriver:
+    async def broadcast(self, event) -> None:
+        for channel in event.broadcast_on():
+            logger.info(
+                f"[Broadcast] channel={channel.name} event={event.broadcast_as()} data={event.broadcast_with()}"
+            )

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/drivers/reverb_driver.py

@@ -0,0 +1,7 @@
+class ReverbDriver:
+    def __init__(self, server):
+        self.server = server
+
+    async def broadcast(self, event) -> None:
+        for channel in event.broadcast_on():
+            await self.server.broadcast_to_channel(channel.name, event.broadcast_as(), event.broadcast_with())

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/event.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+
+class ShouldBroadcast(ABC):
+    @abstractmethod
+    def broadcast_on(self) -> list: ...
+
+
+class BroadcastEvent(ShouldBroadcast):
+    def broadcast_as(self) -> str:
+        return self.__class__.__name__
+
+    def broadcast_with(self) -> dict:
+        return {k: v for k, v in self.__dict__.items()}

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/helpers.py

@@ -0,0 +1,7 @@
+from ..application import app
+
+
+async def broadcast(event) -> None:
+    """Broadcast an event using the default driver."""
+    manager = app().make("broadcasting")
+    await manager.event(event)

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/manager.py

@@ -0,0 +1,19 @@
+class BroadcastManager:
+    def __init__(self, config, server=None):
+        self._config = config
+        self._server = server
+
+    def driver(self, name=None):
+        name = name or self._config.get("default", "log")
+        if name == "log":
+            from .drivers.log_driver import LogDriver
+
+            return LogDriver()
+        elif name == "reverb":
+            from .drivers.reverb_driver import ReverbDriver
+
+            return ReverbDriver(self._server)
+        raise ValueError(f"Unknown broadcast driver: {name}")
+
+    async def event(self, broadcast_event) -> None:
+        await self.driver().broadcast(broadcast_event)

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/provider.py

@@ -0,0 +1,21 @@
+from ..providers import Provider
+from .manager import BroadcastManager
+from .config import BroadcastingConfig
+from .reverb.server import ReverbServer
+
+
+class ReverbProvider(Provider):
+    provider_key = "broadcasting"
+
+    def register(self) -> None:
+        config_data = self.resolve_config(BroadcastingConfig)
+        self.merge_config_from(config_data, "broadcasting")
+
+        server = ReverbServer()
+        manager = BroadcastManager(config_data, server)
+
+        self.app.bind("broadcasting", manager)
+        self.app.bind("reverb.server", server)
+
+    def boot(self) -> None:
+        pass

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/reverb/__init__.py

@@ -0,0 +1,5 @@
+from .server import ReverbServer
+from .connection import ConnectionManager
+from .channel_manager import ChannelManager
+
+__all__ = ["ReverbServer", "ConnectionManager", "ChannelManager"]

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/reverb/channel_manager.py

@@ -0,0 +1,17 @@
+class ChannelManager:
+    def __init__(self):
+        self._subscriptions: dict[str, set] = {}
+
+    def subscribe(self, channel: str, socket_id: str) -> None:
+        self._subscriptions.setdefault(channel, set()).add(socket_id)
+
+    def unsubscribe(self, channel: str, socket_id: str) -> None:
+        if channel in self._subscriptions:
+            self._subscriptions[channel].discard(socket_id)
+
+    def remove_socket(self, socket_id: str) -> None:
+        for subs in self._subscriptions.values():
+            subs.discard(socket_id)
+
+    def subscribers(self, channel: str) -> set:
+        return set(self._subscriptions.get(channel, set()))

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/reverb/connection.py

@@ -0,0 +1,21 @@
+import uuid
+from starlette.websockets import WebSocket
+
+
+class ConnectionManager:
+    def __init__(self):
+        self._connections: dict[str, WebSocket] = {}
+
+    def add(self, websocket: WebSocket) -> str:
+        socket_id = str(uuid.uuid4())
+        self._connections[socket_id] = websocket
+        return socket_id
+
+    def remove(self, socket_id: str) -> None:
+        self._connections.pop(socket_id, None)
+
+    def get(self, socket_id: str):
+        return self._connections.get(socket_id)
+
+    def all(self) -> dict:
+        return dict(self._connections)

fastapi_startkit-0.32.0/src/fastapi_startkit/broadcasting/reverb/server.py

@@ -0,0 +1,59 @@
+import json
+from starlette.websockets import WebSocket, WebSocketDisconnect
+from starlette.routing import WebSocketRoute
+from starlette.applications import Starlette
+from .connection import ConnectionManager
+from .channel_manager import ChannelManager
+
+
+class ReverbServer:
+    def __init__(self):
+        self.connections = ConnectionManager()
+        self.channels = ChannelManager()
+
+    async def handle(self, websocket: WebSocket):
+        await websocket.accept()
+        socket_id = self.connections.add(websocket)
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "event": "pusher:connection_established",
+                    "data": json.dumps({"socket_id": socket_id, "activity_timeout": 120}),
+                }
+            )
+        )
+        try:
+            while True:
+                data = await websocket.receive_text()
+                message = json.loads(data)
+                await self._handle_message(socket_id, websocket, message)
+        except WebSocketDisconnect:
+            self.connections.remove(socket_id)
+            self.channels.remove_socket(socket_id)
+
+    async def _handle_message(self, socket_id: str, websocket: WebSocket, message: dict):
+        event = message.get("event", "")
+        if event == "pusher:ping":
+            await websocket.send_text(json.dumps({"event": "pusher:pong", "data": {}}))
+        elif event == "pusher:subscribe":
+            channel = message.get("data", {}).get("channel", "")
+            self.channels.subscribe(channel, socket_id)
+            await websocket.send_text(
+                json.dumps({"event": "pusher_internal:subscription_succeeded", "channel": channel, "data": {}})
+            )
+
+    async def broadcast_to_channel(self, channel_name: str, event_name: str, data: dict):
+        payload = json.dumps({"event": event_name, "channel": channel_name, "data": data})
+        for socket_id in self.channels.subscribers(channel_name):
+            ws = self.connections.get(socket_id)
+            if ws:
+                try:
+                    await ws.send_text(payload)
+                except Exception:
+                    pass
+
+    def as_starlette_app(self, app_key: str = "local") -> Starlette:
+        async def endpoint(ws: WebSocket):
+            await self.handle(ws)
+
+        return Starlette(routes=[WebSocketRoute(f"/app/{app_key}", endpoint)])

fastapi_startkit-0.32.0/src/fastapi_startkit/facades/Broadcast.pyi

@@ -0,0 +1,15 @@
+from fastapi_startkit.broadcasting.channels import Channel
+from fastapi_startkit.broadcasting.event import BroadcastEvent
+
+class Broadcast:
+    """Facade for broadcasting events over WebSocket channels."""
+
+    @staticmethod
+    async def event(event: BroadcastEvent) -> None:
+        """Broadcast an event to all its channels."""
+        ...
+
+    @staticmethod
+    def channel(name: str) -> Channel:
+        """Return a Channel instance for the given name."""
+        ...

fastapi_startkit-0.32.0/src/fastapi_startkit/jsonapi/__init__.py

@@ -0,0 +1,15 @@
+"""fastapi_startkit.jsonapi — JSON:API specification helpers."""
+
+from .response import (
+    JsonAPIListResponse,
+    JsonAPIResponse,
+    parse_fields,
+    parse_include,
+)
+
+__all__ = [
+    "JsonAPIResponse",
+    "JsonAPIListResponse",
+    "parse_include",
+    "parse_fields",
+]