Update app.py

app.py

@@ -1,8 +1,8 @@
-#!/usr/bin/env python3
+#!/usr.bin/env python3
 # coding: utf-8
 
 """ Hugging Face Space (Gradio) App: Video -> Audio -> Whisper Transkript (+ Downloads SRT/TXT/VTT/JSON)
-LÖSUNG FÜR PATH-KONFLIKT IMPLEMENTIERT
+FINALE LÖSUNG: Führt yt-dlp als Python-Modul aus, um PATH-Konflikte und Systemschutz zu umgehen.
 """
 import os
 import subprocess
@@ -14,7 +14,6 @@ import socket
 import urllib.request
 from urllib.parse import urlparse
 import sys
-import shutil
 
 import gradio as gr
 
@@ -29,42 +28,17 @@ except ImportError:
     dns_resolver = None
 
 # ---------------------------------------------------------------------------
-# NEUE HELFER-FUNKTION: Finde den korrekten Pfad zur ausführbaren Datei
+# DEFINITIVE AUFRUFMETHODE: yt-dlp als Modul
 # ---------------------------------------------------------------------------
-def get_executable_path(name):
-    """Findet den vollen Pfad zu einer ausführbaren Datei, die mit pip installiert wurde."""
-    # shutil.which ist der robusteste Weg, um den Pfad zu einer ausführbaren Datei zu finden
-    path = shutil.which(name)
-    if path:
-        # Führen wir eine Versionsprüfung durch, um sicherzustellen, dass es nicht die alte Systemversion ist
-        try:
-            version_output = subprocess.check_output([path, '--version'], text=True)
-            # Neuere Versionen haben oft ein Datum im Format YYYY.MM.DD
-            if '.' in version_output and len(version_output.split('.')[0]) == 4:
-                 print(f"Found modern executable for '{name}' at: {path}")
-                 return path
-        except Exception:
-            pass # Konnte die Version nicht prüfen, fahre mit der Suche fort
-            
-    # Fallback für Umgebungen, in denen `which` nicht das Richtige findet
-    # Versuche im Verzeichnis des Python-Interpreters
-    py_executable_dir = Path(sys.executable).parent
-    candidate = py_executable_dir / name
-    if candidate.exists():
-        print(f"Found executable '{name}' next to python interpreter: {candidate}")
-        return str(candidate)
-        
-    print(f"Warning: Could not find a reliable path for '{name}'. Falling back to system PATH.")
-    return name # Fallback auf den einfachen Namen, wenn alles andere fehlschlägt
-
-# Global die Pfade einmal beim Start ermitteln
-YT_DLP_PATH = get_executable_path("yt-dlp")
-FFMPEG_PATH = get_executable_path("ffmpeg")
+# sys.executable ist der volle Pfad zum aktuell laufenden Python-Interpreter.
+# python -m yt_dlp nutzt Pythons Mechanismus, um das von pip installierte Paket zu finden.
+# Dies ist die robusteste Methode und umgeht alle PATH-Probleme.
+YT_DLP_COMMAND = [sys.executable, "-m", "yt_dlp"]
+FFMPEG_PATH = "ffmpeg" # ffmpeg ist meist unproblematisch im System-PATH
 
 # ---------------------------------------------------------------------------
 # Helper: Shell
 # ---------------------------------------------------------------------------
-
 def run_capture(cmd):
     """Run a command and return stdout; raise RuntimeError with readable stderr on failure."""
     result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
@@ -73,127 +47,96 @@ def run_capture(cmd):
         tail = stderr_text[-2000:]
         raise RuntimeError("Command failed: " + " ".join(map(str, cmd)) + " " + tail)
     return result.stdout
-    
+
 # ... (resolve_hostname_with_dns_python bleibt gleich)
 def resolve_hostname_with_dns_python(hostname):
-    if not dns_resolver:
-        print("Warning: dnspython not found. Falling back to system DNS.")
-        return socket.gethostbyname(hostname)
+    if not dns_resolver: return socket.gethostbyname(hostname)
     try:
-        resolver = dns_resolver.Resolver()
-        resolver.nameservers = ['8.8.8.8', '1.1.1.1']
+        resolver = dns_resolver.Resolver(); resolver.nameservers = ['8.8.8.8', '1.1.1.1']
         answers = resolver.resolve(hostname, 'A')
         return answers[0].to_text() if answers else None
-    except Exception as e:
-        print(f"DNS resolution with dnspython failed for {hostname}: {e}")
-        try:
-            return socket.gethostbyname(hostname)
-        except Exception as se:
-            raise se
-    return None
+    except Exception: return socket.gethostbyname(hostname)
 
 # ---------------------------------------------------------------------------
-# MODIFIZIERTE FUNKTION: Download & Audio (nutzt jetzt expliziten Pfad)
+# MODIFIZIERTE FUNKTION: Download & Audio
 # ---------------------------------------------------------------------------
-
 def download_video_with_ytdlp(url, out_dir, cookies_path=None, format_selector=None):
     out_template = str(Path(out_dir) / "%(title)s.%(ext)s")
-    # KORREKTUR: Verwende den expliziten, vollen Pfad zu yt-dlp
-    cmd = [YT_DLP_PATH, "-o", out_template]
+    # KORREKTUR: Verwende den Modul-Aufruf
+    cmd = YT_DLP_COMMAND + ["-o", out_template]
 
     try:
-        parsed_url = urlparse(url)
-        hostname = parsed_url.hostname
+        hostname = urlparse(url).hostname
         if hostname:
             ip_address = resolve_hostname_with_dns_python(hostname)
             if ip_address:
                 resolve_arg = f"{hostname}:443:{ip_address}"
                 cmd.extend(["--resolve", resolve_arg])
     except Exception as e:
-        print(f"Could not perform custom DNS resolution, proceeding without it. Error: {e}")
+        print(f"Custom DNS resolution failed, proceeding without it. Error: {e}")
 
-    if format_selector:
-        cmd += ["-f", format_selector]
-    if cookies_path:
-        cmd += ["--cookies", cookies_path]
+    if format_selector: cmd += ["-f", format_selector]
+    if cookies_path: cmd += ["--cookies", cookies_path]
     cmd.append(url)
     
     print(f"Running command: {' '.join(cmd)}")
     run_capture(cmd)
 
     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.")
+    if not files: raise FileNotFoundError("Download fehlgeschlagen — keine Datei gefunden.")
     return str(files[0])
 
-
 def extract_audio_ffmpeg(video_path, out_wav):
-    # KORREKTUR: Verwende den expliziten, vollen Pfad zu ffmpeg
     cmd = [FFMPEG_PATH, "-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 bleiben identisch)
-def seconds_to_timestamp(s): 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): 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 segments_to_srt(segments): parts = []; [parts.append(f"{i}\n{seconds_to_timestamp(s['start'])} --> {seconds_to_timestamp(s['end'])}\n{s['text'].strip()}") for i, s in enumerate(segments, 1)]; return "\n\n".join(parts) + "\n\n"
-def segments_to_vtt(segments): parts = ["WEBVTT\n"]; [parts.append(f"{format_timestamp_vtt(s['start'])} --> {format_timestamp_vtt(s['end'])}\n{s['text'].strip()}") for s in segments]; return "\n\n".join(parts)
+def seconds_to_timestamp(s): h, m, s, ms = int(s//3600), int((s%3600)//60), int(s%60), int(round((s-int(s))*1000)); return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
+def format_timestamp_vtt(s): h, m, s, ms = int(s//3600), int((s%3600)//60), int(s%60), int(round((s-int(s))*1000)); return f"{h:02d}:{m:02d}:{s:02d}.{ms:03d}"
+def segments_to_srt(segments): parts = [f"{i}\n{seconds_to_timestamp(s['start'])} --> {seconds_to_timestamp(s['end'])}\n{s['text'].strip()}" for i,s in enumerate(segments,1)]; return "\n\n".join(parts) + "\n\n"
+def segments_to_vtt(segments): parts = ["WEBVTT\n"] + [f"{format_timestamp_vtt(s['start'])} --> {format_timestamp_vtt(s['end'])}\n{s['text'].strip()}" for s in segments]; return "\n\n".join(parts)
 def segments_to_txt(segments): return "\n".join([f"[{seconds_to_timestamp(s['start'])}] {s['text'].strip()}" for s in segments])
-def segments_to_json(segments, language=None, metadata=None): data = {"language": language, "segments": segments}; [data.update({"metadata": metadata}) if metadata else None]; return json.dumps(data, ensure_ascii=False, indent=2)
+def segments_to_json(segments, lang=None, meta=None): data={"language":lang, "segments":segments}; [data.update({"metadata":meta}) if meta else None]; return json.dumps(data,ensure_ascii=False,indent=2)
 
 # ---------------------------------------------------------------------------
-# Kern-Pipeline: Transkription (bleibt logisch identisch)
+# Kern-Pipeline (bleibt identisch)
 # ---------------------------------------------------------------------------
-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
+def transcribe_pipeline(f, u, m, k, c, fmt):
+    if whisper is None: return "Fehler: whisper ist nicht installiert.",*[None]*5
     tmpdir = tempfile.mkdtemp(prefix="whisper_space_");
     try:
-        video_path = download_video_with_ytdlp(url, tmpdir, cookies_path=cookies_file, format_selector=format_selector) if url else file_obj.name
-        if not video_path: return "Kein Video angegeben.", None, None, None, None, None
-        audio_wav = str(Path(tmpdir) / "audio.wav"); extract_audio_ffmpeg(video_path, audio_wav)
-        model = whisper.load_model(model_size); result = model.transcribe(audio_wav, verbose=False)
-        segments = result.get("segments", []); language = result.get("language", "unknown")
-        txt_text = segments_to_txt(segments); srt_text = segments_to_srt(segments); vtt_text = segments_to_vtt(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: [os.remove(video_path) for _ in [1] if os.path.exists(video_path)]
-        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
+        video_path = download_video_with_ytdlp(u, tmpdir, c, fmt) if u else f.name
+        if not video_path: return "Kein Video angegeben.",*[None]*5
+        audio_wav=str(Path(tmpdir)/"audio.wav"); extract_audio_ffmpeg(video_path,audio_wav)
+        model=whisper.load_model(m); result=model.transcribe(audio_wav,verbose=False)
+        segs=result.get("segments",[]); lang=result.get("language","unknown")
+        txt=segments_to_txt(segs); srt=segments_to_srt(segs); vtt=segments_to_vtt(segs); jsn=segments_to_json(segs,lang,{"model":m})
+        base=Path(video_path).stem; files={}
+        for ext, content in {"srt":srt, "vtt":vtt, "txt":txt, "json":jsn}.items(): p=Path(tmpdir)/f"{base}.{ext}"; p.write_text(content,encoding="utf-8"); files[ext]=str(p)
+        if not k and u: [os.remove(video_path) for _ in [1] if os.path.exists(video_path)]
+        meta=f"Model: {m}, Sprache: {lang}"; return txt,files["srt"],files["vtt"],files["txt"],files["json"],meta
+    except Exception as e: return f"Fehler: {e}",*[None]*5
 
 # ---------------------------------------------------------------------------
-# MODIFIZIERTE DIAGNOSE: Zeigt uns den Beweis!
+# MODIFIZIERTE DIAGNOSE
 # ---------------------------------------------------------------------------
 def dns_internet_diag():
     lines = []
-    lines.append("=== Python & PATH Info ===")
+    lines.append("=== Python & Version Info ===")
     lines.append(f"Python Executable: {sys.executable}")
-    lines.append(f"System PATH: {os.environ.get('PATH', 'Nicht gefunden')}")
-
-    lines.append("\n\n=== Executable Location & Version (Proof) ===")
-    for name in ["yt-dlp", "ffmpeg"]:
-        try:
-            # Finde den Pfad, den unser Skript verwenden WÜRDE
-            path_in_use = get_executable_path(name)
-            lines.append(f"Path für '{name}' via get_executable_path(): {path_in_use}")
-            # Finde den Pfad, den das SYSTEM verwenden würde
-            system_path = shutil.which(name)
-            lines.append(f"Path für '{name}' via shutil.which() (System PATH): {system_path}")
-            # Prüfe die Version der Datei, die wir tatsächlich verwenden
-            out = run_capture([path_in_use, "-version" if name == "ffmpeg" else "--version"])
-            version_line = out.splitlines()[0] if out else "(keine Ausgabe)"
-            lines.append(f"VERSION VON '{path_in_use}': {version_line.strip()}")
-        except Exception as e:
-            lines.append(f"Fehler bei der Diagnose von '{name}': {e}")
-    # ... Rest der Diagnose bleibt gleich
-    lines.append("\n\n=== DNS-Auflösung (System) ===")
-    for host in ["huggingface.co", "www.google.com", "www.instagram.com", "youtube.com"]:
-        try: ip = socket.gethostbyname(host); lines.append(f"{host} -> {ip} (OK)")
+    try:
+        # Führe yt-dlp als Modul aus, um die ECHTE, von pip installierte Version zu prüfen
+        cmd = YT_DLP_COMMAND + ["--version"]
+        version_out = run_capture(cmd).strip()
+        lines.append(f"Version via '{' '.join(cmd)}': {version_out} (SOLLTE NEU SEIN)")
+    except Exception as e:
+        lines.append(f"Fehler bei der Prüfung der yt-dlp Modul-Version: {e}")
+    
+    lines.append("\n\n=== DNS-Auflösung (via dnspython mit 8.8.8.8) ===")
+    for host in ["huggingface.co", "www.instagram.com", "youtube.com"]:
+        try: ip = resolve_hostname_with_dns_python(host); lines.append(f"{host} -> {ip} (OK)")
         except Exception as e: lines.append(f"{host} -> ERROR: {e}")
-    if dns_resolver:
-        lines.append("\n\n=== DNS-Auflösung (via dnspython mit 8.8.8.8) ===")
-        for host in ["huggingface.co", "www.google.com", "www.instagram.com", "youtube.com"]:
-            try: ip = resolve_hostname_with_dns_python(host); lines.append(f"{host} -> {ip} (OK)")
-            except Exception as e: lines.append(f"{host} -> ERROR: {e}")
     return "\n".join(lines)
 
 # ---------------------------------------------------------------------------
@@ -205,10 +148,10 @@ with gr.Blocks() as demo:
         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"); vtt_dl = gr.File(label="VTT"); txt_dl = gr.File(label="TXT"); json_dl = gr.File(label="JSON")
-        def run_transcribe(f, u, m, k, c, fmt): cookies_path = c.name if 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,)
+        def run_transcribe(f, u, m, k, c, fmt): cookies_path = c.name if c else None; d, s, v, t, j, meta = transcribe_pipeline(f, u, m, k, cookies_path, (fmt or None)); return (d, gr.update(value=s,visible=bool(s)), gr.update(value=v,visible=bool(v)), gr.update(value=t,visible=bool(t)), gr.update(value=j,visible=bool(j)), 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 Tests durch, um Pfad-Konflikte und DNS-Probleme zu identifizieren."""); diag_btn = gr.Button("Diagnose starten"); diag_out = gr.Textbox(label="Diagnose-Ausgabe", lines=25)
+        gr.Markdown("""Prüft die Version von yt-dlp, wie sie von Python als Modul ausgeführt wird."""); 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__":