Update app.py

app.py

@@ -6,16 +6,19 @@ import os
 import re
 import random
 import subprocess
-import datetime
 from sklearn.feature_extraction.text import TfidfVectorizer
 from nltk.tokenize import sent_tokenize
 from nltk.corpus import stopwords
 
-# Download necessary NLTK data
+# Download NLTK data once
 nltk.download('punkt')
 nltk.download('stopwords')
+
+# Global objects (faster)
 stop_words = set(stopwords.words('english'))
+summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=-1)  # Use device=0 if GPU
 
+# 🧠 Function to download YouTube video
 def download_youtube_video(youtube_url, filename="youtube_video.mp4"):
     print(f"⬇️ Downloading YouTube video via yt-dlp: {youtube_url}")
     command = ["yt-dlp", "-f", "best[ext=mp4]+bestaudio/best", "-o", filename, youtube_url]
@@ -24,79 +27,42 @@ def download_youtube_video(youtube_url, filename="youtube_video.mp4"):
         raise Exception("YouTube download failed: " + result.stderr)
     return filename
 
+# 🎧 Audio extraction
 def extract_audio(video_path):
     clip = VideoFileClip(video_path)
     audio_path = "temp_audio.wav"
     clip.audio.write_audiofile(audio_path, codec='pcm_s16le')
     return audio_path
 
+# 📝 Audio transcription
 def transcribe_audio(audio_path):
-    model = whisper.load_model("base")
-    result = model.transcribe(audio_path, word_timestamps=True)  # includes segment timestamps
-    return result  # full result with segments
-
-def format_timestamp(seconds):
-    """Convert seconds to SRT timestamp format."""
-    td = datetime.timedelta(seconds=float(seconds))
-    return str(td)[:12].replace('.', ',')
-
-def generate_subtitles(transcription):
-    """
-    Generate subtitles in a format similar to SRT using Whisper's segment output.
-    Assumes transcription is a dict containing a 'segments' key with timestamps.
-    """
-    if not transcription or 'segments' not in transcription:
-        raise ValueError("Transcription must include 'segments'.")
-
-    subtitles = []
-    for idx, segment in enumerate(transcription['segments'], start=1):
-        start = format_timestamp(segment['start'])
-        end = format_timestamp(segment['end'])
-        text = segment['text'].strip()
-
-        subtitle = {
-            "index": idx,
-            "start": start,
-            "end": end,
-            "text": text
-        }
-        subtitles.append(subtitle)
-
-    return subtitles
+    model = whisper.load_model("tiny")  # Use "base.en" for slightly better quality
+    result = model.transcribe(audio_path)
+    return result["text"]
 
+# 📄 Summary generator with batching
 def generate_summary(text, max_len=130, min_len=30):
-    summarizer = pipeline("summarization")
     sentences = sent_tokenize(text)
     chunks = [' '.join(sentences[i:i + 10]) for i in range(0, len(sentences), 10)]
-    summary = ""
-
-    for chunk in chunks:
-        input_len = len(chunk.split())
-        dynamic_max_len = min(max_len, max(20, input_len // 2))
-        dynamic_min_len = min(min_len, dynamic_max_len - 5)
-
-        result = summarizer(
-            chunk,
-            max_length=dynamic_max_len,
-            min_length=dynamic_min_len,
-            do_sample=False
-        )[0]["summary_text"]
-
-        summary += result + " "
-
-    return summary.strip()
+    
+    results = summarizer(chunks, max_length=max_len, min_length=min_len, do_sample=False)
+    return " ".join([r["summary_text"] for r in results])
 
+# ❓ Quiz generator
 def generate_quiz(text, num_questions=5):
     sentences = sent_tokenize(text)
-    tfidf = TfidfVectorizer(stop_words='english')
+    tfidf = TfidfVectorizer(stop_words='english', max_features=300)
     X = tfidf.fit_transform(sentences)
+
     quiz = []
     used = set()
+
     for _ in range(num_questions):
         i = random.choice([x for x in range(len(sentences)) if x not in used])
         used.add(i)
         question = sentences[i]
         options = [question]
+
         while len(options) < 4:
             j = random.randint(0, len(sentences) - 1)
             if j != i and sentences[j] not in options:
@@ -107,28 +73,43 @@ def generate_quiz(text, num_questions=5):
             "options": options,
             "answer": question
         })
-    return "\n\n".join(
-        [f"Q{i+1}: {q['question']}\nOptions:\n" + "\n".join([f"{chr(65+j)}. {opt}" for j, opt in enumerate(q['options'])]) for i, q in enumerate(quiz)]
-    )
 
+    return "\n\n".join([
+        f"Q{i + 1}: {q['question']}\nOptions:\n" +
+        "\n".join([f"{chr(65 + j)}. {opt}" for j, opt in enumerate(q['options'])])
+        for i, q in enumerate(quiz)
+    ])
+
+# 📺 Subtitle formatter
+def generate_subtitles(text, max_words_per_line=10):
+    sentences = sent_tokenize(text)
+    subtitles = []
+    count = 1
+    for sentence in sentences:
+        chunks = [sentence[i:i + max_words_per_line] for i in range(0, len(sentence), max_words_per_line)]
+        for chunk in chunks:
+            subtitles.append(f"{count}. {chunk}")
+            count += 1
+    return "\n".join(subtitles)
+
+# 🧪 Master function
 def process_video(video_path, selected_services):
     results = {}
     print("🔧 Extracting audio...")
     audio_path = extract_audio(video_path)
 
-    transcription_result = transcribe_audio(audio_path) if "Transcription" in selected_services else None
-    transcription_text = transcription_result["text"] if transcription_result else None
+    transcription = transcribe_audio(audio_path) if "Transcription" in selected_services else None
 
-    if transcription_result:
-        results["transcription"] = transcription_text
+    if transcription:
+        results["transcription"] = transcription
 
         if "Summary" in selected_services:
-            results["summary"] = generate_summary(transcription_text)
+            results["summary"] = generate_summary(transcription)
 
         if "Subtitles" in selected_services:
-            results["subtitles"] = generate_subtitles(transcription_result)
+            results["subtitles"] = generate_subtitles(transcription)
 
         if "Quiz" in selected_services:
-            results["quiz"] = generate_quiz(transcription_text)
+            results["quiz"] = generate_quiz(transcription)
 
     return results