changing from /

inference.py

@@ -1,7 +1,7 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Response
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 from shared import RealtimeSpeakerDiarization
-import os
+import numpy as np
 import uvicorn
 import logging
 import asyncio
@@ -13,12 +13,6 @@ 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,
@@ -44,13 +38,21 @@ async def send_conversation_updates():
     """Periodically send conversation updates to all connected clients"""
     while True:
         if active_connections:
-            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)
+            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
         await asyncio.sleep(0.5)  # 500ms update interval
 
 @app.on_event("startup")
@@ -72,24 +74,30 @@ async def ws_inference(ws: WebSocket):
     """WebSocket endpoint for real-time audio processing"""
     await ws.accept()
     active_connections.add(ws)
-    logger.info(f"WebSocket connected. Total: {len(active_connections)}")
+    logger.info(f"WebSocket connection established. Total connections: {len(active_connections)}")
+    
     try:
         # Send initial conversation state
-        await ws.send_text(diart.get_formatted_conversation())
+        conversation_html = diart.get_formatted_conversation()
+        await ws.send_text(conversation_html)
+        
         # Process incoming audio chunks
         async for chunk in ws.iter_bytes():
-            if chunk:
-                try:
+            try:
+                # Process raw audio bytes
+                if chunk:
+                    # Process audio data - this updates the internal conversation state
                     diart.process_audio_chunk(chunk)
-                except Exception as e:
-                    logger.error(f"Error processing chunk: {e}")
+            except Exception as e:
+                logger.error(f"Error processing audio 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 closed. Remaining: {len(active_connections)}")
+        logger.info(f"WebSocket connection closed. Remaining connections: {len(active_connections)}")
 
 @app.get("/conversation")
 async def get_conversation():
@@ -104,21 +112,22 @@ async def get_status():
 @app.post("/settings")
 async def update_settings(threshold: float, max_speakers: int):
     """Update speaker detection settings"""
-    return {"result": diart.update_settings(threshold, max_speakers)}
+    result = diart.update_settings(threshold, max_speakers)
+    return {"result": result}
 
 @app.post("/clear")
 async def clear_conversation():
     """Clear the conversation"""
-    return {"result": diart.clear_conversation()}
+    result = diart.clear_conversation()
+    return {"result": result}
 
-# Mount Gradio UI at /ui so it doesn't override API/WebSocket routes
+# Import UI module to mount the Gradio app
 try:
     import ui
-    ui.mount_ui(app, path="/ui")
-    logger.info("Gradio UI mounted at /ui")
+    ui.mount_ui(app)
+    logger.info("Gradio UI mounted successfully")
 except ImportError:
     logger.warning("UI module not found, running in API-only mode")
 
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", 10000))
-    uvicorn.run("backend:app", host="0.0.0.0", port=port)
+    uvicorn.run(app, host="0.0.0.0", port=7860)