Update app.py

app.py

@@ -1,4 +1,551 @@
 
+# import os
+# os.system('conda install -c conda-forge youtube-transcript-api -y')
+# import subprocess
+# subprocess.check_call(["pip", "install", "transformers==4.34.0"])
+# subprocess.check_call(["pip", "install", "torch>=1.7.1"])
+# subprocess.check_call(["pip", "install", "youtube_transcript_api>=0.6.3"])
+# subprocess.check_call(["pip", "install", "pytube"])
+# subprocess.check_call(["pip", "install", "huggingface_hub>=0.19.0"])
+# subprocess.check_call(["pip", "install", "PyPDF2>=3.0.1"])
+# subprocess.check_call(["pip", "install", "google-generativeai"])
+# subprocess.check_call(["pip", "install", "textblob>=0.17.1"])
+# subprocess.check_call(["pip", "install", "python-dotenv>=1.0.0"])
+# subprocess.check_call(["pip", "install", "genai"])
+# subprocess.check_call(["pip", "install", "google-cloud-aiplatform==1.34.0"])
+# import transformers
+# import torch
+# import os 
+# import youtube_transcript_api
+# import pytube
+# import gradio
+# import PyPDF2
+# import pathlib
+# import pandas
+# import numpy
+# import textblob
+# import gradio as gr
+# from youtube_transcript_api import YouTubeTranscriptApi
+# import google.generativeai as genai
+# import requests
+# from textblob import TextBlob
+# import re
+# #from google.cloud import generativeai
+# from huggingface_hub import login
+# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+# def install_missing_packages():
+#     required_packages = {
+#          "torch":">=1.11.0",
+#         "transformers":">=4.34.0",
+#         "youtube_transcript_api" :">=0.6.3" ,
+#         "pytube":None,
+#         "huggingface_hub": ">=0.19.0",
+#         "PyPDF2": ">=3.0.1",
+#         "textblob":">=0.17.1",
+#         "python-dotenv":">=1.0.0",
+#         "genai":None,
+#         "google-generativeai": None,
+#         "google-cloud-aiplatform":"==1.34.0"
+#     }
+
+
+#     for package, version in required_packages.items():
+#         try:
+#             __import__(package)
+#         except ImportError:
+#             package_name = f"{package}{version}" if version else package
+#             subprocess.check_call(["pip", "install", package_name])
+
+# install_missing_packages()
+# # Configuration
+
+# hf_token = os.getenv("HF_TOKEN")
+# if hf_token:
+#     login(hf_token)
+# else:
+#     raise ValueError("HF_TOKEN environment variable not set.")
+    
+# # GOOGLE_API_KEY = "AIzaSyAURQb9jueh3dBQ4SITgKoR0L2_33en3yU"
+# # YOUTUBE_API_KEY = "AIzaSyB7X-RYjZmUuDSMTQsvCfyzURw5bhqOto4"
+# # # genai.configure(api_key=GOOGLE_API_KEY)
+# # GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+# # genai.configure(api_key=GOOGLE_API_KEY)
+# # YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
+# # print("GOOGLE_API_KEY:", os.getenv("GOOGLE_API_KEY"))
+# # print("YOUTUBE_API_KEY:", os.getenv("YOUTUBE_API_KEY"))
+
+
+
+# # Configuration
+# USER_CREDENTIALS = {
+#     "admin": "password123",
+#     "teacher": "teach2024",
+#     "student": "learn2024"
+# }
+
+# import os
+# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+
+# # Use environment variables
+# GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+# YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
+
+# if not GOOGLE_API_KEY or not YOUTUBE_API_KEY:
+#     raise ValueError("Please set GOOGLE_API_KEY and YOUTUBE_API_KEY environment variables")
+
+# genai.configure(api_key=GOOGLE_API_KEY)
+
+# # Database
+# students_data = [
+#     (1, "Alice", "A", "Computer Science"),
+#     (2, "Aliaa", "B", "Mathematics"),
+#     (3, "Charlie", "A", "Machine Learning"),
+#     (4, "Daan", "A", "Physics"),
+#     (5, "Jhon", "C", "Math"),
+#     (6, "Emma", "A+", "Computer Science")
+# ]
+
+# teachers_data = [
+#     (1, "Dr. Smith", "Math", "MS Mathematics"),
+#     (2, "Ms. Johnson", "Science", "MSc Physics"),
+#     (3, "Ms. Jack", "Artificial Intelligence Engineer", "MSc AI"),
+#     (4, "Ms. Evelyn", "Computer Science", "MSc Computer Science"),
+# ]
+
+# courses_data = [
+#     (1, "Algebra", "Dr. Smith", "Advanced"),
+#     (2, "Biology", "Ms. Mia", "Intermediate"),
+#     (3, "Machine Learning", "Ms. Jack", "Intermediate"),
+#     (4, "Computer Science", "Ms. Evelyn", "Intermediate"),
+#     (5, "Mathematics", "Ms. Smith", "Intermediate")
+# ]
+
+# def sanitize_text(text):
+#     """Remove invalid Unicode characters."""
+#     return text.encode("utf-8", "replace").decode("utf-8")
+
+# def extract_video_id(url):
+#     if not url:
+#         return None
+#     patterns = [
+#         r'(?:v=|\/videos\/|embed\/|youtu.be\/|\/v\/|\/e\/|watch\?v=|\/watch\?v=)([^#\&\?]*)'
+#     ]
+#     for pattern in patterns:
+#         match = re.search(pattern, url)
+#         if match:
+#             return match.group(1)
+#     return None
+
+# # def process_youtube_video(url="", keywords=""):
+#     try:
+#         if not url.strip():
+#             return None, "Please enter a YouTube URL", "N/A", ""
+            
+#         video_id = extract_video_id(url)
+#         if not video_id:
+#             return None, "Invalid YouTube URL", "N/A", ""
+
+#         try:
+#             # Try multiple transcript options
+#             transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+            
+#             try:
+#                 transcript = transcript_list.find_transcript(['en'])
+#             except:
+#                 try:
+#                     transcript = transcript_list.find_transcript(['en-US'])
+#                 except:
+#                     try:
+#                         # Try auto-generated
+#                         transcript = transcript_list.find_generated_transcript(['en'])
+#                     except:
+#                         raise NoTranscriptFound()
+
+#             text = " ".join([t['text'] for t in transcript.fetch()])
+            
+#             # Generate summary
+#             model = genai.GenerativeModel("gemini-pro")
+#             summary = model.generate_content(f"Summarize this: {text[:4000]}").text
+            
+#             # Analysis
+#             sentiment = TextBlob(text[:1000]).sentiment
+#             sentiment_label = f"{'Positive' if sentiment.polarity > 0 else 'Negative' if sentiment.polarity < 0 else 'Neutral'} ({sentiment.polarity:.2f})"
+            
+#             thumbnail = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
+
+#         except TranscriptsDisabled:
+#             return thumbnail, "⚠️ This video has disabled subtitles. Please try another video.", "N/A", ""
+#         except NoTranscriptFound:
+#             return thumbnail, "⚠️ No English transcript available. Please try another video.", "N/A", ""
+#         except Exception as e:
+#             return None, f"⚠️ Error: {str(e)}", "N/A", ""
+
+#         # Get recommendations
+#         if keywords.strip():
+#             recommendations = get_recommendations(keywords)
+#         else:
+#             recommendations = ""
+
+#         return thumbnail, summary, sentiment_label, recommendations
+
+#     except Exception as e:
+#         return None, f"Error: {str(e)}", "N/A", ""
+# def get_recommendations(keywords, max_results=5):
+#     if not keywords:
+#         return "Please provide search keywords"
+#     try:
+#         response = requests.get(
+#             "https://www.googleapis.com/youtube/v3/search",
+#             params={
+#                 "part": "snippet",
+#                 "q": f"educational {keywords}",
+#                 "type": "video",
+#                 "maxResults": max_results,
+#                 "relevanceLanguage": "en",
+#                 "key": YOUTUBE_API_KEY
+#             }
+#         ).json()
+        
+#         results = []
+#         for item in response.get("items", []):
+#             title = item["snippet"]["title"]
+#             channel = item["snippet"]["channelTitle"]
+#             video_id = item["id"]["videoId"]
+#             results.append(f"📺 {title}\n👤 {channel}\n🔗 https://youtube.com/watch?v={video_id}\n")
+        
+#         return "\n".join(results) if results else "No recommendations found"
+#     except Exception as e:
+#         return f"Error: {str(e)}"
+
+# # Gradio Interface
+# with gr.Blocks(theme=gr.themes.Soft()) as app:
+#     # Login Page
+#     with gr.Group() as login_page:
+#         gr.Markdown("# 🎓 Educational Learning Management System")
+#         username = gr.Textbox(label="Username")
+#         password = gr.Textbox(label="Password", type="password")
+#         login_btn = gr.Button("Login", variant="primary")
+#         login_msg = gr.Markdown()
+    
+#     # Main Interface
+#     with gr.Group(visible=False) as main_page:
+#         with gr.Row():
+#             with gr.Column(scale=1):
+#                 gr.Markdown("### 📋 Navigation")
+#                 nav_dashboard = gr.Button("📊 Dashboard", variant="primary")
+#                 nav_students = gr.Button("👥 Students")
+#                 nav_teachers = gr.Button("👨‍🏫 Teachers")
+#                 nav_courses = gr.Button("📚 Courses")
+#                 nav_youtube = gr.Button("🎥 YouTube Tool")
+#                 logout_btn = gr.Button("🚪 Logout", variant="stop")
+            
+#             with gr.Column(scale=3):
+#                 # Dashboard Content
+#                 dashboard_page = gr.Group()
+#                 with dashboard_page:
+#                     gr.Markdown("## 📊 Dashboard")
+#                     gr.Markdown(f"""
+#                     ### System Overview
+#                     - 👥 Total Students: {len(students_data)}
+#                     - 👨‍🏫 Total Teachers: {len(teachers_data)}
+#                     - 📚 Total Courses: {len(courses_data)}
+                    
+#                     ### Quick Actions
+#                     - View student performance
+#                     - Access course materials
+#                     - Generate learning insights
+#                     """)
+                
+#                 # Students Content
+#                 students_page = gr.Group(visible=False)
+#                 with students_page:
+#                     gr.Markdown("## 👥 Students")
+#                     gr.DataFrame(
+#                         value=students_data,
+#                         headers=["ID", "Name", "Grade", "Program"]
+#                     )
+                
+#                 # Teachers Content
+#                 teachers_page = gr.Group(visible=False)
+#                 with teachers_page:
+#                     gr.Markdown("## 👨‍🏫 Teachers")
+#                     gr.DataFrame(
+#                         value=teachers_data,
+#                         headers=["ID", "Name", "Subject", "Qualification"]
+#                     )
+                
+#                 # Courses Content
+#                 courses_page = gr.Group(visible=False)
+#                 with courses_page:
+#                     gr.Markdown("## 📚 Courses")
+#                     gr.DataFrame(
+#                         value=courses_data,
+#                         headers=["ID", "Name", "Instructor", "Level"]
+#                     )
+                
+#                 # YouTube Tool Content
+#                 youtube_page = gr.Group(visible=False)
+#                 with youtube_page:
+#                     gr.Markdown("## Agent for YouTube Content Exploration")
+#                     with gr.Row():
+#                         with gr.Column(scale=2):
+#                             video_url = gr.Textbox(
+#                                 label="YouTube URL",
+#                                 placeholder="https://youtube.com/watch?v=..."
+#                             )
+#                             keywords = gr.Textbox(
+#                                 label="Keywords for Recommendations",
+#                                 placeholder="e.g., python programming, machine learning"
+#                             )
+#                             analyze_btn = gr.Button("🔍 Analyze Video", variant="primary")
+                        
+#                         with gr.Column(scale=1):
+#                             video_thumbnail = gr.Image(label="Video Preview")
+                    
+#                     with gr.Row():
+#                         with gr.Column():
+#                             summary = gr.Textbox(label="📝 Summary", lines=8)
+#                             sentiment = gr.Textbox(label="😊 Content Sentiment")
+#                         with gr.Column():
+#                             recommendations = gr.Textbox(label="🎯 Related Videos", lines=10)
+
+#     def login_check(user, pwd):
+#         if USER_CREDENTIALS.get(user) == pwd:
+#             return {
+#                 login_page: gr.update(visible=False),
+#                 main_page: gr.update(visible=True),
+#                 login_msg: ""
+#             }
+#         return {
+#             login_page: gr.update(visible=True),
+#             main_page: gr.update(visible=False),
+#             login_msg: "❌ Invalid credentials"
+#         }
+    
+#     def show_page(page_name):
+#         updates = {
+#             dashboard_page: gr.update(visible=False),
+#             students_page: gr.update(visible=False),
+#             teachers_page: gr.update(visible=False),
+#             courses_page: gr.update(visible=False),
+#             youtube_page: gr.update(visible=False)
+#         }
+#         updates[page_name] = gr.update(visible=True)
+#         return updates
+    
+#     # Event Handlers
+#     login_btn.click(
+#         login_check,
+#         inputs=[username, password],
+#         outputs=[login_page, main_page, login_msg]
+#     )
+    
+#     nav_dashboard.click(lambda: show_page(dashboard_page), outputs=list(show_page(dashboard_page).keys()))
+#     nav_students.click(lambda: show_page(students_page), outputs=list(show_page(students_page).keys()))
+#     nav_teachers.click(lambda: show_page(teachers_page), outputs=list(show_page(teachers_page).keys()))
+#     nav_courses.click(lambda: show_page(courses_page), outputs=list(show_page(courses_page).keys()))
+#     nav_youtube.click(lambda: show_page(youtube_page), outputs=list(show_page(youtube_page).keys()))
+    
+#     analyze_btn.click(
+#         process_youtube_video,
+#         inputs=[video_url, keywords],
+#         outputs=[video_thumbnail, summary, sentiment, recommendations]
+#     )
+    
+#     logout_btn.click(
+#         lambda: {
+#             login_page: gr.update(visible=True),
+#             main_page: gr.update(visible=False)
+#         },
+#         outputs=[login_page, main_page]
+#     )
+
+# if __name__ == "__main__":
+#     app.launch()
+
+
+########################
+# import os
+# os.system('conda install -c conda-forge youtube-transcript-api -y')
+# import subprocess
+# subprocess.check_call(["pip", "install", "transformers==4.34.0"])
+# subprocess.check_call(["pip", "install", "torch>=1.7.1"])
+# subprocess.check_call(["pip", "install", "youtube_transcript_api>=0.6.3"])
+# subprocess.check_call(["pip", "install", "pytube>=12.1.0"])
+# subprocess.check_call(["pip", "install", "huggingface_hub>=0.19.0"])
+# subprocess.check_call(["pip", "install", "PyPDF2>=3.0.1"])
+# subprocess.check_call(["pip", "install", "google-generativeai>=0.3.0"])
+# subprocess.check_call(["pip", "install", "textblob>=0.17.1"])
+# subprocess.check_call(["pip", "install", "python-dotenv>=1.0.0"])
+# subprocess.check_call(["pip", "install", "genai"])
+# subprocess.check_call(["pip", "install", "google-cloud-aiplatform==1.34.0"])
+# subprocess.check_call(["pip", "install", "scikit-learn>=1.0.0"])
+# import transformers
+# import torch
+# import os 
+# import youtube_transcript_api
+# import pytube
+# import gradio
+# import PyPDF2
+# import pathlib
+# import pandas
+# import numpy
+# import textblob
+# import gradio as gr
+# from youtube_transcript_api import YouTubeTranscriptApi
+# import google.generativeai as genai
+# import requests
+# from textblob import TextBlob
+# import re
+# from dotenv import load_dotenv
+# from sklearn.feature_extraction.text import TfidfVectorizer
+# from sklearn.metrics.pairwise import cosine_similarity
+
+
+# #from google.cloud import generativeai
+# from huggingface_hub import login
+# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+# def install_missing_packages():
+#     required_packages = {
+#          "torch":">=1.11.0",
+#         "transformers":">=4.34.0",
+#         "youtube_transcript_api" :">=0.6.3" ,
+#         "pytube":">=12.1.0",
+#         "huggingface_hub": ">=0.19.0",
+#         "PyPDF2": ">=3.0.1",
+#         "textblob":">=0.17.1",
+#         "python-dotenv":">=1.0.0",
+#         "genai":None,
+#         "google-generativeai": ">=0.3.0",
+#         "google-cloud-aiplatform":"==1.34.0",
+#          "scikit-learn": ">=1.0.0"
+#     }
+
+
+#     for package, version in required_packages.items():
+#         try:
+#             __import__(package)
+#         except ImportError:
+#             package_name = f"{package}{version}" if version else package
+#             subprocess.check_call(["pip", "install", package_name])
+
+# install_missing_packages()
+# # # Configuration
+# # USER_CREDENTIALS = {
+# #     "admin": "password123",
+# #     "teacher": "teach2024",
+# #     "student": "learn2024"
+# # }
+
+# hf_token = os.getenv("HF_TOKEN")
+# if hf_token:
+#     login(hf_token)
+# else:
+#     raise ValueError("HF_TOKEN environment variable not set.")
+    
+# # GOOGLE_API_KEY = "AIzaSyAURQb9jueh3dBQ4SITgKoR0L2_33en3yU"
+# # YOUTUBE_API_KEY = "AIzaSyB7X-RYjZmUuDSMTQsvCfyzURw5bhqOto4"
+# # genai.configure(api_key=GOOGLE_API_KEY)
+# # # GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+# # # genai.configure(api_key=GOOGLE_API_KEY)
+# # # YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
+# # # print("GOOGLE_API_KEY:", os.getenv("GOOGLE_API_KEY"))
+# # # print("YOUTUBE_API_KEY:", os.getenv("YOUTUBE_API_KEY"))
+
+# import os
+# import gradio as gr
+# from youtube_transcript_api import YouTubeTranscriptApi
+# from dotenv import load_dotenv
+# import google.generativeai as genai
+# import requests
+
+# from transformers import pipeline
+# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+# from pytube import YouTube
+# import gradio as gr
+# from transformers import pipeline
+# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+# from pytube import YouTube
+# import gradio as gr
+
+# # Function to extract transcript from a YouTube video
+# def extract_transcript(youtube_video_url):
+#     try:
+#         video_id = youtube_video_url.split("v=")[1].split("&")[0]  # Extract video ID from URL
+
+#         # Try to fetch transcript using YouTubeTranscriptApi
+#         try:
+#             transcript = YouTubeTranscriptApi.get_transcript(video_id)
+#             result = " ".join([i['text'] for i in transcript])
+#             return result
+#         except (TranscriptsDisabled, NoTranscriptFound):
+#             pass  # Fallback to pytube if no transcript found
+
+#         # Fallback to pytube for captions
+#         yt = YouTube(youtube_video_url)
+#         if yt.captions:
+#             captions = yt.captions.get_by_language_code("en")
+#             if captions:
+#                 transcript = captions.generate_srt_captions()
+#                 return transcript.replace("\n", " ")  # Clean SRT captions format
+#             else:
+#                 return "Error: No English captions available for this video."
+#         else:
+#             return "Error: No captions available for this video."
+
+#     except Exception as e:
+#         return f"Error: Unable to process the video URL. Details: {str(e)}"
+
+# # Function to summarize the text
+# def summarize_transcript(transcript_text):
+#     try:
+#         summarizer = pipeline('summarization', model="facebook/bart-large-cnn")  # Using BART model for summarization
+#         summarized_text = []
+#         num_iters = len(transcript_text) // 1000 + 1
+
+#         for i in range(num_iters):
+#             start = i * 1000
+#             end = (i + 1) * 1000
+#             chunk = transcript_text[start:end]
+#             if chunk.strip():
+#                 out = summarizer(chunk, max_length=130, min_length=30, do_sample=False)
+#                 summarized_text.append(out[0]['summary_text'])
+        
+#         return " ".join(summarized_text)
+#     except Exception as e:
+#         return f"Error during summarization: {str(e)}"
+
+# # Gradio Interface function
+# def gradio_interface(youtube_url):
+#     transcript = extract_transcript(youtube_url)
+#     if transcript.startswith("Error"):
+#         return transcript, "Summarization cannot be performed due to transcript error."
+    
+#     summarized_text = summarize_transcript(transcript)
+#     return transcript, summarized_text
+
+# # Gradio Interface Design
+# with gr.Blocks() as demo:
+#     gr.Markdown("# YouTube Video Summarizer")
+#     with gr.Row():
+#         youtube_url_input = gr.Textbox(
+#             label="YouTube Video URL", 
+#             placeholder="Enter the YouTube video link here"
+#         )
+#     summarize_button = gr.Button("Summarize Transcript")
+#     with gr.Row():
+#         transcript_output = gr.Textbox(label="Original Transcript", lines=10, interactive=False)
+#         summary_output = gr.Textbox(label="Summarized Text", lines=10, interactive=False)
+#     summarize_button.click(
+#         fn=gradio_interface, 
+#         inputs=[youtube_url_input], 
+#         outputs=[transcript_output, summary_output]
+#     )
+
+# # Launch Gradio App
+# if __name__ == "__main__":
+#     demo.launch()
+
 import os
 os.system('conda install -c conda-forge youtube-transcript-api -y')
 import subprocess
@@ -136,7 +683,7 @@ def extract_video_id(url):
             return match.group(1)
     return None
 
-# def process_youtube_video(url="", keywords=""):
+def process_youtube_video(url="", keywords=""):
     try:
         if not url.strip():
             return None, "Please enter a YouTube URL", "N/A", ""
@@ -362,187 +909,3 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
 
 if __name__ == "__main__":
     app.launch()
-
-
-########################
-# import os
-# os.system('conda install -c conda-forge youtube-transcript-api -y')
-# import subprocess
-# subprocess.check_call(["pip", "install", "transformers==4.34.0"])
-# subprocess.check_call(["pip", "install", "torch>=1.7.1"])
-# subprocess.check_call(["pip", "install", "youtube_transcript_api>=0.6.3"])
-# subprocess.check_call(["pip", "install", "pytube>=12.1.0"])
-# subprocess.check_call(["pip", "install", "huggingface_hub>=0.19.0"])
-# subprocess.check_call(["pip", "install", "PyPDF2>=3.0.1"])
-# subprocess.check_call(["pip", "install", "google-generativeai>=0.3.0"])
-# subprocess.check_call(["pip", "install", "textblob>=0.17.1"])
-# subprocess.check_call(["pip", "install", "python-dotenv>=1.0.0"])
-# subprocess.check_call(["pip", "install", "genai"])
-# subprocess.check_call(["pip", "install", "google-cloud-aiplatform==1.34.0"])
-# subprocess.check_call(["pip", "install", "scikit-learn>=1.0.0"])
-# import transformers
-# import torch
-# import os 
-# import youtube_transcript_api
-# import pytube
-# import gradio
-# import PyPDF2
-# import pathlib
-# import pandas
-# import numpy
-# import textblob
-# import gradio as gr
-# from youtube_transcript_api import YouTubeTranscriptApi
-# import google.generativeai as genai
-# import requests
-# from textblob import TextBlob
-# import re
-# from dotenv import load_dotenv
-# from sklearn.feature_extraction.text import TfidfVectorizer
-# from sklearn.metrics.pairwise import cosine_similarity
-
-
-# #from google.cloud import generativeai
-# from huggingface_hub import login
-# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-# def install_missing_packages():
-#     required_packages = {
-#          "torch":">=1.11.0",
-#         "transformers":">=4.34.0",
-#         "youtube_transcript_api" :">=0.6.3" ,
-#         "pytube":">=12.1.0",
-#         "huggingface_hub": ">=0.19.0",
-#         "PyPDF2": ">=3.0.1",
-#         "textblob":">=0.17.1",
-#         "python-dotenv":">=1.0.0",
-#         "genai":None,
-#         "google-generativeai": ">=0.3.0",
-#         "google-cloud-aiplatform":"==1.34.0",
-#          "scikit-learn": ">=1.0.0"
-#     }
-
-
-#     for package, version in required_packages.items():
-#         try:
-#             __import__(package)
-#         except ImportError:
-#             package_name = f"{package}{version}" if version else package
-#             subprocess.check_call(["pip", "install", package_name])
-
-# install_missing_packages()
-# # # Configuration
-# # USER_CREDENTIALS = {
-# #     "admin": "password123",
-# #     "teacher": "teach2024",
-# #     "student": "learn2024"
-# # }
-
-# hf_token = os.getenv("HF_TOKEN")
-# if hf_token:
-#     login(hf_token)
-# else:
-#     raise ValueError("HF_TOKEN environment variable not set.")
-    
-# # GOOGLE_API_KEY = "AIzaSyAURQb9jueh3dBQ4SITgKoR0L2_33en3yU"
-# # YOUTUBE_API_KEY = "AIzaSyB7X-RYjZmUuDSMTQsvCfyzURw5bhqOto4"
-# # genai.configure(api_key=GOOGLE_API_KEY)
-# # # GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-# # # genai.configure(api_key=GOOGLE_API_KEY)
-# # # YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
-# # # print("GOOGLE_API_KEY:", os.getenv("GOOGLE_API_KEY"))
-# # # print("YOUTUBE_API_KEY:", os.getenv("YOUTUBE_API_KEY"))
-
-# import os
-# import gradio as gr
-# from youtube_transcript_api import YouTubeTranscriptApi
-# from dotenv import load_dotenv
-# import google.generativeai as genai
-# import requests
-
-# from transformers import pipeline
-# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-# from pytube import YouTube
-# import gradio as gr
-# from transformers import pipeline
-# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-# from pytube import YouTube
-# import gradio as gr
-
-# # Function to extract transcript from a YouTube video
-# def extract_transcript(youtube_video_url):
-#     try:
-#         video_id = youtube_video_url.split("v=")[1].split("&")[0]  # Extract video ID from URL
-
-#         # Try to fetch transcript using YouTubeTranscriptApi
-#         try:
-#             transcript = YouTubeTranscriptApi.get_transcript(video_id)
-#             result = " ".join([i['text'] for i in transcript])
-#             return result
-#         except (TranscriptsDisabled, NoTranscriptFound):
-#             pass  # Fallback to pytube if no transcript found
-
-#         # Fallback to pytube for captions
-#         yt = YouTube(youtube_video_url)
-#         if yt.captions:
-#             captions = yt.captions.get_by_language_code("en")
-#             if captions:
-#                 transcript = captions.generate_srt_captions()
-#                 return transcript.replace("\n", " ")  # Clean SRT captions format
-#             else:
-#                 return "Error: No English captions available for this video."
-#         else:
-#             return "Error: No captions available for this video."
-
-#     except Exception as e:
-#         return f"Error: Unable to process the video URL. Details: {str(e)}"
-
-# # Function to summarize the text
-# def summarize_transcript(transcript_text):
-#     try:
-#         summarizer = pipeline('summarization', model="facebook/bart-large-cnn")  # Using BART model for summarization
-#         summarized_text = []
-#         num_iters = len(transcript_text) // 1000 + 1
-
-#         for i in range(num_iters):
-#             start = i * 1000
-#             end = (i + 1) * 1000
-#             chunk = transcript_text[start:end]
-#             if chunk.strip():
-#                 out = summarizer(chunk, max_length=130, min_length=30, do_sample=False)
-#                 summarized_text.append(out[0]['summary_text'])
-        
-#         return " ".join(summarized_text)
-#     except Exception as e:
-#         return f"Error during summarization: {str(e)}"
-
-# # Gradio Interface function
-# def gradio_interface(youtube_url):
-#     transcript = extract_transcript(youtube_url)
-#     if transcript.startswith("Error"):
-#         return transcript, "Summarization cannot be performed due to transcript error."
-    
-#     summarized_text = summarize_transcript(transcript)
-#     return transcript, summarized_text
-
-# # Gradio Interface Design
-# with gr.Blocks() as demo:
-#     gr.Markdown("# YouTube Video Summarizer")
-#     with gr.Row():
-#         youtube_url_input = gr.Textbox(
-#             label="YouTube Video URL", 
-#             placeholder="Enter the YouTube video link here"
-#         )
-#     summarize_button = gr.Button("Summarize Transcript")
-#     with gr.Row():
-#         transcript_output = gr.Textbox(label="Original Transcript", lines=10, interactive=False)
-#         summary_output = gr.Textbox(label="Summarized Text", lines=10, interactive=False)
-#     summarize_button.click(
-#         fn=gradio_interface, 
-#         inputs=[youtube_url_input], 
-#         outputs=[transcript_output, summary_output]
-#     )
-
-# # Launch Gradio App
-# if __name__ == "__main__":
-#     demo.launch()
-