Upload folder using huggingface_hub

Dockerfile

@@ -4,4 +4,4 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 COPY app.py .
 EXPOSE 7860
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--ws-ping-interval", "20", "--ws-ping-timeout", "40"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -49,7 +49,7 @@ for size, repo in MODEL_IDS.items():
         local_dir = snapshot_download(repo_id=repo, token=HF_TOKEN)
         PROCESSORS[size] = WhisperProcessor.from_pretrained(local_dir)
         MODELS[size] = ctranslate2.models.Whisper(
-            local_dir, compute_type="int8", inter_threads=1, intra_threads=1
+            local_dir, compute_type="int8", inter_threads=1, intra_threads=2
         )
         log_event("model_loaded_ok", model_size=size)
     except Exception as e:
@@ -247,110 +247,6 @@ async def transcribe(
     return {"request_id": request_id, "model_size": model_size, "language": language, "text": text,
             "audio_duration_s": round(duration_s, 2), "chunks_processed": n_chunks, "elapsed_s": round(elapsed, 2)}
 
-@app.websocket("/ws/transcribe")
-async def ws_transcribe(
-    websocket: WebSocket,
-    model_size: str = Query("large"),
-    language: str = Query(...),
-    token: str = Query(...),
-):
-    try:
-        info = hf_api.whoami(token=token)
-        user_orgs = [o.get("name") for o in info.get("orgs", [])]
-        if ORG_NAME not in user_orgs:
-            await websocket.close(code=4403); return
-        username = info.get("name", "unknown")
-    except Exception:
-        await websocket.close(code=4401); return
-
-    if model_size not in MODELS or language not in VALID_LANGS or VAD_MODEL is None:
-        await websocket.close(code=4400); return
-
-    await websocket.accept()
-    send_lock = asyncio.Lock()
-    async def safe_send_json(payload):
-        async with send_lock:
-            await websocket.send_json(payload)
-    async def heartbeat(interval: float = 20.0):
-        while True:
-            await asyncio.sleep(interval)
-            try:
-                await safe_send_json({"type": "heartbeat"})
-                log_event("ws_heartbeat_sent", user=username)
-            except Exception as e:
-                log_event("ws_heartbeat_failed", user=username, error=str(e))
-                return
-    heartbeat_task = asyncio.create_task(heartbeat())
-    log_event("ws_connected", user=username, model_size=model_size, language=language)
-
-    SR = 16000
-    FRAME_SAMPLES = 512
-    FRAME_BYTES = FRAME_SAMPLES * 2
-    SILENCE_FRAMES_TO_FLUSH = max(1, int(600 / ((FRAME_SAMPLES / SR) * 1000)))
-    MAX_UTTERANCE_SAMPLES = 25 * SR
-    SPEECH_PROB_THRESHOLD = 0.5
-
-    byte_buffer = b""
-    speech_frames, speech_started, silence_run = [], False, 0
-
-    async def flush_and_transcribe():
-        nonlocal speech_frames, speech_started, silence_run
-        if not speech_frames:
-            speech_started, silence_run = False, 0
-            return
-        audio = np.concatenate(speech_frames)
-        speech_frames, speech_started, silence_run = [], False, 0
-        if len(audio) < int(0.2 * SR):
-            return
-        try:
-            text, duration_s, _ = await asyncio.to_thread(run_inference, audio, SR, model_size, language)
-            await safe_send_json({"type": "final", "text": text, "audio_duration_s": round(duration_s, 2)})
-            log_event("ws_utterance_transcribed", user=username, duration_s=round(duration_s, 2))
-        except Exception as e:
-            log_event("ws_transcribe_error", user=username, error=str(e))
-            try:
-                await safe_send_json({"type": "error", "detail": "transcription failed"})
-            except Exception:
-                pass  # socket already closed - nothing to send to
-
-    try:
-        while True:
-            data = await websocket.receive_bytes()
-            byte_buffer += data
-            while len(byte_buffer) >= FRAME_BYTES:
-                frame_bytes, byte_buffer = byte_buffer[:FRAME_BYTES], byte_buffer[FRAME_BYTES:]
-                frame_f32 = np.frombuffer(frame_bytes, dtype=np.int16).astype(np.float32) / 32768.0
-                prob = VAD_MODEL(torch.from_numpy(frame_f32), SR).item()
-
-                if prob >= SPEECH_PROB_THRESHOLD:
-                    if not speech_started:
-                        speech_started = True
-                        await safe_send_json({"type": "speech_start"})
-                    speech_frames.append(frame_f32)
-                    silence_run = 0
-                elif speech_started:
-                    speech_frames.append(frame_f32)
-                    silence_run += 1
-                    if silence_run >= SILENCE_FRAMES_TO_FLUSH:
-                        await flush_and_transcribe()
-
-                if sum(len(f) for f in speech_frames) >= MAX_UTTERANCE_SAMPLES:
-                    log_event("ws_max_utterance_reached", user=username)
-                    await flush_and_transcribe()
-    except WebSocketDisconnect:
-        log_event("ws_disconnected", user=username)
-        # client is gone - do not attempt to send anything further.
-        # just discard any partial in-flight utterance rather than
-        # transcribing into a socket that no longer exists.
-    except RuntimeError as e:
-        # server-initiated close (e.g. ping timeout) leaves the socket in
-        # a disconnected state; a subsequent receive_bytes() raises
-        # RuntimeError instead of WebSocketDisconnect. Treat the same way.
-        log_event("ws_disconnected_runtime", user=username, error=str(e))
-    finally:
-        heartbeat_task.cancel()
-
-
 @app.exception_handler(HTTPException)
 async def http_exception_handler(request: Request, exc: HTTPException):
     log_event("request_error", path=str(request.url.path), status=exc.status_code, detail=exc.detail)

requirements.txt

@@ -16,3 +16,4 @@ websockets
 # force rebuild 1786901172
 # force rebuild 1786902184
 # force rebuild 1786902905
+# revert streaming, force rebuild 1786903429