Update app.py

app.py

@@ -1,103 +1,83 @@
 import os
 import subprocess
 import sys
-import requests
-import gradio as gr
-from urllib.parse import urlparse
-from moviepy.editor import VideoFileClip
-from transformers import pipeline
-import yt_dlp as youtube_dl
-
-# Ensure required packages are installed
-def install_package(package):
-    try:
-        __import__(package)
-    except ImportError:
-        print(f"Installing {package}...")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
-        __import__(package)
-
-install_package("torch")
-install_package("tensorflow")
-install_package("transformers")
-install_package("gradio")
-install_package("yt-dlp")
-install_package("moviepy")
 
-# Check if URL is a direct video file
-def is_direct_video_link(url: str) -> bool:
-    parsed = urlparse(url)
-    path = parsed.path.lower()
-    return any(path.endswith(ext) for ext in (".mp4", ".mov", ".avi", ".mkv", ".wmv", ".flv"))
+# Ensure required libraries are installed
+try:
+    import yt_dlp as youtube_dl
+except ImportError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "yt-dlp"])
+    import yt_dlp as youtube_dl
 
-# Download functions
-def download_video_direct(video_url: str, filename: str = "video"):
-    ext = os.path.splitext(urlparse(video_url).path)[1]
-    if ext == "":
-        raise ValueError("Cannot determine file extension.")
-    filename_with_ext = filename + ext
-    print(f"Downloading: {video_url}")
-    resp = requests.get(video_url, stream=True)
-    resp.raise_for_status()
-    with open(filename_with_ext, "wb") as f:
-        for chunk in resp.iter_content(chunk_size=8192):
-            f.write(chunk)
-    return filename_with_ext
+import gradio as gr
+from transformers import pipeline
 
-def download_video_via_yt_dlp(video_url: str, filename: str = "video.mp4"):
+def download_video(video_url, filename="downloaded_video.mp4"):
+    """
+    Download the video file using yt_dlp with cookies.txt for authentication.
+    """
     ydl_opts = {
-        "format": "best[ext=mp4]/best",
-        "outtmpl": filename,
-        "noplaylist": True,
-        "quiet": True
+        'format': 'best',
+        'outtmpl': filename,
+        'noplaylist': True,
+        'quiet': True,
+        'cookiefile': 'cookies.txt',
+        'user_agent': (
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+            'AppleWebKit/537.36 (KHTML, like Gecko) '
+            'Chrome/115.0.0.0 Safari/537.36'
+        ),
     }
-    print(f"Downloading (yt-dlp): {video_url}")
+
     with youtube_dl.YoutubeDL(ydl_opts) as ydl:
         ydl.download([video_url])
     return filename
 
-# Extract audio via MoviePy (Supports ALL video formats)
-def extract_audio(video_filename: str, audio_filename: str = "audio.wav") -> str:
-    try:
-        video = VideoFileClip(video_filename)
-        audio = video.audio
-        audio.write_audiofile(audio_filename)
-        return audio_filename
-    except Exception as e:
-        raise Exception(f"Audio extraction failed: {e}")
+def extract_audio(video_filename, audio_filename="extracted_audio.wav"):
+    command = [
+        'ffmpeg',
+        '-y',
+        '-i', video_filename,
+        '-vn',
+        '-acodec', 'pcm_s16le',
+        '-ar', '44100',
+        '-ac', '2',
+        audio_filename
+    ]
+    subprocess.run(command, check=True)
+    return audio_filename
 
-# Hugging Face accent classifier
-def classify_accent(audio_file: str, model_name: str = "superb/wav2vec2-base-superb-sid") -> str:
+def classify_accent(audio_file, model_name="your-hf-accent-model"):
+    if model_name == "your-hf-accent-model":
+        return "Accent: Demo Accent\nConfidence: 100.00%"
     classifier = pipeline("audio-classification", model=model_name)
     results = classifier(audio_file)
     if results:
         top = results[0]
-        return f"Accent: {top['label']} (Confidence: {top['score'] * 100:.2f}%)"
-    return "No classification result."
+        return f"Accent: {top['label']}\nConfidence: {top['score'] * 100:.2f}%"
+    else:
+        return "No classification result."
 
-# Full pipeline for Gradio
-def accent_classifier(video_url: str) -> str:
-    tmp_video, tmp_audio = None, None
+def accent_classifier(video_url):
     try:
-        tmp_video = download_video_direct(video_url) if is_direct_video_link(video_url) else download_video_via_yt_dlp(video_url)
-        tmp_audio = extract_audio(tmp_video)
-        result = classify_accent(tmp_audio)
+        video_filename = download_video(video_url)
+        audio_filename = extract_audio(video_filename)
+        result = classify_accent(audio_filename)
     except Exception as e:
-        result = f"Error: {e}"
+        result = f"Error occurred: {e}"
     finally:
-        if tmp_video and os.path.exists(tmp_video):
-            os.remove(tmp_video)
-        if tmp_audio and os.path.exists(tmp_audio):
-            os.remove(tmp_audio)
+        if os.path.exists("downloaded_video.mp4"):
+            os.remove("downloaded_video.mp4")
+        if os.path.exists("extracted_audio.wav"):
+            os.remove("extracted_audio.wav")
     return result
 
-# Gradio UI setup
 iface = gr.Interface(
     fn=accent_classifier,
-    inputs=gr.Textbox(label="Video URL", placeholder="Enter a direct video or streaming link"),
+    inputs=gr.Textbox(label="Video URL", placeholder="Enter a public YouTube, Vimeo, or Dailymotion link"),
     outputs="text",
-    title="🎤 Accent Classifier",
-    description="Paste any video URL (MP4/MOV/AVI/MKV/WMV/FLV, YouTube, Vimeo, etc.). This will download, extract audio, and classify the speaker's accent."
+    title="Accent Classifier",
+    description="Downloads a video, extracts audio, and classifies the accent using a Hugging Face model."
 )
 
 if __name__ == "__main__":