Update app.py

app.py

@@ -1,43 +1,96 @@
-import cv2
-import os
+import gradio as gr
 import torch
-from transformers import pipeline
-from moviepy.editor import VideoFileClip
-
-def extract_keyframes(video_path, interval=5):
-    cap = cv2.VideoCapture(video_path)
-    frame_rate = int(cap.get(cv2.CAP_PROP_FPS))
-    keyframes = []
-    frame_count = 0
+import yt_dlp
+import os
+import subprocess
+import json
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import moviepy.editor as mp
+import langdetect
+import uuid
+
+# Load 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()
+
+def generate_unique_filename(extension):
+    return f"{uuid.uuid4()}{extension}"
+
+def download_youtube_audio(url):
+    output_path = generate_unique_filename(".wav")
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'postprocessors': [{'key': 'FFmpegExtractAudio', 'preferredcodec': 'wav'}],
+        'outtmpl': output_path,
+        'keepvideo': False,
+    }
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([url])
+    return output_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", "")
+
+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]}"
+    response, _ = model.chat(tokenizer, prompt, history=[])
+    return response
+
+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)}", ""
+
+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)}", ""
+
+demo = gr.Blocks()
+with demo:
+    gr.Markdown("## 🎥 Video Summarization Tool")
+    with gr.Tabs():
+        with gr.TabItem("📤 Upload Video"):
+            video_input = gr.File()
+            video_button = gr.Button("Process Video")
+        with gr.TabItem("🔗 YouTube Link"):
+            url_input = gr.Textbox()
+            url_button = gr.Button("Process URL")
     
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if not ret:
-            break
-        if frame_count % (frame_rate * interval) == 0:
-            keyframes.append(frame)
-        frame_count += 1
+    transcription_output = gr.Textbox(label="Transcription", lines=10)
+    summary_output = gr.Textbox(label="Summary", lines=10)
+    summary_button = gr.Button("Generate Summary")
     
-    cap.release()
-    return keyframes
-
-def generate_captions(frames):
-    caption_generator = pipeline("image-to-text", model="Salesforce/blip-image-captioning-base")
-    captions = [caption_generator(frame)[0]['generated_text'] for frame in frames]
-    return captions
-
-def summarize_text(texts):
-    summarizer = pipeline("summarization")
-    summary = summarizer(" ".join(texts), max_length=50, min_length=10, do_sample=False)
-    return summary[0]['summary_text']
-
-def summarize_video(video_path):
-    frames = extract_keyframes(video_path)
-    captions = generate_captions(frames)
-    summary = summarize_text(captions)
-    return summary
-
-if __name__ == "__main__":
-    video_path = "input.mp4"  # Change to your video file
-    summary = summarize_video(video_path)
-    print("Video Summary:", summary)
+    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()