Update app.py

app.py

@@ -2,95 +2,94 @@ import gradio as gr
 import torch
 import yt_dlp
 import os
-import subprocess
-import json
-from transformers import AutoTokenizer, AutoModelForCausalLM
 import moviepy.editor as mp
-import langdetect
+import whisper
 import uuid
+import langdetect
+from transformers import AutoTokenizer, AutoModelForCausalLM
 
-# Load model
+# Load LLM Model
 model_path = "Qwen/Qwen2.5-7B-Instruct"
 tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
-model = AutoModelForCausalLM.from_pretrained(
-    model_path, torch_dtype=torch.float16, trust_remote_code=True
-).cuda().eval()
+model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, trust_remote_code=True).cuda()
+model.eval()
 
+# Function to generate a unique filename
 def generate_unique_filename(extension):
     return f"{uuid.uuid4()}{extension}"
 
+# Function to download audio from a YouTube video
 def download_youtube_audio(url):
-    output_path = generate_unique_filename(".wav")
+    output_path = generate_unique_filename(".mp3")
     ydl_opts = {
         'format': 'bestaudio/best',
-        'postprocessors': [{'key': 'FFmpegExtractAudio', 'preferredcodec': 'wav'}],
+        'postprocessors': [{'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3'}],
         'outtmpl': output_path,
-        'keepvideo': False,
     }
     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
         ydl.download([url])
-    return output_path
+    return output_path if os.path.exists(output_path) else None
+
+# Function to extract audio from a video file
+def extract_audio(video_path):
+    video = mp.VideoFileClip(video_path)
+    audio_path = generate_unique_filename(".mp3")
+    video.audio.write_audiofile(audio_path)
+    return audio_path
 
-def transcribe_audio(file_path):
-    output_file = generate_unique_filename(".json")
-    command = [
-        "insanely-fast-whisper",
-        "--file-name", file_path,
-        "--device-id", "0",
-        "--model-name", "openai/whisper-large-v3",
-        "--task", "transcribe",
-        "--timestamp", "chunk",
-        "--transcript-path", output_file
-    ]
-    subprocess.run(command, check=True)
-    with open(output_file, "r") as f:
-        transcription = json.load(f)
-    os.remove(output_file)
-    return transcription.get("text", "")
+# Function to transcribe audio using Whisper
+def transcribe_audio(audio_path):
+    model = whisper.load_model("base")
+    result = model.transcribe(audio_path)
+    return result["text"]
 
-def generate_summary(transcription):
-    if not transcription.strip():
-        return "Error: No transcription available to summarize."
-    detected_language = langdetect.detect(transcription)
-    prompt = f"Summarize the following text in the detected language ({detected_language}):\n{transcription[:1000]}"
+# Function to summarize text using LLM
+def summarize_text(text):
+    detected_language = langdetect.detect(text)
+    prompt = f"Summarize the following text in 150-300 words in {detected_language}: {text[:300000]}..."
     response, _ = model.chat(tokenizer, prompt, history=[])
     return response
 
+# Gradio function to process YouTube links
 def process_youtube(url):
     if not url:
-        return "Error: Please enter a valid YouTube URL.", ""
-    try:
-        audio_file = download_youtube_audio(url)
-        transcription = transcribe_audio(audio_file)
-        os.remove(audio_file)
-        return transcription, ""
-    except Exception as e:
-        return f"Error processing YouTube: {str(e)}", ""
+        return "Please enter a YouTube URL.", ""
+    audio_path = download_youtube_audio(url)
+    if not audio_path:
+        return "Error downloading YouTube audio.", ""
+    transcription = transcribe_audio(audio_path)
+    summary = summarize_text(transcription)
+    os.remove(audio_path)
+    return transcription, summary
 
-def process_uploaded_video(video_path):
-    try:
-        transcription = transcribe_audio(video_path)
-        return transcription, ""
-    except Exception as e:
-        return f"Error processing video: {str(e)}", ""
+# Gradio function to process uploaded videos
+def process_uploaded_video(video):
+    if not video:
+        return "No video uploaded.", ""
+    audio_path = extract_audio(video)
+    transcription = transcribe_audio(audio_path)
+    summary = summarize_text(transcription)
+    os.remove(audio_path)
+    return transcription, summary
 
-demo = gr.Blocks()
-with demo:
-    gr.Markdown("## 🎥 Video Summarization Tool")
+# Gradio UI
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎥 Video Summarizer")
+    
     with gr.Tabs():
         with gr.TabItem("📤 Upload Video"):
-            video_input = gr.File()
+            video_input = gr.Video(label="Upload Video")
             video_button = gr.Button("Process Video")
+        
         with gr.TabItem("🔗 YouTube Link"):
-            url_input = gr.Textbox()
+            url_input = gr.Textbox(label="Enter YouTube URL")
             url_button = gr.Button("Process URL")
     
-    transcription_output = gr.Textbox(label="Transcription", lines=10)
-    summary_output = gr.Textbox(label="Summary", lines=10)
-    summary_button = gr.Button("Generate Summary")
+    with gr.Row():
+        transcription_output = gr.Textbox(label="📝 Transcription", lines=10)
+        summary_output = gr.Textbox(label="📊 Summary", lines=10)
     
     video_button.click(process_uploaded_video, inputs=[video_input], outputs=[transcription_output, summary_output])
     url_button.click(process_youtube, inputs=[url_input], outputs=[transcription_output, summary_output])
-    summary_button.click(generate_summary, inputs=[transcription_output], outputs=[summary_output])
 
 demo.launch()