7th

routes/transcripe.py

@@ -13,6 +13,7 @@ from models.database import get_db
 from sqlalchemy.exc import IntegrityError
 from websockets.exceptions import ConnectionClosedOK, ConnectionClosedError
 import aiohttp, asyncio
+from stores.sttremotes import NoSpeechDetected, ProviderUnavailable
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -22,38 +23,6 @@ transcripe_router = APIRouter(
         tags=["transcripe"]) 
 
 
-# @transcripe_router.post("/transcribe")
-# async def transcribe_endpoint(file: UploadFile = File(...),session_id: str = None,chunk_number: int = 0, db: AsyncSession = Depends(get_db)):    
-#     if not session_id or session_id.strip() == "":
-#         session_id = f"ses_{uuid.uuid4().hex[:8]}"
-    
-#     session = await get_session(db, session_id)
-#     if not session:
-#         session = await create_session(db, session_id)
-
-#     with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as temp_file:
-#         content = await file.read()
-#         temp_file.write(content)
-#         temp_path = temp_file.name
-    
-#     try:
-#         controller = TranscriptionController(models, logger, remotename=get_settings().REMOTE_INFERENCE_PROVIDER)
-#         text, language = await controller.transcribe_audio(temp_path)
-
-#         if text:
-#             transcription = await create_transcription(db, session_id, chunk_number, text, language)
-        
-#         return {
-#             "id": transcription.id,
-#             "session_id": transcription.session_id,
-#             "chunk_number": transcription.chunk_number,
-#             "text": transcription.text,
-#             "language": transcription.language,
-#             "created_at": transcription.created_at
-#         }
-#     finally:
-#         if os.path.exists(temp_path):
-#             os.remove(temp_path)
 
 
 @transcripe_router.post("/transcribe")
@@ -72,22 +41,26 @@ async def transcribe_endpoint(
             session = await create_session(db, session_id)
         except IntegrityError:
             await db.rollback()
-            session = await get_session(db, session_id)  
-
-    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as temp_file:
-        content = await file.read()
-        temp_file.write(content)
-        temp_path = temp_file.name
+            session = await get_session(db, session_id)
 
+    temp_path = None
     try:
-        controller = TranscriptionController(models, logger, remotename=get_settings().REMOTE_INFERENCE_PROVIDER)
-        text, language = await controller.transcribe_audio(temp_path)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as f:
+            f.write(await file.read())
+            temp_path = f.name
+
+        controller = TranscriptionController(
+            models, logger, remotename=get_settings().REMOTE_INFERENCE_PROVIDER
+        )
 
-        if not text or text.strip() == "":
+        try:
+            text, language = await controller.transcribe_audio(temp_path)
+        except NoSpeechDetected:
             return {"status": "no_speech", "session_id": session_id, "chunk_number": chunk_number}
+        except ProviderUnavailable as e:
+            raise HTTPException(status_code=503, detail=str(e))
 
         transcription = await create_transcription(db, session_id, chunk_number, text, language)
-
         return {
             "id": transcription.id,
             "session_id": transcription.session_id,
@@ -97,7 +70,7 @@ async def transcribe_endpoint(
             "created_at": transcription.created_at,
         }
     finally:
-        if os.path.exists(temp_path):
+        if temp_path and os.path.exists(temp_path):
             os.remove(temp_path)
 
 
@@ -110,19 +83,24 @@ async def websocket_endpoint(
 ):
     await websocket.accept()
 
-    result = await get_session(db, session_id)
-    if not result:
+    session = await get_session(db, session_id)
+    if not session:
         try:
-            result = await create_session(db, session_id)
+            session = await create_session(db, session_id)
         except IntegrityError:
             await db.rollback()
-            result = await get_session(db, session_id)
+            session = await get_session(db, session_id)
 
-    if not result:
+    if not session:
         await websocket.send_json({"error": "Session not found nor created"})
         await websocket.close()
         return
 
+    if not models:
+        await websocket.send_json({"error": "Models not yet loaded, please reconnect."})
+        await websocket.close()
+        return
+
     controller = TranscriptionController(
         models, logger, remotename=get_settings().REMOTE_INFERENCE_PROVIDER
     )
@@ -134,64 +112,51 @@ async def websocket_endpoint(
         while True:
             message = await websocket.receive()
             if message["type"] == "websocket.disconnect":
-                logger.info(f"Client sent disconnect frame for session {session_id}")
+                logger.info(f"Client disconnected for session {session_id}")
                 break
 
             data = message.get("bytes")
             if not data:
-                logger.warning(f"Received non-bytes message on chunk {chunk_number}, skipping")
+                logger.warning(f"Non-bytes message on chunk {chunk_number}, skipping")
                 continue
 
-            logger.info(f"Received audio chunk {chunk_number} ({len(data)} bytes)")
+            logger.info(f"Received chunk {chunk_number} ({len(data)} bytes)")
 
             temp_path = None
             try:
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".webm") as temp_file:
-                    temp_file.write(data)
-                    temp_path = temp_file.name
-
-                MAX_RETRIES = 3
-                text, language = None, None
-                last_exc = None
-                for attempt in range(MAX_RETRIES):
-                    try:
-                        text, language = await controller.transcribe_audio(temp_path)
-                        break
-                    except (aiohttp.ServerDisconnectedError, asyncio.TimeoutError) as e:
-                        last_exc = e
-                        logger.warning(
-                            f"Remote inference attempt {attempt + 1} failed for "
-                            f"chunk {chunk_number}: {e}"
-                        )
-                        if attempt < MAX_RETRIES - 1:
-                            await asyncio.sleep(2 ** attempt)
-
-                if text is None and last_exc is not None:
-                    await websocket.send_json({
-                        "chunk_number": chunk_number,
-                        "status": "inference_unavailable",
-                        "error": str(last_exc)
-                    })
-                    chunk_number += 1
-                    continue
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".webm") as f:
+                    f.write(data)
+                    temp_path = f.name
 
-                if text and text.strip():
+                try:
+                    text, language = await controller.transcribe_audio(temp_path)
+                    # Success — save and send back
                     await create_transcription(db, session_id, chunk_number, text, language)
                     await websocket.send_json({
+                        "status": "ok",
                         "chunk_number": chunk_number,
                         "text": text,
                         "language": language,
                         "session_id": session_id,
-                        "status": "ok"
                     })
-                    logger.info(f"Transcribed chunk {chunk_number} ({language}): {text[:50]}...")
-                else:
+                    logger.info(f"Chunk {chunk_number} ({language}): {text[:50]}...")
+
+                except NoSpeechDetected:
+                    # Silent chunk — keep connection alive, tell the client
                     await websocket.send_json({
-                        "chunk_number": chunk_number,
                         "status": "no_speech",
-                        "language": language
+                        "chunk_number": chunk_number,
+                    })
+                    logger.info(f"Chunk {chunk_number}: no speech detected")
+
+                except ProviderUnavailable as e:
+                    # Provider is down — keep connection alive, client can retry
+                    await websocket.send_json({
+                        "status": "provider_unavailable",
+                        "chunk_number": chunk_number,
+                        "error": str(e),
                     })
-                    logger.info(f"Chunk {chunk_number} ignored (no speech, detected lang: {language})")
+                    logger.error(f"Chunk {chunk_number}: provider unavailable — {e}")
 
                 chunk_number += 1
 
@@ -206,7 +171,7 @@ async def websocket_endpoint(
         logger.info(f"WebSocket closed cleanly for session {session_id}: {e}")
 
     except Exception as e:
-        logger.error(f"Unhandled error in WebSocket for session {session_id}: {e}", exc_info=True)
+        logger.error(f"Unhandled error for session {session_id}: {e}", exc_info=True)
         try:
             await websocket.send_json({"error": str(e)})
         except Exception:
@@ -217,58 +182,6 @@ async def websocket_endpoint(
             pass
 
 
-# @transcripe_router.websocket("/ws/{session_id}")
-# async def websocket_endpoint(websocket: WebSocket, session_id: str, db: AsyncSession = Depends(get_db)):
-#     await websocket.accept()
-
-#     result = await get_session(db, session_id)
-#     if not result:
-#         result = await create_session(db, session_id)
-    
-#     if not result:
-#         await websocket.send_json({"error": "Session not found nor created"})
-#         await websocket.close()
-#         return
-    
-#     chunk_number = 0
-#     logger.info(f"WebSocket connection established for session {session_id}")
-    
-#     try:
-#         while True:
-#             data = await websocket.receive_bytes()
-#             logger.info(f"Received audio chunk {chunk_number} ({len(data)} bytes)")
-
-#             with tempfile.NamedTemporaryFile(delete=False, suffix=".webm") as temp_file:
-#                 temp_file.write(data)
-#                 temp_path = temp_file.name
-            
-#             try:
-#                 controller = TranscriptionController(models, logger, remotename=get_settings().REMOTE_INFERENCE_PROVIDER)
-#                 text, language = await controller.transcribe_audio(temp_path)
-                
-#                 if text:
-#                     transcription = await create_transcription(db, session_id, chunk_number, text, language)
-#                     await websocket.send_json({
-#                         "chunk_number": chunk_number,
-#                         "text": text,
-#                         "language": language,
-#                         "session_id": session_id
-#                     })
-#                     logger.info(f"Transcribed chunk {chunk_number} ({language}): {text[:50]}...")
-#                 else:
-#                     logger.info(f"Chunk {chunk_number} ignored (Detected: {language})")
-                
-#                 chunk_number += 1
-#             finally:
-#                 if os.path.exists(temp_path):
-#                     os.remove(temp_path)
-    
-#     except WebSocketDisconnect:
-#         logger.info(f"WebSocket disconnected for session {session_id}")
-#     except Exception as e:
-#         logger.error(f"Error in WebSocket: {str(e)}")
-#         await websocket.send_json({"error": str(e)})
-#         await websocket.close()
 
 models={}