Update app.py

app.py

@@ -13,16 +13,14 @@ import whisperx
 # ─────────────────────────────────────────────
 # Config
 # ─────────────────────────────────────────────
-DEVICE = "cpu"                  # change to "cuda" if you have GPU
-COMPUTE_TYPE = "int8"           # "float16" on GPU, "int8" good on CPU
-WHISPER_MODEL_SIZE = "tiny"     # "tiny", "base", "small", "medium", "large-v3" ...
+DEVICE = "cpu"          # change to "cuda" if you have GPU
+COMPUTE_TYPE = "int8"   # "float16" on GPU, "int8" is good on CPU
+WHISPER_MODEL_SIZE = "tiny"  # "tiny", "base", "small", "medium", "large-v3" ...
 SAMPLE_RATE = 16000
-MODEL_LANGUAGE = None           # None = multilingual / auto-detect
+MODEL_LANGUAGE = None   # None = multilingual / auto-detect
 
 # Global (lazy loaded)
 asr_model = None
-align_model = None
-align_metadata = None
 
 def load_whisperx_model():
     global asr_model
@@ -32,117 +30,54 @@ def load_whisperx_model():
             WHISPER_MODEL_SIZE,
             device=DEVICE,
             compute_type=COMPUTE_TYPE,
-            language=MODEL_LANGUAGE,   # None = auto
+            language=MODEL_LANGUAGE,  # None = auto
             download_root=os.path.expanduser("~/.cache/whisperx")
         )
         print("✅ WhisperX transcription model loaded.")
     return asr_model
 
-def load_align_model(lang_code: str):
-    global align_model, align_metadata
-    if align_model is None or align_metadata is None:
-        print(f"⏳ Loading alignment model for language '{lang_code}' …")
-        align_model, align_metadata = whisperx.load_align_model(
-            language_code=lang_code,
-            device=DEVICE
-        )
-        print("✅ Alignment model loaded.")
-    return align_model, align_metadata
-
 # ─────────────────────────────────────────────
-# Core transcription + alignment
+# Core transcription (text only — no timestamps)
 # ─────────────────────────────────────────────
 def transcribe_audio(
     audio_path: str,
     language: str = "auto",
     task: str = "transcribe",
-    timestamps: str = "segment"   # "none", "segment", "word"
 ) -> dict:
-    global asr_model
-
     print(f"Processing audio: {audio_path}")
-
-    # Load audio (whisperx helper handles many formats)
+    
+    # Load audio
     audio = whisperx.load_audio(audio_path)
-
-    # Load transcription model
+    
+    # Load model
     model = load_whisperx_model()
-
+    
     # Transcribe
     transcribe_options = {
         "language": None if language == "auto" else language,
         "task": task,
-        "batch_size": 8 if DEVICE == "cpu" else 16,  # tune for your RAM
+        "batch_size": 8 if DEVICE == "cpu" else 16,
         "chunk_size": 30,
     }
-
+    
     result = model.transcribe(audio, **transcribe_options)
-
+    
     full_text = result["text"].strip()
     detected_lang = result.get("language", "unknown")
-
-    chunks_out = []
-
-    if timestamps != "none" and "segments" in result:
-        # Load alignment model (only once per language)
-        align_model_, meta = load_align_model(detected_lang)
-
-        # Align → this gives word-level timestamps
-        aligned_result = whisperx.align(
-            result["segments"],
-            align_model_,
-            meta,
-            audio,
-            DEVICE,
-            return_char_alignments=False  # word level
-        )
-
-        # Format output like your original
-        for segment in aligned_result["segments"]:
-            if "words" in segment:
-                for word_info in segment["words"]:
-                    chunks_out.append({
-                        "text": word_info["word"].strip(),
-                        "timestamp": [
-                            round(word_info.get("start", None), 3),
-                            round(word_info.get("end", None), 3)
-                        ]
-                    })
-            else:
-                # fallback to segment level if words missing
-                chunks_out.append({
-                    "text": segment["text"].strip(),
-                    "timestamp": [
-                        round(segment.get("start", None), 3),
-                        round(segment.get("end", None), 3)
-                    ]
-                })
-
+    
     return {
         "text": full_text,
         "language": detected_lang,
-        "chunks": chunks_out,
         "warning": None
     }
 
-def _chunks_to_display(chunks: list) -> str:
-    if not chunks:
-        return "(no timestamped chunks)"
-    lines = []
-    for c in chunks:
-        ts = c.get("timestamp", [None, None])
-        s = f"{ts[0]:.2f}s" if ts[0] is not None else "?"
-        e = f"{ts[1]:.2f}s" if ts[1] is not None else "?"
-        lines.append(f"[{s} → {e}] {c['text']}")
-    return "\n".join(lines)
-
 # ─────────────────────────────────────────────
 # FastAPI app
 # ─────────────────────────────────────────────
 app = FastAPI(
-    title="MythAI STT — WhisperX Edition",
-    description="Speech-to-Text with word-level timestamps via WhisperX + faster-whisper",
-    version="3.0-whisperx",
+    title="MythAI STT — WhisperX Simple",
+    description="Basic Speech-to-Text using WhisperX / faster-whisper (text only)",
+    version="3.0-simple",
 )
 
 app.add_middleware(
@@ -155,9 +90,9 @@ app.add_middleware(
 @app.get("/")
 async def root():
     return {
-        "message": "MythAI STT (WhisperX) is active",
+        "message": "MythAI STT (simple text-only) is active",
         "model": f"faster-whisper-{WHISPER_MODEL_SIZE}",
-        "timestamps": "word-level via alignment",
+        "timestamps": "none",
         "ui": "/ui",
     }
 
@@ -166,7 +101,6 @@ async def health():
     return {
         "status": "ok",
         "model_loaded": asr_model is not None,
-        "align_loaded": align_model is not None,
     }
 
 @app.post("/transcribe")
@@ -174,7 +108,6 @@ async def transcribe_endpoint(
     file: UploadFile = File(...),
     language: str = Query("auto"),
     task: str = Query("transcribe", pattern="^(transcribe|translate)$"),
-    timestamps: str = Query("word", pattern="^(none|segment|word)$"),
 ):
     try:
         suffix = os.path.splitext(file.filename or "audio")[1] or ".wav"
@@ -186,18 +119,19 @@ async def transcribe_endpoint(
             tmp_path,
             language=language,
             task=task,
-            timestamps=timestamps,
         )
+
         os.unlink(tmp_path)
         return JSONResponse(content=result)
+
     except Exception as e:
         print(f"API error: {e}")
         return JSONResponse(status_code=500, content={"error": str(e)})
 
 # ─────────────────────────────────────────────
-# Gradio UI
+# Gradio UI — simplified (no timestamp options)
 # ─────────────────────────────────────────────
-def gradio_transcribe(audio_input, language: str, task: str, timestamps: str):
+def gradio_transcribe(audio_input, language: str, task: str):
     try:
         if audio_input is None:
             return "⚠️ Upload or record audio first.", ""
@@ -222,7 +156,6 @@ def gradio_transcribe(audio_input, language: str, task: str, timestamps: str):
                 tmp_path,
                 language if language != "Auto-detect" else "auto",
                 task.lower(),
-                timestamps.lower(),
             )
         finally:
             if cleanup:
@@ -231,9 +164,7 @@ def gradio_transcribe(audio_input, language: str, task: str, timestamps: str):
         lang_note = f"**Detected language:** {result['language']}\n\n"
         transcript = lang_note + result["text"]
 
-        segments_txt = _chunks_to_display(result["chunks"])
-
-        return transcript, segments_txt
+        return transcript, ""
 
     except Exception as e:
         msg = f"❌ Error: {str(e)}"
@@ -241,16 +172,17 @@ def gradio_transcribe(audio_input, language: str, task: str, timestamps: str):
         return msg, ""
 
 # UI setup
-LANG_OPTIONS = ["Auto-detect", "en", "es", "fr", "de", "it", "ja", "zh", "ru", "ko", "pt"]  # add more if needed
+LANG_OPTIONS = ["Auto-detect", "en", "es", "fr", "de", "it", "ja", "zh", "ru", "ko", "pt"]
 
 with gr.Blocks(
-    title="MythAI STT — WhisperX",
+    title="MythAI STT — Simple",
     theme=gr.themes.Soft(primary_hue="violet", secondary_hue="purple"),
 ) as demo:
     gr.Markdown("""
-    # 🎤 MythAI STT — WhisperX Edition
-    Fast transcription + **word-level timestamps** using faster-whisper + forced alignment  
-    (much more accurate than native Whisper timestamps)
+    # 🎤 MythAI STT — Simple Edition
+    Fast plain-text transcription using **faster-whisper**
+    
+    (no timestamps / alignment — just the text)
     """)
 
     with gr.Row():
@@ -259,23 +191,21 @@ with gr.Blocks(
         with gr.Column():
             language_dd = gr.Dropdown(LANG_OPTIONS, value="Auto-detect", label="Language")
             task_radio = gr.Radio(["transcribe", "translate"], value="transcribe", label="Task")
-            timestamps_radio = gr.Radio(["none", "segment", "word"], value="word", label="Timestamps")
-
             submit_btn = gr.Button("Transcribe", variant="primary")
 
     transcript_out = gr.Markdown(label="Transcript")
-    segments_out = gr.Textbox(label="Word / Segment Timestamps", lines=12, interactive=False)
+    gr.Markdown("No word/segment timestamps in this version.")
 
     submit_btn.click(
         gradio_transcribe,
-        inputs=[audio_input, language_dd, task_radio, timestamps_radio],
-        outputs=[transcript_out, segments_out]
+        inputs=[audio_input, language_dd, task_radio],
+        outputs=[transcript_out, gr.State()]   # dummy second output to keep layout
     )
 
     gr.Markdown("""
     ---
-    **API Endpoints**  
-    • POST /transcribe (file, language, task, timestamps)  
+    **API Endpoints**
+    • POST /transcribe (file, language, task)
     • GET /health
     """)
 
@@ -285,8 +215,8 @@ app = gr.mount_gradio_app(app, demo, path="/ui")
 if __name__ == "__main__":
     import uvicorn
     print("\n" + "="*60)
-    print("MythAI STT (WhisperX) starting …")
-    print("UI:        http://0.0.0.0:7860/ui")
-    print("API docs:  http://0.0.0.0:7860/docs")
+    print("MythAI STT (simple text-only) starting …")
+    print("UI:   http://0.0.0.0:7860/ui")
+    print("Docs: http://0.0.0.0:7860/docs")
     print("="*60 + "\n")
     uvicorn.run(app, host="0.0.0.0", port=7860)