Update app.py

app.py

@@ -2,14 +2,6 @@
 # -*- coding: utf-8 -*-
 """
 Hugging Face Space (Gradio) App: Video -> Audio -> Whisper Transkript (+ Downloads SRT/TXT/VTT/JSON)
-
-Rechtlicher Hinweis:
-- Verwende diese App nur für eigene Inhalte oder Inhalte, für die du explizit die Erlaubnis hast.
-- Respektiere Urheberrecht und die Terms of Service der jeweiligen Plattformen.
-
-Benötigt:
-- ffmpeg (systemweit)
-- Python-Pakete siehe requirements.txt
 """
 import os
 import subprocess
@@ -20,60 +12,41 @@ from datetime import timedelta
 
 import gradio as gr
 
-# Versuch, whisper zu importieren (installiert via requirements.txt as git+repo)
 try:
     import whisper
-except Exception as e:
+except Exception:
     whisper = None
 
-# Hilfsfunktionen ----------------------------------------------------------
-
-
 def run(cmd, hide_output=False):
-    """Run shell command, raise on error."""
     if hide_output:
         subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     else:
         subprocess.run(cmd, check=True)
 
-
 def download_video_with_ytdlp(url: str, out_dir: str) -> str:
-    """Download best video using yt-dlp into out_dir, return filepath"""
     out_template = str(Path(out_dir) / "%(title)s.%(ext)s")
     cmd = ["yt-dlp", "-f", "best", "-o", out_template, url]
     run(cmd)
-    # pick most recently modified file
     files = sorted(Path(out_dir).glob("*"), key=lambda p: p.stat().st_mtime, reverse=True)
     if not files:
-        raise FileNotFoundError("Download erfolglos — keine Datei gefunden.")
+        raise FileNotFoundError("Download fehlgeschlagen — keine Datei gefunden.")
     return str(files[0])
 
-
 def extract_audio_ffmpeg(video_path: str, out_wav: str):
-    """Extract mono 16k WAV for Whisper"""
     cmd = [
-        "ffmpeg",
-        "-y",
-        "-i", video_path,
-        "-vn",
-        "-ac", "1",
-        "-ar", "16000",
-        "-f", "wav",
-        out_wav
+        "ffmpeg", "-y", "-i", video_path,
+        "-vn", "-ac", "1", "-ar", "16000", "-f", "wav", out_wav
     ]
     run(cmd, hide_output=True)
     return out_wav
 
-
-def seconds_to_timestamp(s: float, always_ms: bool = True) -> str:
-    """Convert seconds (float) to SRT/VTT time format HH:MM:SS,mmm"""
+def seconds_to_timestamp(s: float) -> str:
     hours = int(s // 3600)
     minutes = int((s % 3600) // 60)
     seconds = int(s % 60)
     ms = int(round((s - int(s)) * 1000))
     return f"{hours:02d}:{minutes:02d}:{seconds:02d},{ms:03d}"
 
-
 def format_timestamp_vtt(s: float) -> str:
     hours = int(s // 3600)
     minutes = int((s % 3600) // 60)
@@ -81,90 +54,108 @@ def format_timestamp_vtt(s: float) -> str:
     ms = int(round((s - int(s)) * 1000))
     return f"{hours:02d}:{minutes:02d}:{seconds:02d}.{ms:03d}"
 
-
 def segments_to_srt(segments):
-    """Create SRT string from whisper segments"""
-    parts = []
+    out = []
     for i, seg in enumerate(segments, start=1):
         start = seconds_to_timestamp(seg['start'])
         end = seconds_to_timestamp(seg['end'])
         text = seg['text'].strip()
-        parts.append(f"{i}\n{start} --> {end}\n{text}\n")
-    return "\n".join(parts)
-
+        out.append(f"{i}\n{start} --> {end}\n{text}\n")
+    return "\n".join(out)
 
 def segments_to_vtt(segments):
-    """Create VTT string from whisper segments"""
-    parts = ["WEBVTT\n"]
+    out = ["WEBVTT\n"]
     for seg in segments:
         start = format_timestamp_vtt(seg['start'])
         end = format_timestamp_vtt(seg['end'])
         text = seg['text'].strip()
-        parts.append(f"{start} --> {end}\n{text}\n")
-    return "\n".join(parts)
-
+        out.append(f"{start} --> {end}\n{text}\n")
+    return "\n".join(out)
 
 def segments_to_txt(segments):
-    """Create plain TXT with timestamps per segment"""
-    lines = []
-    for seg in segments:
-        start = seconds_to_timestamp(seg['start'])
-        text = seg['text'].strip()
-        lines.append(f"[{start}] {text}")
-    return "\n".join(lines)
-
+    return "\n".join([f"[{seconds_to_timestamp(seg['start'])}] {seg['text'].strip()}" for seg in segments])
 
 def segments_to_json(segments, language=None, metadata=None):
-    obj = {
-        "language": language,
-        "segments": segments
-    }
+    data = {"language": language, "segments": segments}
     if metadata:
-        obj["metadata"] = metadata
-    return json.dumps(obj, ensure_ascii=False, indent=2)
-
-# Haupt-Workflow ----------------------------------------------------------
+        data["metadata"] = metadata
+    return json.dumps(data, ensure_ascii=False, indent=2)
 
 def transcribe_pipeline(file_obj, url, model_size, keep_video=False):
-    """
-    file_obj: uploaded file (temp path) or None
-    url: optional URL to download via yt-dlp
-    model_size: whisper model size
-    """
     if whisper is None:
-        return "Fehler: lokales whisper nicht verfügbar. Stelle sicher, dass das Repo installiert ist.", None, None, None, None, None
+        return "Fehler: whisper ist nicht installiert.", None, None, None, None, None
 
     tmpdir = tempfile.mkdtemp(prefix="whisper_space_")
     try:
-        # 1) Get video path either from uploaded file or by downloading URL
         if url:
             video_path = download_video_with_ytdlp(url, tmpdir)
         elif file_obj:
-            # file_obj is a tuple (name, file-like) or a path depending on Gradio version.
-            # Gradio typically supplies a filesystem path.
             if isinstance(file_obj, str) and os.path.exists(file_obj):
                 video_path = file_obj
             else:
-                # try to write content to temp file
                 uploaded_path = Path(tmpdir) / Path(getattr(file_obj, "name", "upload")).name
                 with open(uploaded_path, "wb") as f:
-                    # file_obj may be a SpooledTemporaryFile or similar with .read()
                     f.write(file_obj.read())
                 video_path = str(uploaded_path)
         else:
-            return "Kein Video angegeben (weder Datei noch URL).", None, None, None, None, None
+            return "Kein Video angegeben.", None, None, None, None, None
 
-        # 2) Extract audio
         audio_wav = str(Path(tmpdir) / "audio.wav")
         extract_audio_ffmpeg(video_path, audio_wav)
 
-        # 3) Load whisper model and transcribe
         model = whisper.load_model(model_size)
-        # transcribe: get segments to generate SRT/VTT etc.
         result = model.transcribe(audio_wav, verbose=False)
         segments = result.get("segments", [])
-        language = result.get("language", None)
+        language = result.get("language", "unknown")
 
-        # 4) Create output strings
         srt_text = segments_to_srt(segments)
-        vtt_text = segments
+        vtt_text = segments_to_vtt(segments)
+        txt_text = segments_to_txt(segments)
+        json_text = segments_to_json(segments, language, {"model": model_size})
+
+        out_files = {}
+        base = Path(video_path).stem
+        for ext, content in {"srt": srt_text, "vtt": vtt_text, "txt": txt_text, "json": json_text}.items():
+            p = Path(tmpdir) / f"{base}.{ext}"
+            p.write_text(content, encoding="utf-8")
+            out_files[ext] = str(p)
+
+        display_text = txt_text
+
+        if not keep_video and url:
+            try:
+                os.remove(video_path)
+            except Exception:
+                pass
+
+        return display_text, out_files["srt"], out_files["vtt"], out_files["txt"], out_files["json"], f"Model: {model_size}, Sprache: {language}"
+    except Exception as e:
+        return f"Fehler: {e}", None, None, None, None, None
+    finally:
+        pass
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Video → Whisper Transkript (SRT/TXT/VTT/JSON)")
+    with gr.Row():
+        with gr.Column():
+            url_in = gr.Textbox(label="Video URL", placeholder="https://...")
+            file_in = gr.File(label="Oder Videodatei hochladen")
+            model_sel = gr.Radio(["tiny", "base", "small", "medium", "large"], value="small", label="Whisper-Modell")
+            keep_chk = gr.Checkbox(label="Video behalten", value=False)
+            btn = gr.Button("Transkribieren")
+            status = gr.Textbox(label="Status")
+        with gr.Column():
+            transcript = gr.Textbox(label="Transkript mit Zeitmarken", lines=20)
+            srt_dl = gr.File(label="SRT", visible=False)
+            vtt_dl = gr.File(label="VTT", visible=False)
+            txt_dl = gr.File(label="TXT", visible=False)
+            json_dl = gr.File(label="JSON", visible=False)
+
+    def run_transcribe(f, u, m, k):
+        display, srtf, vttf, txtf, jsonf, meta = transcribe_pipeline(f, u, m, k)
+        return display, gr.update(value=srtf, visible=bool(srtf)), gr.update(value=vttf, visible=bool(vttf)), gr.update(value=txtf, visible=bool(txtf)), gr.update(value=jsonf, visible=bool(jsonf)), meta
+
+    btn.click(run_transcribe, [file_in, url_in, model_sel, keep_chk], [transcript, srt_dl, vtt_dl, txt_dl, json_dl, status])
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))