Refactored APIs

reachy_f1_commentator/main.py

@@ -46,7 +46,8 @@ _app_instance = None
 class ReachyF1Commentator(ReachyMiniApp):
     """Main Reachy Mini app for F1 commentary generation."""
     
-    custom_app_url: str = "/static"  # Serve web UI from static directory
+    custom_app_url: str = "http://0.0.0.0:8080"  # Root path where the app is served
+    dont_start_webserver: bool = False  # Let framework handle the web server
     
     def __init__(self):
         """Initialize the F1 commentator app."""
@@ -78,9 +79,11 @@ class ReachyF1Commentator(ReachyMiniApp):
         logger.info("Starting F1 Commentator app")
         
         self.reachy_mini_instance = reachy_mini
-        # state_tracker already initialized in __init__
         
-        # Web server is started automatically by framework when custom_app_url is set
+        # Setup FastAPI routes using the framework-provided settings_app
+        self._setup_api_routes()
+        
+        # Web server is started automatically by framework
         logger.info(f"Web UI available at {self.custom_app_url}")
         
         # Wait for stop_event or user interaction
@@ -92,6 +95,275 @@ class ReachyF1Commentator(ReachyMiniApp):
         finally:
             self._cleanup()
     
+    def _setup_api_routes(self):
+        """Setup FastAPI routes and static file serving."""
+        import os
+        from fastapi import WebSocket, WebSocketDisconnect
+        from fastapi.staticfiles import StaticFiles
+        
+        app = self.settings_app
+        
+        # Mount static files
+        static_path = os.path.join(os.path.dirname(__file__), "static")
+        if os.path.exists(static_path):
+            app.mount("/static", StaticFiles(directory=static_path, html=True), name="static")
+            logger.info(f"Mounted static files from {static_path}")
+        
+        # Initialize dashboard manager
+        global dashboard_manager
+        dashboard_manager = ConnectionManager()
+        
+        # Add all API routes
+        self._add_api_routes(app)
+        
+        logger.info("API routes configured")
+    
+    def _add_api_routes(self, app: FastAPI):
+        """Add all API routes to the FastAPI app."""
+        from fastapi import WebSocket, WebSocketDisconnect
+        import asyncio
+        
+        # Configuration endpoints
+        @app.get("/api/config")
+        async def get_config():
+            """Get saved configuration."""
+            try:
+                config = load_saved_config()
+                return {
+                    "elevenlabs_api_key": config.get("elevenlabs_api_key", ""),
+                    "elevenlabs_voice_id": config.get("elevenlabs_voice_id", "HSSEHuB5EziJgTfCVmC6")
+                }
+            except Exception as e:
+                logger.error(f"Failed to get config: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        @app.post("/api/config")
+        async def save_config_endpoint(request: ConfigSaveRequest):
+            """Save configuration."""
+            try:
+                config = {
+                    "elevenlabs_api_key": request.elevenlabs_api_key,
+                    "elevenlabs_voice_id": request.elevenlabs_voice_id
+                }
+                
+                if save_config(config):
+                    return {"status": "saved", "message": "Configuration saved successfully"}
+                else:
+                    raise HTTPException(status_code=500, detail="Failed to save configuration")
+            except Exception as e:
+                logger.error(f"Failed to save config: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        # Race data endpoints
+        @app.get("/api/races/years")
+        async def get_years():
+            """Get list of available years with race data."""
+            try:
+                if _app_instance is None:
+                    raise HTTPException(status_code=503, detail="App not initialized")
+                
+                years = _app_instance.openf1_client.get_years()
+                return {"years": years}
+            except Exception as e:
+                logger.error(f"Failed to get years: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        @app.get("/api/races/{year}")
+        async def get_races(year: int):
+            """Get all races for a specific year."""
+            try:
+                if _app_instance is None:
+                    raise HTTPException(status_code=503, detail="App not initialized")
+                
+                logger.info(f"Fetching races for year {year}")
+                races = _app_instance.openf1_client.get_races_by_year(year)
+                
+                if not races:
+                    logger.warning(f"No races found for year {year}")
+                    return {"races": []}
+                
+                # Convert to dict format
+                races_data = [
+                    {
+                        "session_key": race.session_key,
+                        "date": race.date,
+                        "country": race.country,
+                        "circuit": race.circuit,
+                        "name": race.name
+                    }
+                    for race in races
+                ]
+                
+                logger.info(f"Returning {len(races_data)} races for year {year}")
+                return {"races": races_data}
+            except Exception as e:
+                logger.error(f"Failed to get races for year {year}: {e}", exc_info=True)
+                raise HTTPException(status_code=500, detail=f"Failed to load races: {str(e)}")
+        
+        # Commentary control endpoints
+        @app.post("/api/commentary/start")
+        async def start_commentary(request: CommentaryStartRequest):
+            """Start commentary playback."""
+            try:
+                if _app_instance is None:
+                    raise HTTPException(status_code=503, detail="App not initialized")
+                
+                # Convert request to WebUIConfiguration
+                config = WebUIConfiguration(
+                    mode=request.mode,
+                    session_key=request.session_key,
+                    commentary_mode=request.commentary_mode,
+                    playback_speed=request.playback_speed,
+                    elevenlabs_api_key=request.elevenlabs_api_key,
+                    elevenlabs_voice_id=request.elevenlabs_voice_id
+                )
+                
+                result = _app_instance.start_commentary(config)
+                return result
+            except Exception as e:
+                logger.error(f"Failed to start commentary: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        @app.post("/api/commentary/stop")
+        async def stop_commentary():
+            """Stop active commentary playback."""
+            try:
+                if _app_instance is None:
+                    raise HTTPException(status_code=503, detail="App not initialized")
+                
+                result = _app_instance.stop_commentary()
+                return result
+            except Exception as e:
+                logger.error(f"Failed to stop commentary: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        @app.get("/api/commentary/status")
+        async def get_status():
+            """Get current playback status."""
+            try:
+                if _app_instance is None:
+                    raise HTTPException(status_code=503, detail="App not initialized")
+                
+                status = _app_instance.get_status()
+                return status
+            except Exception as e:
+                logger.error(f"Failed to get status: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        # Q&A endpoint
+        @app.post("/api/qa/ask")
+        async def ask_question(request: QuestionRequest):
+            """Handle Q&A question from user."""
+            try:
+                if _app_instance is None:
+                    raise HTTPException(status_code=503, detail="App not initialized")
+                
+                if not request.question or not request.question.strip():
+                    raise HTTPException(status_code=400, detail="Question cannot be empty")
+                
+                # Process question using QA manager
+                answer = _app_instance.process_question(request.question)
+                
+                return {"question": request.question, "answer": answer}
+            except Exception as e:
+                logger.error(f"Failed to process question: {e}", exc_info=True)
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        # Dashboard endpoints
+        @app.websocket("/ws/dashboard")
+        async def dashboard_websocket(websocket: WebSocket):
+            """WebSocket endpoint for live dashboard updates."""
+            await dashboard_manager.connect(websocket)
+            try:
+                while True:
+                    # Process any queued broadcasts
+                    while dashboard_manager.broadcast_queue:
+                        message = dashboard_manager.broadcast_queue.pop(0)
+                        await dashboard_manager.broadcast(message)
+                    
+                    # Wait a bit before checking queue again
+                    await asyncio.sleep(0.1)
+                    
+                    # Check if client sent any messages (for keep-alive)
+                    try:
+                        data = await asyncio.wait_for(websocket.receive_text(), timeout=0.1)
+                        # Echo back for ping/pong
+                        await websocket.send_text(data)
+                    except asyncio.TimeoutError:
+                        # No message received, continue
+                        pass
+                        
+            except WebSocketDisconnect:
+                dashboard_manager.disconnect(websocket)
+            except Exception as e:
+                logger.error(f"WebSocket error: {e}")
+                dashboard_manager.disconnect(websocket)
+        
+        @app.get("/api/dashboard/state")
+        async def get_dashboard_state():
+            """Get current race state for dashboard."""
+            try:
+                if _app_instance is None or _app_instance.state_tracker is None:
+                    return {
+                        "positions": [],
+                        "race_info": {
+                            "current_lap": 0,
+                            "total_laps": 0,
+                            "leader": None,
+                            "fastest_lap_holder": None,
+                            "race_phase": "START"
+                        },
+                        "recent_events": []
+                    }
+                
+                # Get positions
+                positions = _app_instance.state_tracker.get_positions()
+                positions_data = [
+                    {
+                        "position": p.position,
+                        "driver": p.name,
+                        "gap_to_leader": f"+{p.gap_to_leader:.3f}s" if p.gap_to_leader > 0 else "Leader",
+                        "tire_compound": p.current_tire or "Unknown",
+                        "pit_stops": p.pit_count,
+                        "team": "Unknown"  # Team info not available in DriverState
+                    }
+                    for p in positions[:20]  # Top 20
+                ]
+                
+                # Get race info
+                leader = _app_instance.state_tracker.get_leader()
+                state = _app_instance.state_tracker._state  # Access private _state attribute
+                
+                race_info = {
+                    "current_lap": state.current_lap,
+                    "total_laps": state.total_laps,
+                    "leader": leader.name if leader else None,
+                    "fastest_lap_holder": state.fastest_lap_driver,
+                    "fastest_lap_time": f"{state.fastest_lap_time:.3f}s" if state.fastest_lap_time else None,
+                    "race_phase": state.race_phase.value if state.race_phase else "START",
+                    "safety_car": state.safety_car_active
+                }
+                
+                return {
+                    "positions": positions_data,
+                    "race_info": race_info,
+                    "recent_events": []  # TODO: Add event history
+                }
+            except Exception as e:
+                logger.error(f"Failed to get dashboard state: {e}", exc_info=True)
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        # Root and health endpoints
+        @app.get("/")
+        async def root():
+            """Redirect to static UI."""
+            return RedirectResponse(url="/static/index.html")
+        
+        @app.get("/health")
+        async def health():
+            """Health check endpoint."""
+            return {"status": "healthy", "app": "reachy-f1-commentator"}
+    
     def start_commentary(self, config: WebUIConfiguration) -> dict:
         """
         Start commentary playback with given configuration.
@@ -648,8 +920,9 @@ class ReachyF1Commentator(ReachyMiniApp):
 
 
 
-# FastAPI app for web UI endpoints
-app = FastAPI(title="Reachy F1 Commentator API")
+# ============================================================================
+# Helper Classes and Functions for API Routes
+# ============================================================================
 
 # WebSocket connections for live dashboard
 from fastapi import WebSocket, WebSocketDisconnect
@@ -692,13 +965,8 @@ class ConnectionManager:
         for conn in disconnected:
             self.disconnect(conn)
 
-dashboard_manager = ConnectionManager()
-
-# Mount static files
-import os
-static_path = os.path.join(os.path.dirname(__file__), "static")
-if os.path.exists(static_path):
-    app.mount("/static", StaticFiles(directory=static_path, html=True), name="static")
+# Global dashboard manager (initialized in _setup_api_routes)
+dashboard_manager = None
 
 
 # Pydantic models for API
@@ -716,7 +984,12 @@ class ConfigSaveRequest(BaseModel):
     elevenlabs_voice_id: str = 'HSSEHuB5EziJgTfCVmC6'
 
 
+class QuestionRequest(BaseModel):
+    question: str
+
+
 # Configuration file path
+import os
 CONFIG_DIR = os.path.expanduser("~/.reachy_f1_commentator")
 CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
 
@@ -747,259 +1020,6 @@ def save_config(config: dict) -> bool:
         return False
 
 
-@app.get("/api/config")
-async def get_config():
-    """Get saved configuration."""
-    try:
-        config = load_saved_config()
-        return {
-            "elevenlabs_api_key": config.get("elevenlabs_api_key", ""),
-            "elevenlabs_voice_id": config.get("elevenlabs_voice_id", "HSSEHuB5EziJgTfCVmC6")
-        }
-    except Exception as e:
-        logger.error(f"Failed to get config: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/api/config")
-async def save_config_endpoint(request: ConfigSaveRequest):
-    """Save configuration."""
-    try:
-        config = {
-            "elevenlabs_api_key": request.elevenlabs_api_key,
-            "elevenlabs_voice_id": request.elevenlabs_voice_id
-        }
-        
-        if save_config(config):
-            return {"status": "saved", "message": "Configuration saved successfully"}
-        else:
-            raise HTTPException(status_code=500, detail="Failed to save configuration")
-    except Exception as e:
-        logger.error(f"Failed to save config: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/api/races/years")
-async def get_years():
-    """Get list of available years with race data."""
-    try:
-        if _app_instance is None:
-            raise HTTPException(status_code=503, detail="App not initialized")
-        
-        years = _app_instance.openf1_client.get_years()
-        return {"years": years}
-    except Exception as e:
-        logger.error(f"Failed to get years: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/api/races/{year}")
-async def get_races(year: int):
-    """Get all races for a specific year."""
-    try:
-        if _app_instance is None:
-            raise HTTPException(status_code=503, detail="App not initialized")
-        
-        logger.info(f"Fetching races for year {year}")
-        races = _app_instance.openf1_client.get_races_by_year(year)
-        
-        if not races:
-            logger.warning(f"No races found for year {year}")
-            return {"races": []}
-        
-        # Convert to dict format
-        races_data = [
-            {
-                "session_key": race.session_key,
-                "date": race.date,
-                "country": race.country,
-                "circuit": race.circuit,
-                "name": race.name
-            }
-            for race in races
-        ]
-        
-        logger.info(f"Returning {len(races_data)} races for year {year}")
-        return {"races": races_data}
-    except Exception as e:
-        logger.error(f"Failed to get races for year {year}: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to load races: {str(e)}")
-
-
-@app.post("/api/commentary/start")
-async def start_commentary(request: CommentaryStartRequest):
-    """Start commentary playback."""
-    try:
-        if _app_instance is None:
-            raise HTTPException(status_code=503, detail="App not initialized")
-        
-        # Convert request to WebUIConfiguration
-        config = WebUIConfiguration(
-            mode=request.mode,
-            session_key=request.session_key,
-            commentary_mode=request.commentary_mode,
-            playback_speed=request.playback_speed,
-            elevenlabs_api_key=request.elevenlabs_api_key,
-            elevenlabs_voice_id=request.elevenlabs_voice_id
-        )
-        
-        result = _app_instance.start_commentary(config)
-        return result
-    except Exception as e:
-        logger.error(f"Failed to start commentary: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/api/commentary/stop")
-async def stop_commentary():
-    """Stop active commentary playback."""
-    try:
-        if _app_instance is None:
-            raise HTTPException(status_code=503, detail="App not initialized")
-        
-        result = _app_instance.stop_commentary()
-        return result
-    except Exception as e:
-        logger.error(f"Failed to stop commentary: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/api/commentary/status")
-async def get_status():
-    """Get current playback status."""
-    try:
-        if _app_instance is None:
-            raise HTTPException(status_code=503, detail="App not initialized")
-        
-        status = _app_instance.get_status()
-        return status
-    except Exception as e:
-        logger.error(f"Failed to get status: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-class QuestionRequest(BaseModel):
-    question: str
-
-
-@app.post("/api/qa/ask")
-async def ask_question(request: QuestionRequest):
-    """Handle Q&A question from user."""
-    try:
-        if _app_instance is None:
-            raise HTTPException(status_code=503, detail="App not initialized")
-        
-        if not request.question or not request.question.strip():
-            raise HTTPException(status_code=400, detail="Question cannot be empty")
-        
-        # Process question using QA manager
-        answer = _app_instance.process_question(request.question)
-        
-        return {"question": request.question, "answer": answer}
-    except Exception as e:
-        logger.error(f"Failed to process question: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/")
-async def root():
-    """Redirect to static UI."""
-    from fastapi.responses import RedirectResponse
-    return RedirectResponse(url="/static/index.html")
-
-
-# Health check endpoint
-@app.get("/health")
-async def health():
-    """Health check endpoint."""
-    return {"status": "healthy", "app": "reachy-f1-commentator"}
-
-
-@app.websocket("/ws/dashboard")
-async def dashboard_websocket(websocket: WebSocket):
-    """WebSocket endpoint for live dashboard updates."""
-    await dashboard_manager.connect(websocket)
-    try:
-        while True:
-            # Process any queued broadcasts
-            while dashboard_manager.broadcast_queue:
-                message = dashboard_manager.broadcast_queue.pop(0)
-                await dashboard_manager.broadcast(message)
-            
-            # Wait a bit before checking queue again
-            await asyncio.sleep(0.1)
-            
-            # Check if client sent any messages (for keep-alive)
-            try:
-                data = await asyncio.wait_for(websocket.receive_text(), timeout=0.1)
-                # Echo back for ping/pong
-                await websocket.send_text(data)
-            except asyncio.TimeoutError:
-                # No message received, continue
-                pass
-                
-    except WebSocketDisconnect:
-        dashboard_manager.disconnect(websocket)
-    except Exception as e:
-        logger.error(f"WebSocket error: {e}")
-        dashboard_manager.disconnect(websocket)
-
-
-@app.get("/api/dashboard/state")
-async def get_dashboard_state():
-    """Get current race state for dashboard."""
-    try:
-        if _app_instance is None or _app_instance.state_tracker is None:
-            return {
-                "positions": [],
-                "race_info": {
-                    "current_lap": 0,
-                    "total_laps": 0,
-                    "leader": None,
-                    "fastest_lap_holder": None,
-                    "race_phase": "START"
-                },
-                "recent_events": []
-            }
-        
-        # Get positions
-        positions = _app_instance.state_tracker.get_positions()
-        positions_data = [
-            {
-                "position": p.position,
-                "driver": p.name,
-                "gap_to_leader": f"+{p.gap_to_leader:.3f}s" if p.gap_to_leader > 0 else "Leader",
-                "tire_compound": p.current_tire or "Unknown",
-                "pit_stops": p.pit_count,
-                "team": "Unknown"  # Team info not available in DriverState
-            }
-            for p in positions[:20]  # Top 20
-        ]
-        
-        # Get race info
-        leader = _app_instance.state_tracker.get_leader()
-        state = _app_instance.state_tracker._state  # Access private _state attribute
-        
-        race_info = {
-            "current_lap": state.current_lap,
-            "total_laps": state.total_laps,
-            "leader": leader.name if leader else None,
-            "fastest_lap_holder": state.fastest_lap_driver,
-            "fastest_lap_time": f"{state.fastest_lap_time:.3f}s" if state.fastest_lap_time else None,
-            "race_phase": state.race_phase.value if state.race_phase else "START",
-            "safety_car": state.safety_car_active
-        }
-        
-        return {
-            "positions": positions_data,
-            "race_info": race_info,
-            "recent_events": []  # TODO: Add event history
-        }
-    except Exception as e:
-        logger.error(f"Failed to get dashboard state: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
 # ============================================================================
 # Standalone Mode Entry Point
 # ============================================================================
@@ -1014,6 +1034,7 @@ if __name__ == "__main__":
     The app will auto-detect and connect to Reachy if available.
     """
     import uvicorn
+    from fastapi import FastAPI
     
     logger.info("=" * 60)
     logger.info("Starting Reachy F1 Commentator in standalone mode")
@@ -1038,15 +1059,28 @@ if __name__ == "__main__":
         logger.info("   Running without Reachy - audio playback disabled")
         logger.info("   This is normal for development/testing")
     
+    # Create a standalone FastAPI app for development
+    standalone_app = FastAPI(title="Reachy F1 Commentator API (Standalone)")
+    
+    # Manually set up the app's settings_app to use our standalone app
+    commentator.settings_app = standalone_app
+    
+    # Setup API routes
+    commentator._setup_api_routes()
+    
     # Run FastAPI server on port 8080 (port 8000 is used by Reachy)
     logger.info("")
     logger.info("Starting web server on http://localhost:8080")
     logger.info("Open http://localhost:8080 in your browser")
     logger.info("=" * 60)
     
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=8080,
-        log_level="info"
-    )
+    try:
+        uvicorn.run(
+            standalone_app,
+            host="0.0.0.0",
+            port=8080,
+            log_level="info"
+        )
+    except KeyboardInterrupt:
+        logger.info("Shutting down...")
+        commentator._cleanup()

reachy_f1_commentator/static/dashboard.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Live Race Dashboard - Reachy F1 Commentator</title>
-    <link rel="stylesheet" href="dashboard.css">
+    <link rel="stylesheet" href="/static/dashboard.css">
 </head>
 <body>
     <div class="dashboard-container">
@@ -69,6 +69,6 @@
         </footer>
     </div>
 
-    <script src="dashboard.js"></script>
+    <script src="/static/dashboard.js"></script>
 </body>
 </html>

reachy_f1_commentator/static/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Reachy F1 Commentator</title>
-    <link rel="stylesheet" href="style.css">
+    <link rel="stylesheet" href="/static/style.css">
 </head>
 <body>
     <div class="container">
@@ -14,7 +14,7 @@
                     <h1>🏎️ Reachy F1 Commentator</h1>
                     <p class="subtitle">Interactive F1 Race Commentary</p>
                 </div>
-                <a href="dashboard.html" class="dashboard-link" target="_blank">
+                <a href="/static/dashboard.html" class="dashboard-link" target="_blank">
                     📊 Live Dashboard
                 </a>
             </div>
@@ -142,6 +142,6 @@
         </div>
     </div>
 
-    <script src="main.js"></script>
+    <script src="/static/main.js"></script>
 </body>
 </html>