Update app.py

app.py

@@ -1,149 +1,66 @@
 import gradio as gr
 import subprocess
-import numpy as np
-import wave
-from vosk import Model, KaldiRecognizer
-import json
-from datetime import timedelta
 import os
+import traceback
+import srt
+from datetime import timedelta
+from faster_whisper import WhisperModel
 
+# Load tiny model (best for HF free)
+model = WhisperModel("tiny", device="cpu", compute_type="int8")
 
-# -----------------------------
-# Download + Load VOSK model
-# -----------------------------
-if not os.path.exists("model"):
-    os.system("wget https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip")
-    os.system("unzip vosk-model-small-en-us-0.15.zip")
-    os.system("mv vosk-model-small-en-us-0.15 model")
-
-
-model = Model("model")
-
-
-# -----------------------------
-# Extract audio as WAV (ffmpeg)
-# -----------------------------
 def extract_audio(video_path):
-    try:
-        audio_path = "audio.wav"
-        cmd = [
-            "ffmpeg", "-y",
-            "-i", video_path,
-            "-ac", "1", "-ar", "16000",
-            audio_path
-        ]
-
-        subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
-        return audio_path, "Audio extracted!"
-    except Exception as e:
-        return None, f"FFmpeg Error:\n{e}"
+    audio_path = "audio.wav"
+    cmd = f"ffmpeg -y -i '{video_path}' -ar 16000 -ac 1 -f wav {audio_path}"
+    subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    return audio_path
 
-
-# -----------------------------
-# Read WAV using Python's 'wave'
-# -----------------------------
-def read_wave(path):
+def generate_srt(video):
     try:
-        wf = wave.open(path, "rb")
-        frames = wf.readframes(wf.getnframes())
-        audio = np.frombuffer(frames, dtype=np.int16)
-        wf.close()
-        return audio
-    except Exception as e:
-        raise RuntimeError(f"WAV Read Error: {e}")
+        video_path = video
+        if not video_path:
+            return None, "No file uploaded"
 
+        # Extract audio
+        audio_path = extract_audio(video_path)
 
-# -----------------------------
-# Vosk Offline Speech-to-Text
-# -----------------------------
-def transcribe_audio(audio_path):
-    try:
-        audio = read_wave(audio_path)
-
-        rec = KaldiRecognizer(model, 16000)
-        rec.SetWords(True)
+        # Transcribe
+        segments, info = model.transcribe(audio_path)
 
-        for chunk in np.array_split(audio, 30):
-            rec.AcceptWaveform(chunk.tobytes())
+        subs = []
+        idx = 1
 
-        result = json.loads(rec.FinalResult())
-        text = result.get("text", "")
+        for seg in segments:
+            start = timedelta(seconds=seg.start)
+            end = timedelta(seconds=seg.end)
+            subs.append(
+                srt.Subtitle(index=idx, start=start, end=end, content=seg.text)
+            )
+            idx += 1
 
-        if not text:
-            return None, "No speech detected."
+        srt_data = srt.compose(subs)
 
-        return text, "Transcription complete!"
-    except Exception as e:
-        return None, f"STT Error:\n{e}"
+        # Save file
+        output_path = "output.srt"
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(srt_data)
 
+        return output_path, "SRT successfully generated!"
 
-# -----------------------------
-# Make SRT subtitles
-# -----------------------------
-def make_srt(text):
-    try:
-        words = text.split()
-        lines = []
-
-        chunk = ""
-        for w in words:
-            if len(chunk.split()) < 7:
-                chunk += w + " "
-            else:
-                lines.append(chunk.strip())
-                chunk = w + " "
-
-        if chunk:
-            lines.append(chunk.strip())
-
-        srt_out = ""
-        for i, caption in enumerate(lines, start=1):
-            start = timedelta(seconds=(i - 1) * 3)
-            end = timedelta(seconds=i * 3)
-
-            srt_out += f"{i}\n"
-            srt_out += f"{str(start)[:-3].replace('.', ',')} --> {str(end)[:-3].replace('.', ',')}\n"
-            srt_out += caption + "\n\n"
-
-        file = "subtitles.srt"
-        with open(file, "w", encoding="utf-8") as f:
-            f.write(srt_out)
-
-        return file, "SRT created!"
     except Exception as e:
-        return None, f"SRT Error:\n{e}"
-
-
-# -----------------------------
-# Main Pipeline
-# -----------------------------
-def process(video):
-    audio, log1 = extract_audio(video)
-    if not audio:
-        return None, log1
-
-    text, log2 = transcribe_audio(audio)
-    if not text:
-        return None, log2
-
-    srt_path, log3 = make_srt(text)
-
-    logs = f"{log1}\n{log2}\n{log3}"
-    return srt_path, logs
+        error_text = traceback.format_exc()
+        return None, f"❌ ERROR:\n{error_text}"
 
 
-# -----------------------------
-# Gradio App
-# -----------------------------
-with gr.Blocks() as app:
-    gr.Markdown("## 🎬 Offline Subtitle Generator (No Whisper · No Token · No Soundfile · 100% Free)")
+with gr.Blocks() as demo:
+    gr.Markdown("## 🎧 Auto SRT Generator (No Token, No Whisper API, Fully Local)")
 
-    video_in = gr.Video(label="Upload Video")
-    btn = gr.Button("Generate SRT")
+    video_input = gr.Video(label="Upload Video")
+    generate_btn = gr.Button("Generate SRT")
 
-    srt_out = gr.File(label="Download SRT")
-    logs = gr.Textbox(label="Debug Logs")
+    srt_output = gr.File(label="Download SRT")
+    debug_box = gr.Textbox(label="Debug Log", lines=8)
 
-    btn.click(process, inputs=video_in, outputs=[srt_out, logs])
+    generate_btn.click(generate_srt, inputs=video_input, outputs=[srt_output, debug_box])
 
-app.launch()
+demo.launch()