changing from /

inference.py

@@ -1,7 +1,7 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Response
 from fastapi.middleware.cors import CORSMiddleware
 from shared import RealtimeSpeakerDiarization
-import numpy as np
+import os
 import uvicorn
 import logging
 import asyncio
@@ -13,6 +13,12 @@ logger = logging.getLogger(__name__)
 # Initialize FastAPI app
 app = FastAPI()
 
+# Respond to HEAD / with a 200 so port scanners don’t see a 405
+@app.head("/", include_in_schema=False)
+@app.get("/")
+async def root():
+    return {"message": "Speaker Diarization Signaling Server"}
+
 # Add CORS middleware for browser compatibility
 app.add_middleware(
     CORSMiddleware,
@@ -38,21 +44,13 @@ async def send_conversation_updates():
     """Periodically send conversation updates to all connected clients"""
     while True:
         if active_connections:
-            try:
-                # Get current conversation HTML
-                conversation_html = diart.get_formatted_conversation()
-                
-                # Send to all active connections
-                for ws in active_connections.copy():
-                    try:
-                        await ws.send_text(conversation_html)
-                    except Exception as e:
-                        logger.error(f"Error sending to WebSocket: {e}")
-                        active_connections.discard(ws)
-            except Exception as e:
-                logger.error(f"Error in conversation update: {e}")
-        
-        # Wait before sending next update
+            conversation_html = diart.get_formatted_conversation()
+            for ws in list(active_connections):
+                try:
+                    await ws.send_text(conversation_html)
+                except Exception as e:
+                    logger.error(f"Error sending to WebSocket: {e}")
+                    active_connections.discard(ws)
         await asyncio.sleep(0.5)  # 500ms update interval
 
 @app.on_event("startup")
@@ -74,30 +72,24 @@ async def ws_inference(ws: WebSocket):
     """WebSocket endpoint for real-time audio processing"""
     await ws.accept()
     active_connections.add(ws)
-    logger.info(f"WebSocket connection established. Total connections: {len(active_connections)}")
-    
+    logger.info(f"WebSocket connected. Total: {len(active_connections)}")
     try:
         # Send initial conversation state
-        conversation_html = diart.get_formatted_conversation()
-        await ws.send_text(conversation_html)
-        
+        await ws.send_text(diart.get_formatted_conversation())
         # Process incoming audio chunks
         async for chunk in ws.iter_bytes():
-            try:
-                # Process raw audio bytes
-                if chunk:
-                    # Process audio data - this updates the internal conversation state
+            if chunk:
+                try:
                     diart.process_audio_chunk(chunk)
-            except Exception as e:
-                logger.error(f"Error processing audio chunk: {e}")
-                
+                except Exception as e:
+                    logger.error(f"Error processing chunk: {e}")
     except WebSocketDisconnect:
         logger.info("WebSocket disconnected")
     except Exception as e:
         logger.error(f"WebSocket error: {e}")
     finally:
         active_connections.discard(ws)
-        logger.info(f"WebSocket connection closed. Remaining connections: {len(active_connections)}")
+        logger.info(f"WebSocket closed. Remaining: {len(active_connections)}")
 
 @app.get("/conversation")
 async def get_conversation():
@@ -112,22 +104,21 @@ async def get_status():
 @app.post("/settings")
 async def update_settings(threshold: float, max_speakers: int):
     """Update speaker detection settings"""
-    result = diart.update_settings(threshold, max_speakers)
-    return {"result": result}
+    return {"result": diart.update_settings(threshold, max_speakers)}
 
 @app.post("/clear")
 async def clear_conversation():
     """Clear the conversation"""
-    result = diart.clear_conversation()
-    return {"result": result}
+    return {"result": diart.clear_conversation()}
 
-# Import UI module to mount the Gradio app
+# Mount Gradio UI at /ui so it doesn't override API/WebSocket routes
 try:
     import ui
-    ui.mount_ui(app)
-    logger.info("Gradio UI mounted successfully")
+    ui.mount_ui(app, path="/ui")
+    logger.info("Gradio UI mounted at /ui")
 except ImportError:
     logger.warning("UI module not found, running in API-only mode")
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860) 
+    port = int(os.getenv("PORT", 10000))
+    uvicorn.run("backend:app", host="0.0.0.0", port=port)

ui.py

@@ -203,7 +203,7 @@ def build_ui():
                             } else {
                                 updateStatus('warning', 'Connection unstable');
                             }
-                        } catch (err) {
+                      } catch (err) {
                             console.error('Error updating connection info:', err);
                         }
                     }
@@ -406,7 +406,7 @@ def build_ui():
         status_timer = gr.Timer(5)
         status_timer.tick(fn=get_status, outputs=status_output)
 
-    
+        
     return demo
 
 # Create Gradio interface