simplify code, make notifier work with tracks added

Author: Gawor270

examples/selective_subscription/README.md

@@ -0,0 +1,38 @@
+# Selective Subscription Demo
+
+Demo application showing selective subscription functionality with [Fishjam](https://fishjam.io) and the Python Server SDK.
+
+## Prerequisites
+
+- Python 3.11+
+- [uv](https://docs.astral.sh/uv/) package manager
+- Fishjam credentials ([get them here](https://fishjam.io/app))
+
+## Quick Start
+
+1. Install dependencies(in project root):
+   ```bash
+   uv sync
+   ```
+
+2. Run the server:
+   ```bash
+   FISHJAM_ID=<your-id> \
+   FISHJAM_MANAGEMENT_TOKEN=<your-token> \
+   uv run examples/selective_subscription/main.py
+   ```
+
+3. Open http://localhost:8000 in your browser
+
+## Usage
+
+1. Create peers with names
+2. Copy peer tokens and use them with a WebRTC client (e.g., [minimal-react](https://github.com/fishjam-cloud/web-client-sdk/tree/main/examples/react-client/minimal-react))
+3. Once peers have tracks, manage subscriptions through the web interface
+
+### API Endpoints
+
+- `POST /api/peers` - Create a peer with manual subscription mode
+- `POST /api/subscribe_peer` - Subscribe to all tracks from a peer
+- `POST /api/subscribe_tracks` - Subscribe to specific track IDs
+

examples/selective_subscription/main.py

@@ -12,24 +12,12 @@ async def lifespan(app):
     async with async_worker() as worker:
         notification_handler = NotificationHandler(room_service)
         worker.run_in_background(notification_handler.start())
-        
         print(f"Selective subscription demo started on http://{HOST}:{PORT}")
-        print("Available endpoints:")
-        print("  POST /api/peers - Create a new peer")
-        print("  POST /api/subscribe_peer - subscribe to all tracks of a peer")
-        print("  POST /api/subscribe_tracks - subscribe to specific tracks")
-        
         yield
 
 
 app.router.lifespan_context = lifespan
 
 
 if __name__ == "__main__":
-    uvicorn.run(
-        "main:app",
-        host=HOST,
-        port=PORT,
-        reload=True,
-        log_level="info"
-    )
+    uvicorn.run("main:app", host=HOST, port=PORT, reload=True, log_level="info")

examples/selective_subscription/selective_subscription/app.py

@@ -1,6 +1,4 @@
-import json
 from pathlib import Path
-from typing import Dict, Any
 
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
@@ -12,7 +10,6 @@
 
 from .room_service import RoomService
 
-
 room_service = RoomService()
 templates = Jinja2Templates(directory=str(Path(__file__).resolve().parent.parent / "templates"))
 
@@ -37,7 +34,6 @@ async def create_peer(request: Request) -> Response:
             "room_name": room_name,
             "peer_name": peer_name
         })
-    
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
 
@@ -54,12 +50,11 @@ async def subscribe_peer(request: Request) -> Response:
             )
 
         room_service.subscibe_peer(peer_id, target_peer_id)
-
         return JSONResponse({"status": "subscribed"})
-    
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
-    
+
+
 async def subscribe_tracks(request: Request) -> Response:
     try:
         body = await request.json()
@@ -73,23 +68,16 @@ async def subscribe_tracks(request: Request) -> Response:
             )
 
         room_service.subscribe_tracks(peer_id, track_ids)
-
         return JSONResponse({"status": "subscribed"})
-    
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)
 
-async def health_check(request: Request) -> Response:
-    return JSONResponse({"status": "OK"})
-
-
 async def serve_index(request: Request) -> Response:
     return templates.TemplateResponse("index.html", {"request": request})
 
 
 routes = [
     Route("/", serve_index, methods=["GET"]),
-    Route("/health", health_check, methods=["GET"]),
     Route("/api/peers", create_peer, methods=["POST"]),
     Route("/api/subscribe_peer", subscribe_peer, methods=["POST"]),
     Route("/api/subscribe_tracks", subscribe_tracks, methods=["POST"]),

examples/selective_subscription/selective_subscription/notification_handler.py

@@ -12,10 +12,10 @@
 
 
 class NotificationHandler:
-    
     def __init__(self, room_service: RoomService):
         self.room_service = room_service
         self._notifier = FishjamNotifier(FISHJAM_ID, FISHJAM_TOKEN)
+
         @self._notifier.on_server_notification
         async def _(notification: AllowedNotification):
             match notification:
@@ -27,13 +27,9 @@ async def _(notification: AllowedNotification):
                     peer_type=ServerMessagePeerType.PEER_TYPE_WEBRTC,
                 ):
                     await handle_peer_disconnected(notification)
-                case ServerMessageTrackAdded(
-                    peer_type=ServerMessagePeerType.PEER_TYPE_WEBRTC,
-                ):
+                case ServerMessageTrackAdded():
                     await handle_track_added(notification)
-                case ServerMessageTrackRemoved(
-                    peer_type=ServerMessagePeerType.PEER_TYPE_WEBRTC,
-                ):
+                case ServerMessageTrackRemoved():
                     await handle_track_removed(notification)
 
         async def handle_peer_connected(notification: ServerMessagePeerConnected):
@@ -47,9 +43,7 @@ async def handle_track_added(notification: ServerMessageTrackAdded):
 
         async def handle_track_removed(notification: ServerMessageTrackRemoved):
             print(f"Track removed: {notification.track}")
-    
+
     async def start(self) -> None:
-        """Long-running coroutine that connects the notifier and processes messages."""
         await self._notifier.connect()
-            
 

examples/selective_subscription/selective_subscription/room_service.py

@@ -7,17 +7,13 @@
 
 
 class RoomService:
-    
     def __init__(self):
-        self.fishjam = FishjamClient(
-            FISHJAM_ID,
-            FISHJAM_TOKEN,
-        )
+        self.fishjam = FishjamClient(FISHJAM_ID, FISHJAM_TOKEN)
         self.room = self.fishjam.create_room(RoomOptions(
             max_peers=10,
             room_type="conference"
         ))
-    
+
     def get_or_create_room(self) -> Room:
         if self.room:
             try:
@@ -27,26 +23,19 @@ def get_or_create_room(self) -> Room:
                 pass
 
         return self.fishjam.create_room()
-    
+
     def create_peer(self) -> tuple[Peer, str]:
         room = self.get_or_create_room()
-
-        options = PeerOptions(
-            subscribe_mode="manual",
-        )
-        
+        options = PeerOptions(subscribe_mode="manual")
         peer, token = self.fishjam.create_peer(room.id, options)
         return peer, token
 
-    
     def subscibe_peer(self, peer_id: str, target_peer_id: str):
         room = self.get_or_create_room()
-
         self.fishjam.subscribe_peer(room.id, peer_id, target_peer_id)
-    
+
     def subscribe_tracks(self, peer_id: str, track_ids: List[str]):
         room = self.get_or_create_room()
-
         self.fishjam.subscribe_tracks(room.id, peer_id, track_ids)
 
     def get_peer_session(self, peer_id: str):
@@ -59,4 +48,4 @@ def __init__(self):
 
                 return _Session()
 
-        return None
+        return None