lite-start

api/route/convert_from_mp3.py

@@ -6,6 +6,9 @@ from pathlib import Path
 import uuid
 from typing import List
 import asyncio
+import subprocess
+import shutil
+import uuid
 # moviepy is imported lazily inside the conversion function to avoid
 # failing module import at application startup when the package is missing.
 
@@ -85,4 +88,98 @@ async def video_to_mp3(req: VideoToMp3Request):
     return FileResponse(str(dest), filename=dest.name, media_type="audio/mpeg")
 
 
+# Convert an existing MP3 (in data/audio) to WAV and run transcription
+class Mp3ToTextRequest(BaseModel):
+    filename: str
+    model_path: str
+
+
+def _run_ffmpeg(src: Path, dest: Path):
+    # produce mono 16k WAV suitable for Vosk
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(src),
+        "-ac",
+        "1",
+        "-ar",
+        "16000",
+        "-vn",
+        "-f",
+        "wav",
+        str(dest),
+    ]
+    subprocess.run(cmd, check=True)
+
+
+@router.post("/mp3-to-text")
+async def mp3_to_text(req: Mp3ToTextRequest):
+    logger = __import__("logging").getLogger("convert.mp3-to-text")
+    try:
+        if shutil.which("ffmpeg") is None:
+            raise HTTPException(status_code=503, detail="ffmpeg is not available in the runtime. Install ffmpeg in the environment/container.")
+    except Exception:
+        raise HTTPException(status_code=503, detail="ffmpeg is not available in the runtime. Install ffmpeg in the environment/container.")
+
+    data_dir = Path(__file__).resolve().parent.parent.parent / "data"
+    audio_dir = data_dir / "audio"
+    src = (audio_dir / req.filename).resolve()
+    try:
+        src.relative_to(audio_dir)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid filename")
+    if not src.exists() or not src.is_file():
+        raise HTTPException(status_code=404, detail="Source file not found")
+
+    audio_dir.mkdir(parents=True, exist_ok=True)
+    dest = audio_dir / f"{src.stem}_{uuid.uuid4().hex}.wav"
+
+    try:
+        logger.info("Starting ffmpeg conversion %s -> %s", src.name, dest.name)
+        await asyncio.get_running_loop().run_in_executor(None, _run_ffmpeg, src, dest)
+        logger.info("ffmpeg conversion finished")
+    except subprocess.CalledProcessError as e:
+        raise HTTPException(status_code=500, detail=f"ffmpeg conversion failed: {e}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"conversion failed: {e}")
+
+    # Use class-based transcriber
+    try:
+        from api.lib.audio_processing import VoskModelManager
+    except Exception as e:
+        try:
+            dest.unlink()
+        except Exception:
+            pass
+        raise HTTPException(status_code=500, detail=f"Internal import error: {e}")
+
+    try:
+        logger.info("Starting transcription stage for %s", dest.name)
+        # Resolve model path (relative to project root or absolute) and ensure it's inside ./models
+        project_root = Path(__file__).resolve().parent.parent.parent
+        models_dir = project_root / "models"
+        model_path = Path(req.model_path)
+        if not model_path.is_absolute():
+            model_path = project_root / req.model_path
+        model_path = model_path.resolve()
+        try:
+            model_path.relative_to(models_dir)
+        except Exception:
+            raise HTTPException(status_code=400, detail="model_path must point inside the project's models directory")
+        if not model_path.exists():
+            raise HTTPException(status_code=400, detail=f"Model path not found: {model_path}")
+
+        mgr = VoskModelManager(model_path)
+        text = mgr.transcribe_wav(dest)
+        logger.info("Transcription stage finished for %s", dest.name)
+    finally:
+        try:
+            dest.unlink()
+        except Exception:
+            pass
+
+    return {"text": text}
+
+
 # Note: this endpoint uses the bundled ffmpeg provided by `imageio-ffmpeg`.

api/route/convert_mp3_to_text.py

@@ -0,0 +1,134 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from pathlib import Path
+import subprocess
+import shutil
+import json
+import logging
+
+try:
+    from vosk import Model, KaldiRecognizer
+except Exception:
+    Model = None
+    KaldiRecognizer = None
+
+router = APIRouter(prefix="/convert", tags=["convert"])
+
+
+class Mp3ToTextRequest(BaseModel):
+    filename: str
+    model_path: str
+
+
+@router.post("/mp3-to-text-ffmpeg")
+async def mp3_to_text_ffmpeg(req: Mp3ToTextRequest):
+    """Convert MP3 -> PCM via ffmpeg (stdout) and transcribe with Vosk.
+
+    This endpoint requires `ffmpeg` available in PATH. It decodes the input
+    MP3 to raw PCM s16le 16k mono and streams it into Vosk recognizer.
+    """
+    logger = logging.getLogger("convert.mp3")
+
+    if Model is None or KaldiRecognizer is None:
+        raise HTTPException(status_code=503, detail="vosk is not installed in runtime")
+
+    project_root = Path(__file__).resolve().parent.parent.parent
+    audio_dir = project_root / "data" / "audio"
+    models_dir = project_root / "models"
+
+    src = (audio_dir / req.filename).resolve()
+    try:
+        src.relative_to(audio_dir)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid filename")
+    if not src.exists() or not src.is_file():
+        raise HTTPException(status_code=404, detail="Source file not found")
+
+    model_path = Path(req.model_path)
+    if not model_path.is_absolute():
+        model_path = project_root / req.model_path
+    model_path = model_path.resolve()
+    try:
+        model_path.relative_to(models_dir)
+    except Exception:
+        raise HTTPException(status_code=400, detail="model_path must point inside the project's models directory")
+    if not model_path.exists():
+        raise HTTPException(status_code=400, detail=f"Model path not found: {model_path}")
+
+    if shutil.which("ffmpeg") is None:
+        raise HTTPException(status_code=503, detail="ffmpeg is not available in the runtime. Install ffmpeg to use this endpoint.")
+
+    try:
+        from api.lib.audio_processing import FFmpegConverter, VoskModelManager
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal import error: {e}")
+
+    if shutil.which("ffmpeg") is None:
+        raise HTTPException(status_code=503, detail="ffmpeg is not available in the runtime. Install ffmpeg to use this endpoint.")
+
+    # Stream decode via ffmpeg to temporary process and feed recognizer
+    try:
+        mgr = VoskModelManager(model_path)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to load Vosk model: {e}")
+
+    cmd = [
+        "ffmpeg",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        str(src),
+        "-f",
+        "s16le",
+        "-acodec",
+        "pcm_s16le",
+        "-ac",
+        "1",
+        "-ar",
+        "16000",
+        "-",
+    ]
+
+    logger.info("Starting ffmpeg streaming decode")
+    try:
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to start ffmpeg: {e}")
+
+    if proc.stdout is None:
+        proc.kill()
+        raise HTTPException(status_code=500, detail="ffmpeg did not provide stdout")
+
+    recognizer = None
+    try:
+        recognizer = KaldiRecognizer(mgr.model, 16000)
+        bytes_read = 0
+        total = None
+        try:
+            total = src.stat().st_size
+        except Exception:
+            total = None
+
+        last_pct = 0
+        while True:
+            chunk = proc.stdout.read(4000)
+            if not chunk:
+                break
+            recognizer.AcceptWaveform(chunk)
+            bytes_read += len(chunk)
+            if total:
+                pct = int(bytes_read * 100 / total)
+                if pct - last_pct >= 5:
+                    last_pct = pct
+                    logger.info("Decoding+transcription progress: %s%%", pct)
+
+        result = json.loads(recognizer.FinalResult())
+        text = result.get("text", "")
+        logger.info("Transcription finished; result length=%d", len(text))
+        return {"text": text}
+    finally:
+        try:
+            proc.kill()
+        except Exception:
+            pass