Update app.py

app.py

@@ -3,6 +3,17 @@
 """
 Hugging Face Space (Gradio) App: Video -> Audio -> Whisper Transkript (+ Downloads SRT/TXT/VTT/JSON)
 
+Tab 1: Transkription
+- Video per URL (yt-dlp) oder Upload
+- Audio-Extraktion via ffmpeg
+- Transkription mit Whisper (lokal)
+- Downloads: SRT, VTT, TXT, JSON
+
+Tab 2: Netzwerk / DNS Diagnose
+- Testet DNS-Auflösung für mehrere Hosts
+- Testet HTTP-Requests auf Basis-URLs
+- Zeigt Version/Verfügbarkeit von yt-dlp und ffmpeg
+
 Hinweis: Verwende diese App nur für eigene oder freigegebene Inhalte.
 """
 import os
@@ -11,6 +22,9 @@ import tempfile
 import json
 from pathlib import Path
 from datetime import timedelta
+import socket
+import urllib.request
+
 import gradio as gr
 
 try:
@@ -18,14 +32,30 @@ try:
 except Exception:
     whisper = None
 
+# ---------------------------------------------------------------------------
+# Helper: Shell
+# ---------------------------------------------------------------------------
+
 def run_capture(cmd):
+    """Run a command and return stdout, raise RuntimeError with stderr on failure."""
     result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
     if result.returncode != 0:
         err_tail = result.stderr[-1000:] if result.stderr else ""
-        raise RuntimeError(f"Command failed: {' '.join(cmd)}\n{err_tail}")
+        raise RuntimeError(f"Command failed: {' '.join(cmd)}
+{err_tail}")
     return result.stdout
 
-def download_video_with_ytdlp(url: str, out_dir: str, cookies_path=None, format_selector=None) -> str:
+
+# ---------------------------------------------------------------------------
+# Download & Audio
+# ---------------------------------------------------------------------------
+
+def download_video_with_ytdlp(url, out_dir, cookies_path=None, format_selector=None):
+    """Download a video with yt-dlp into out_dir and return the video path.
+
+    - Wenn DNS/Internet für bestimmte Hosts (z.B. Instagram) geblockt ist,
+      wird eine verständliche Fehlermeldung zurückgegeben.
+    """
     out_template = str(Path(out_dir) / "%(title)s.%(ext)s")
     cmd = ["yt-dlp", "-o", out_template]
     if format_selector:
@@ -33,23 +63,35 @@ def download_video_with_ytdlp(url: str, out_dir: str, cookies_path=None, format_
     if cookies_path:
         cmd += ["--cookies", cookies_path]
     cmd.append(url)
+
     try:
         run_capture(cmd)
     except RuntimeError as e:
         msg = str(e)
         if "Failed to resolve" in msg or "Name or service not known" in msg:
-            raise RuntimeError("Kein DNS/Internet im Space: URL-Download nicht möglich. Bitte Videodatei hochladen oder in einer Umgebung mit Internet ausführen.")
+            raise RuntimeError(
+                "DNS/Internet-Problem: Der Space kann den Host nicht auflösen. "
+                "URL-Download ist hier nicht möglich. Bitte Videodatei direkt hochladen "
+                "oder den Space in einer Umgebung mit Internet/DNS-Freigabe ausführen."
+            )
         raise
+
     files = sorted(Path(out_dir).glob("*"), key=lambda p: p.stat().st_mtime, reverse=True)
     if not files:
         raise FileNotFoundError("Download fehlgeschlagen — keine Datei gefunden.")
     return str(files[0])
 
+
 def extract_audio_ffmpeg(video_path, out_wav):
     cmd = ["ffmpeg", "-y", "-i", video_path, "-vn", "-ac", "1", "-ar", "16000", "-f", "wav", out_wav]
     subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     return out_wav
 
+
+# ---------------------------------------------------------------------------
+# Zeit- und Format-Helfer
+# ---------------------------------------------------------------------------
+
 def seconds_to_timestamp(s):
     hours = int(s // 3600)
     minutes = int((s % 3600) // 60)
@@ -57,6 +99,7 @@ def seconds_to_timestamp(s):
     ms = int(round((s - int(s)) * 1000))
     return f"{hours:02d}:{minutes:02d}:{seconds:02d},{ms:03d}"
 
+
 def format_timestamp_vtt(s):
     hours = int(s // 3600)
     minutes = int((s % 3600) // 60)
@@ -64,26 +107,39 @@ def format_timestamp_vtt(s):
     ms = int(round((s - int(s)) * 1000))
     return f"{hours:02d}:{minutes:02d}:{seconds:02d}.{ms:03d}"
 
+
 def segments_to_srt(segments):
     parts = []
     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)
+        parts.append(f"{i}
+{start} --> {end}
+{text}
+")
+    return "
+".join(parts)
+
 
 def segments_to_vtt(segments):
-    parts = ["WEBVTT\n"]
+    parts = ["WEBVTT
+"]
     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)
+        parts.append(f"{start} --> {end}
+{text}
+")
+    return "
+".join(parts)
+
 
 def segments_to_txt(segments):
-    return "\n".join([f"[{seconds_to_timestamp(seg['start'])}] {seg['text'].strip()}" for seg in segments])
+    return "
+".join([f"[{seconds_to_timestamp(seg['start'])}] {seg['text'].strip()}" for seg in segments])
+
 
 def segments_to_json(segments, language=None, metadata=None):
     data = {"language": language, "segments": segments}
@@ -91,11 +147,18 @@ def segments_to_json(segments, language=None, metadata=None):
         data["metadata"] = metadata
     return json.dumps(data, ensure_ascii=False, indent=2)
 
+
+# ---------------------------------------------------------------------------
+# Kern-Pipeline: Transkription
+# ---------------------------------------------------------------------------
+
 def transcribe_pipeline(file_obj, url, model_size, keep_video=False, cookies_file=None, format_selector=None):
     if whisper is None:
         return "Fehler: whisper ist nicht installiert.", None, None, None, None, None
+
     tmpdir = tempfile.mkdtemp(prefix="whisper_space_")
     try:
+        # Quelle bestimmen
         if url:
             cookies_path = cookies_file if cookies_file and os.path.exists(cookies_file) else None
             video_path = download_video_with_ytdlp(url, tmpdir, cookies_path=cookies_path, format_selector=format_selector)
@@ -109,56 +172,150 @@ def transcribe_pipeline(file_obj, url, model_size, keep_video=False, cookies_fil
                 video_path = str(uploaded_path)
         else:
             return "Kein Video angegeben.", None, None, None, None, None
+
+        # Audio extrahieren
         audio_wav = str(Path(tmpdir) / "audio.wav")
         extract_audio_ffmpeg(video_path, audio_wav)
+
+        # Whisper laden & transkribieren
         model = whisper.load_model(model_size)
         result = model.transcribe(audio_wav, verbose=False)
         segments = result.get("segments", [])
         language = result.get("language", "unknown")
+
+        # Ausgaben erzeugen
         srt_text = segments_to_srt(segments)
         vtt_text = segments_to_vtt(segments)
         txt_text = segments_to_txt(segments)
         json_text = segments_to_json(segments, language, {"model": model_size})
+
         base = Path(video_path).stem
         files = {}
         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")
             files[ext] = str(p)
+
         if not keep_video and url:
             try:
                 os.remove(video_path)
             except Exception:
                 pass
-        return txt_text, files["srt"], files["vtt"], files["txt"], files["json"], f"Model: {model_size}, Sprache: {language}"
+
+        meta = f"Model: {model_size}, Sprache: {language}"
+        return txt_text, files["srt"], files["vtt"], files["txt"], files["json"], meta
     except Exception as e:
         return f"Fehler: {e}", None, None, None, None, None
 
+
+# ---------------------------------------------------------------------------
+# Netzwerk / DNS Diagnose
+# ---------------------------------------------------------------------------
+
+def dns_internet_diag():
+    """Führt einige Basis-Checks aus und gibt einen Textreport zurück."""
+    lines = []
+
+    # DNS-Checks
+    lines.append("=== DNS-Auflösung ===")
+    for host in ["huggingface.co", "www.google.com", "www.instagram.com"]:
+        try:
+            ip = socket.gethostbyname(host)
+            lines.append(f"{host} -> {ip}")
+        except Exception as e:
+            lines.append(f"{host} -> ERROR: {e}")
+
+    # HTTP-Checks
+    lines.append("
+=== HTTP-Requests (GET) ===")
+    for url in ["https://huggingface.co", "https://www.google.com", "https://www.instagram.com"]:
+        try:
+            with urllib.request.urlopen(url, timeout=5) as resp:
+                code = getattr(resp, "status", None) or resp.getcode()
+                lines.append(f"{url} -> OK (Status {code})")
+        except Exception as e:
+            lines.append(f"{url} -> ERROR: {e}")
+
+    # yt-dlp
+    lines.append("
+=== yt-dlp ===")
+    try:
+        out = run_capture(["yt-dlp", "--version"])
+        lines.append(f"yt-dlp Version: {out.strip()}")
+    except Exception as e:
+        lines.append(f"yt-dlp Fehler: {e}")
+
+    # ffmpeg
+    lines.append("
+=== ffmpeg ===")
+    try:
+        out = run_capture(["ffmpeg", "-version"])
+        first = out.splitlines()[0] if out else "(keine Ausgabe)"
+        lines.append(first)
+    except Exception as e:
+        lines.append(f"ffmpeg Fehler: {e}")
+
+    return "
+".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI mit zwei Tabs
+# ---------------------------------------------------------------------------
+
 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")
-            cookies_in = gr.File(label="Cookies.txt (optional)")
-            fmt_in = gr.Textbox(label="Format (optional, yt-dlp -f)")
-            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", 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, c, fmt):
-        cookies_path = c if isinstance(c, str) and os.path.exists(c) else None
-        display, srtf, vttf, txtf, jsonf, meta = transcribe_pipeline(f, u, m, k, cookies_file=cookies_path, format_selector=fmt)
-        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, cookies_in, fmt_in], [transcript, srt_dl, vtt_dl, txt_dl, json_dl, status])
+
+    with gr.Tab("Transkription"):
+        with gr.Row():
+            with gr.Column():
+                url_in = gr.Textbox(label="Video URL", placeholder="https://...")
+                file_in = gr.File(label="Oder Videodatei hochladen")
+                cookies_in = gr.File(label="Cookies.txt (optional, für yt-dlp)")
+                fmt_in = gr.Textbox(label="Format (optional, yt-dlp -f)", placeholder="z.B. bestvideo+bestaudio/best")
+                model_sel = gr.Radio(["tiny", "base", "small", "medium", "large"], value="small", label="Whisper-Modell")
+                keep_chk = gr.Checkbox(label="Video behalten (bei URL-Download)", value=False)
+                btn = gr.Button("Transkribieren")
+                status = gr.Textbox(label="Status / Meta", interactive=False)
+            with gr.Column():
+                transcript = gr.Textbox(label="Transkript", 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, c, fmt):
+            cookies_path = c if isinstance(c, str) and os.path.exists(c) else None
+            display, srtf, vttf, txtf, jsonf, meta = transcribe_pipeline(f, u, m, k, cookies_file=cookies_path, format_selector=(fmt or None))
+            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, cookies_in, fmt_in],
+            [transcript, srt_dl, vtt_dl, txt_dl, json_dl, status],
+        )
+
+    with gr.Tab("Netzwerk / DNS Diagnose"):
+        gr.Markdown(
+            """Führt einfache Tests für DNS, HTTP sowie yt-dlp/ffmpeg aus.
+            
+- Wenn z. B. `www.instagram.com` nicht auflösbar ist, liegt ein DNS-/Firewall-Problem vor.
+            
+- Wenn Hugging Face / Google funktionieren, aber Instagram nicht, blockt vermutlich die Umgebung nur bestimmte Domains.
+            """
+        )
+        diag_btn = gr.Button("Diagnose starten")
+        diag_out = gr.Textbox(label="Diagnose-Ausgabe", lines=25)
+
+        diag_btn.click(dns_internet_diag, inputs=[], outputs=[diag_out])
+
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))