Update app.py

app.py

@@ -1,322 +1,475 @@
-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"
-    }
+# 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"])
+# subprocess.check_call(["pip", "install", "google-api-python-client>=2.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
+# from googleapiclient.discovery import build
+# import requests
+# from textblob import TextBlob
+# import re
+# #from google.cloud import generativeai
+# from googleapiclient.discovery import build
+# 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",
+#         "google-api-python-client": ">=2.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])
+#     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
+# 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)
+# hf_token = os.getenv("HF_TOKEN")
+# if hf_token:
+#     login(hf_token)
+# else:
+#     raise ValueError("HF_TOKEN environment variable not set.")
+
+
+# YOUTUBE_API_KEY = "AIzaSyD_SDF4lC3vpHVAMnBOcN2ZCTz7dRjUc98"  # Replace with your YouTube API Key
+
+# USER_CREDENTIALS = {"admin": "password"}  # Example user credentials
+
+# import os
+# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+
+# # Use environment variables
 # 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"))
 
+# 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)
 
-# Configuration
-USER_CREDENTIALS = {
-    "admin": "password123",
-    "teacher": "teach2024",
-    "student": "learn2024"
-}
+# # 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")
+# ]
 
-import os
-from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
+# 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"),
+# ]
 
-# Use environment variables
-GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
+# 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")
+# ]
 
-if not GOOGLE_API_KEY or not YOUTUBE_API_KEY:
-    raise ValueError("Please set GOOGLE_API_KEY and YOUTUBE_API_KEY environment variables")
+# def extract_video_id(url):
+#     match = re.search(r"(?:v=|\/)([0-9A-Za-z_-]{11})", url)
+#     return match.group(1) if match else None
 
-genai.configure(api_key=GOOGLE_API_KEY)
+# def get_video_metadata(video_id):
+#     try:
+#         youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
+#         request = youtube.videos().list(part="snippet", id=video_id)
+#         response = request.execute()
 
-# 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")
-]
+#         if "items" in response and len(response["items"]) > 0:
+#             snippet = response["items"][0]["snippet"]
+#             return {
+#                 "title": snippet.get("title", "No title available"),
+#                 "description": snippet.get("description", "No description available"),
+#             }
+#         return {}
 
-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"),
-]
+#     except Exception as e:
+#         return {"title": "Error fetching metadata", "description": str(e)}
 
-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 clean_text_for_analysis(text):
+#     return " ".join(text.split())
 
-def sanitize_text(text):
-    """Remove invalid Unicode characters."""
-    return text.encode("utf-8", "replace").decode("utf-8")
+# 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()
 
-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=""):
+#         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)}"
+
+# def process_youtube_video(url):
 #     try:
-#         # Initialize variables
-#         thumbnail = None  # Default value for thumbnail
+#         thumbnail = None
 #         summary = "No transcript available"
 #         sentiment_label = "N/A"
 
-#         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", ""
+#             return None, "Invalid YouTube URL", "N/A"
 
 #         thumbnail = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
 
 #         try:
-#             # Try multiple transcript options
 #             transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-            
+#             transcript = None
 #             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()
+#                 transcript = transcript_list.find_generated_transcript(['en'])
 
 #             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})"
-
-#         except TranscriptsDisabled:
-#             # Fallback: Use video metadata if available
-#             metadata = get_video_metadata(video_id)
-#             summary = metadata.get("description", "⚠️ This video has disabled subtitles. No transcript available.")
-#         except NoTranscriptFound:
-#             # Fallback: Use video metadata if available
-#             metadata = get_video_metadata(video_id)
-#             summary = metadata.get("description", "⚠️ No English transcript available. No transcript available.")
-#         except Exception as e:
-#             return thumbnail, f"⚠️ Error: {str(e)}", "N/A", ""
-
-#         # Get recommendations
-#         if keywords.strip():
-#             recommendations = get_recommendations(keywords)
-#         else:
-#             recommendations = ""
+#             if not text.strip():
+#                 raise ValueError("Transcript is empty")
 
-#         return thumbnail, summary, sentiment_label, recommendations
-
-#     except Exception as e:
-#         return None, f"Error: {str(e)}", "N/A", ""
+#             cleaned_text = clean_text_for_analysis(text)
 
+#             sentiment = TextBlob(cleaned_text).sentiment
+#             sentiment_label = f"{'Positive' if sentiment.polarity > 0 else 'Negative' if sentiment.polarity < 0 else 'Neutral'} ({sentiment.polarity:.2f})"
 
-# def get_video_metadata(video_id):
-#     """
-#     Fetches video metadata such as title and description using the YouTube Data API.
-#     """
-#     try:
-#         from googleapiclient.discovery import build
+#             summary = f"Summary: {cleaned_text[:400]}..."
 
-#         # Replace with your YouTube Data API key
-#         API_KEY = "AIzaSyB7X-RYjZmUuDSMTQsvCfyzURw5bhqOto4"
-#         youtube = build("youtube", "v3", developerKey=API_KEY)
-#         request = youtube.videos().list(part="snippet", id=video_id)
-#         response = request.execute()
+#         except (TranscriptsDisabled, NoTranscriptFound):
+#             metadata = get_video_metadata(video_id)
+#             summary = metadata.get("description", "No subtitles available")
+#             sentiment_label = "N/A"
 
-#         if "items" in response and len(response["items"]) > 0:
-#             snippet = response["items"][0]["snippet"]
-#             return {
-#                 "title": snippet.get("title", "No title available"),
-#                 "description": snippet.get("description", "No description available"),
-#             }
-#         return {}
+#         return thumbnail, summary, sentiment_label
 
 #     except Exception as e:
-#         return {"title": "Error fetching metadata", "description": str(e)}
-
-#         # Get recommendations
-#         if keywords.strip():
-#             recommendations = get_recommendations(keywords)
-#         else:
-#             recommendations = ""
+#         return None, f"Error: {str(e)}", "N/A"
 
-#         return thumbnail, summary, sentiment_label, recommendations
-
-#     except Exception as e:
-#         return None, f"Error: {str(e)}", "N/A", ""
+# # 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()
 
-def process_youtube_video(url="", keywords=""):
-    try:
-        # Initialize variables
-        thumbnail = None
-        summary = "No transcript available"
-        sentiment_label = "N/A"
-        recommendations = ""
-        subtitle_info = "No additional information available"
+#     # 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")
 
-        if not url.strip():
-            return None, "Please enter a YouTube URL", "N/A", "", ""
+#             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
+#                     """)
 
-        video_id = extract_video_id(url)
-        if not video_id:
-            return None, "Invalid YouTube URL", "N/A", "", ""
+#                 # Students Content
+#                 students_page = gr.Group(visible=False)
+#                 with students_page:
+#                     gr.Markdown("## 👥 Students")
+#                     gr.DataFrame(
+#                         value=students_data,
+#                         headers=["ID", "Name", "Grade", "Program"]
+#                     )
 
-        thumbnail = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
+#                 # 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")
+#                             recommend_btn = gr.Button("🔎 Get Recommendations", 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],
+#         outputs=[video_thumbnail, summary, sentiment]
+#     )
+
+#     recommend_btn.click(
+#         get_recommendations,
+#         inputs=[keywords],
+#         outputs=[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 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"])
+subprocess.check_call(["pip", "install", "google-api-python-client>=2.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
+from googleapiclient.discovery import build
+import requests
+from textblob import TextBlob
+import re
+#from google.cloud import generativeai
+from googleapiclient.discovery import build
+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",
+        "google-api-python-client": ">=2.0.0"
+    }
 
+
+    for package, version in required_packages.items():
         try:
-            # Fetch transcript
-            transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-            transcript = None
-            try:
-                transcript = transcript_list.find_transcript(['en'])
-            except:
-                transcript = transcript_list.find_generated_transcript(['en'])
+            __import__(package)
+        except ImportError:
+            package_name = f"{package}{version}" if version else package
+            subprocess.check_call(["pip", "install", package_name])
 
-            text = " ".join([t['text'] for t in transcript.fetch()])
-            if not text.strip():
-                raise ValueError("Transcript is empty")
+install_missing_packages()
+# Configuration
 
-            # Generate summary
-            model = genai.GenerativeModel("gemini-pro")
-            summary = model.generate_content(f"Summarize this: {text[:4000]}").text
+hf_token = os.getenv("HF_TOKEN")
+if hf_token:
+    login(hf_token)
+else:
+    raise ValueError("HF_TOKEN environment variable not set.")
 
-            # Extract subtitle information
-            subtitle_info = extract_subtitle_info(text)
 
-            # Sentiment 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})"
+YOUTUBE_API_KEY = "AIzaSyD_SDF4lC3vpHVAMnBOcN2ZCTz7dRjUc98"  # Replace with your YouTube API Key
 
-        except TranscriptsDisabled:
-            metadata = get_video_metadata(video_id)
-            summary = metadata.get("description", "⚠️ This video has disabled subtitles.")
-            sentiment_label = "N/A"
-            subtitle_info = "No subtitles available for analysis."
-        except NoTranscriptFound:
-            metadata = get_video_metadata(video_id)
-            summary = metadata.get("description", "⚠️ No English transcript available.")
-            sentiment_label = "N/A"
-            subtitle_info = "No subtitles available for analysis."
-        except Exception as e:
-            return thumbnail, f"⚠️ Error processing transcript: {str(e)}", "N/A", "", ""
+USER_CREDENTIALS = {"admin": "password"}  # Example user credentials
 
-        # Get recommendations
-        if keywords.strip():
-            recommendations = get_recommendations(keywords)
+import os
+from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
 
-        return thumbnail, summary, sentiment_label, subtitle_info, recommendations
+# Use environment variables
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
 
-    except Exception as e:
-        return None, f"Error: {str(e)}", "N/A", "", ""
+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 extract_video_id(url):
-    """
-    Extracts the video ID from a YouTube URL.
-    """
-    import re
     match = re.search(r"(?:v=|\/)([0-9A-Za-z_-]{11})", url)
     return match.group(1) if match else None
 
-
 def get_video_metadata(video_id):
-    """
-    Fetches video metadata such as title and description using the YouTube Data API.
-    """
     try:
-        from googleapiclient.discovery import build
-
-        # Replace with your YouTube Data API key
-        YOUTUBE_API_KEY = "AIzaSyD_SDF4lC3vpHVAMnBOcN2ZCTz7dRjUc98"
         youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
         request = youtube.videos().list(part="snippet", id=video_id)
         response = request.execute()
@@ -332,35 +485,46 @@ def get_video_metadata(video_id):
     except Exception as e:
         return {"title": "Error fetching metadata", "description": str(e)}
 
+def clean_text_for_analysis(text):
+    return " ".join(text.split())
 
-def extract_subtitle_info(text):
-    """
-    Extracts meaningful information from the subtitles.
-    This could include topics, key insights, or a breakdown of the content.
-    """
+def process_youtube_video(url):
     try:
-        # Split text into sentences for better analysis
-        sentences = text.split(". ")
-        
-        # Example: Extract key topics or keywords
-        from collections import Counter
-        words = text.split()
-        common_words = Counter(words).most_common(10)
-        key_topics = ", ".join([word for word, count in common_words])
-
-        # Example: Provide a breakdown of the content
-        info = f"Key topics discussed: {key_topics}. \nNumber of sentences: {len(sentences)}. \nTotal words: {len(words)}."
-
-        return info
-    except Exception as e:
-        return f"Error extracting subtitle information: {str(e)}"
-
-
-
-
-
+        video_id = extract_video_id(url)
+        if not video_id:
+            return None, "Invalid YouTube URL", "N/A"
 
+        thumbnail = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
+        summary = "No transcript available"
+        sentiment_label = "N/A"
 
+        try:
+            transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+            transcript = None
+            try:
+                transcript = transcript_list.find_transcript(['en'])
+            except:
+                transcript = transcript_list.find_generated_transcript(['en'])
+
+            text = " ".join([t['text'] for t in transcript.fetch()])
+            if not text.strip():
+                raise ValueError("Transcript is empty")
+
+            cleaned_text = clean_text_for_analysis(text)
+
+            sentiment = TextBlob(cleaned_text).sentiment
+            sentiment_label = f"{'Positive' if sentiment.polarity > 0 else 'Negative' if sentiment.polarity < 0 else 'Neutral'} ({sentiment.polarity:.2f})"
+
+            summary = f"Summary of Content: {cleaned_text[:400]}..."
+
+        except (TranscriptsDisabled, NoTranscriptFound):
+            metadata = get_video_metadata(video_id)
+            summary = metadata.get("description", "No subtitles available")
+
+        return thumbnail, summary, sentiment_label
+
+    except Exception as e:
+        return None, f"Error: {str(e)}", "N/A"
 
 def get_recommendations(keywords, max_results=5):
     if not keywords:
@@ -377,14 +541,14 @@ def get_recommendations(keywords, max_results=5):
                 "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")
-        
+            results.append(f"\ud83d\udcfa {title}\n\ud83d\udc64 {channel}\n\ud83d\udd17 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)}"
@@ -393,68 +557,67 @@ def get_recommendations(keywords, max_results=5):
 with gr.Blocks(theme=gr.themes.Soft()) as app:
     # Login Page
     with gr.Group() as login_page:
-        gr.Markdown("# 🎓 Educational Learning Management System")
+        gr.Markdown("# \ud83c\udf93 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")
-            
+                gr.Markdown("### \ud83d\udccb Navigation")
+                nav_dashboard = gr.Button("\ud83d\udcca Dashboard", variant="primary")
+                nav_students = gr.Button("\ud83d\udc65 Students")
+                nav_teachers = gr.Button("\ud83d\udc69\u200d\ud83c\udf93 Teachers")
+                nav_courses = gr.Button("\ud83d\udcda Courses")
+                nav_youtube = gr.Button("\ud83c\udfa5 YouTube Tool")
+                logout_btn = gr.Button("\ud83d\udeaa Logout", variant="stop")
+
             with gr.Column(scale=3):
                 # Dashboard Content
                 dashboard_page = gr.Group()
                 with dashboard_page:
-                    gr.Markdown("## 📊 Dashboard")
+                    gr.Markdown("## \ud83d\udcca Dashboard")
                     gr.Markdown(f"""
                     ### System Overview
-                    - 👥 Total Students: {len(students_data)}
-                    - 👨‍🏫 Total Teachers: {len(teachers_data)}
-                    - 📚 Total Courses: {len(courses_data)}
-                    
+                    - \ud83d\udc65 Total Students: {len(students_data)}
+                    - \ud83d\udc69\u200d\ud83c\udf93 Total Teachers: {len(teachers_data)}
+                    - \ud83d\udcda 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.Markdown("## \ud83d\udc65 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.Markdown("## \ud83d\udc69\u200d\ud83c\udf93 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.Markdown("## \ud83d\udcda Courses")
                     gr.DataFrame(
                         value=courses_data,
                         headers=["ID", "Name", "Instructor", "Level"]
                     )
-                
+
                 # YouTube Tool Content
                 youtube_page = gr.Group(visible=False)
                 with youtube_page:
@@ -469,17 +632,18 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
                                 label="Keywords for Recommendations",
                                 placeholder="e.g., python programming, machine learning"
                             )
-                            analyze_btn = gr.Button("🔍 Analyze Video", variant="primary")
-                        
+                            analyze_btn = gr.Button("\ud83d\udd0d Analyze Video", variant="primary")
+                            recommend_btn = gr.Button("\ud83d\udd0e Get Recommendations", 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")
+                            summary = gr.Textbox(label="\ud83d\uddcb Summary", lines=8)
+                            sentiment = gr.Textbox(label="\ud83d\ude0a Content Sentiment")
                         with gr.Column():
-                            recommendations = gr.Textbox(label="🎯 Related Videos", lines=10)
+                            recommendations = gr.Textbox(label="\ud83c\udf1f Related Videos", lines=10)
 
     def login_check(user, pwd):
         if USER_CREDENTIALS.get(user) == pwd:
@@ -491,9 +655,9 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
         return {
             login_page: gr.update(visible=True),
             main_page: gr.update(visible=False),
-            login_msg: "❌ Invalid credentials"
+            login_msg: "\u274c Invalid credentials"
         }
-    
+
     def show_page(page_name):
         updates = {
             dashboard_page: gr.update(visible=False),
@@ -504,26 +668,32 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
         }
         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]
+        inputs=[video_url],
+        outputs=[video_thumbnail, summary, sentiment]
     )
-    
+
+    recommend_btn.click(
+        get_recommendations,
+        inputs=[keywords],
+        outputs=[recommendations]
+    )
+
     logout_btn.click(
         lambda: {
             login_page: gr.update(visible=True),
@@ -534,732 +704,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()
-###############################################
-# 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>=15.0.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.1"])
-# 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", "yt-dlp"])
-# subprocess.check_call(["pip", "install", "browser-cookie3"])
-# subprocess.check_call(["pip", "install", "ffmpeg-python"])
-# 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":">=15.0.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.1",
-#         "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.")
-    
-
-# # 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:
-#         thumbnail = None
-#         summary = ""
-#         sentiment_label = "N/A"
-#         recommendations = ""
-
-#         if not url.strip():
-#             return thumbnail, "Please enter a YouTube URL", sentiment_label, recommendations
-            
-#         video_id = extract_video_id(url)
-#         if not video_id:
-#             return thumbnail, "Invalid YouTube URL", sentiment_label, recommendations
-
-#         # Set thumbnail early
-#         thumbnail = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
-
-#         # First try getting video info using pytube
-#         try:
-#             yt = YouTube(url)
-#             video_title = yt.title
-#             video_description = yt.description
-#             initial_text = f"Title: {video_title}\n\nDescription: {video_description}"
-#         except Exception as e:
-#             initial_text = ""
-
-#         try:
-#             # Try getting transcript
-#             transcript_text = ""
-#             transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-            
-#             # Try multiple transcript options
-#             for lang in ['en', 'en-US']:
-#                 try:
-#                     transcript = transcript_list.find_transcript([lang])
-#                     transcript_text = " ".join([t['text'] for t in transcript.fetch()])
-#                     break
-#                 except:
-#                     continue
-
-#             if not transcript_text:
-#                 # Try auto-generated transcript
-#                 transcript = transcript_list.find_generated_transcript(['en'])
-#                 transcript_text = " ".join([t['text'] for t in transcript.fetch()])
-
-#             # Combine transcript with video info
-#             if transcript_text:
-#                 analysis_text = f"{initial_text}\n\nTranscript:\n{transcript_text}"
-#             else:
-#                 analysis_text = initial_text
-
-#         except (TranscriptsDisabled, NoTranscriptFound):
-#             # If no transcript available, use only video info
-#             analysis_text = initial_text
-#             if not analysis_text:
-#                 return thumbnail, "⚠️ Unable to analyze video content. No transcript or video information available.", sentiment_label, recommendations
-        
-#         # Generate summary using available text
-#         try:
-#             model = genai.GenerativeModel("gemini-pro")
-#             if len(analysis_text) > 4000:
-#                 analysis_text = analysis_text[:4000]
-            
-#             if analysis_text:
-#                 summary = model.generate_content(
-#                     f"Please provide a comprehensive summary of this video content: {analysis_text}"
-#                 ).text
-#             else:
-#                 summary = "Unable to generate summary due to lack of video content."
-
-#             # Sentiment analysis
-#             sentiment = TextBlob(analysis_text[:1000]).sentiment
-#             sentiment_label = f"{'Positive' if sentiment.polarity > 0 else 'Negative' if sentiment.polarity < 0 else 'Neutral'} ({sentiment.polarity:.2f})"
-
-#         except Exception as e:
-#             summary = f"Error generating summary: {str(e)}"
-#             sentiment_label = "Error calculating sentiment"
-
-#         # Get recommendations
-#         if keywords.strip():
-#             recommendations = get_recommendations(keywords)
-
-#         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 gradio as gr
-# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-# from transformers import pipeline
-# import torch
-# import os
-# import yt_dlp
-# from urllib.parse import urlparse, parse_qs
-# import browser_cookie3
-# from urllib.parse import urlparse, parse_qs
-
-# def extract_video_id(url):
-#     """Extract video ID from YouTube URL"""
-#     if not url:
-#         return None
-    
-#     parsed_url = urlparse(url)
-#     if parsed_url.hostname in ['www.youtube.com', 'youtube.com']:
-#         if parsed_url.path == '/watch':
-#             return parse_qs(parsed_url.query)['v'][0]
-#         elif parsed_url.path.startswith(('/embed/', '/v/')):
-#             return parsed_url.path.split('/')[2]
-#     elif parsed_url.hostname == 'youtu.be':
-#         return parsed_url.path[1:]
-#     return None
-
-# def download_audio(url, output_path):
-#     """Download audio using yt-dlp"""
-#     ydl_opts = {
-#         'format': 'bestaudio/best',
-#         'postprocessors': [{
-#             'key': 'FFmpegExtractAudio',
-#             'preferredcodec': 'mp3',
-#             'preferredquality': '192',
-#         }],
-#         'outtmpl': output_path,
-#         'quiet': True,
-#         'no_warnings': True
-#     }
-    
-#     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-#         ydl.download([url])
-#     return f"{output_path}.mp3"
-
-# def get_transcript(youtube_url, use_whisper=True):
-#     try:
-#         video_id = extract_video_id(youtube_url)
-#         if not video_id:
-#             return "Invalid YouTube URL format"
-        
-#         # First try YouTube's built-in transcripts
-#         try:
-#             transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-            
-#             for lang in ['en', 'en-US']:
-#                 try:
-#                     transcript = transcript_list.find_transcript([lang])
-#                     transcript_text = "\n".join([
-#                         f"[{entry['start']:.1f}s] {entry['text']}"
-#                         for entry in transcript.fetch()
-#                     ])
-#                     return "Using YouTube Transcript:\n\n" + transcript_text
-#                 except:
-#                     continue
-                    
-#             # Try auto-generated transcript
-#             transcript = transcript_list.find_generated_transcript(['en'])
-#             transcript_text = "\n".join([
-#                 f"[{entry['start']:.1f}s] {entry['text']}"
-#                 for entry in transcript.fetch()
-#             ])
-#             return "Using Auto-generated Transcript:\n\n" + transcript_text
-            
-#         except (TranscriptsDisabled, NoTranscriptFound):
-#             if not use_whisper:
-#                 return "No transcript available and Whisper fallback is disabled"
-            
-#             # Fallback to Whisper
-#             try:
-#                 # Create temp directory if it doesn't exist
-#                 if not os.path.exists('temp'):
-#                     os.makedirs('temp')
-                
-#                 # Download audio using yt-dlp
-#                 output_path = os.path.join('temp', video_id)
-#                 audio_file = download_audio(youtube_url, output_path)
-                
-#                 # Initialize Whisper pipeline
-#                 device = "cuda" if torch.cuda.is_available() else "cpu"
-#                 transcriber = pipeline(
-#                     "automatic-speech-recognition",
-#                     model="openai/whisper-base",
-#                     device=device
-#                 )
-                
-#                 # Transcribe audio
-#                 result = transcriber(
-#                     audio_file,
-#                     chunk_length_s=30,
-#                     return_timestamps=True
-#                 )
-                
-#                 # Clean up
-#                 os.remove(audio_file)
-                
-#                 # Format output
-#                 if isinstance(result, dict) and 'chunks' in result:
-#                     transcript_text = "\n".join([
-#                         f"[{chunk['timestamp'][0]:.1f}s] {chunk['text']}"
-#                         for chunk in result['chunks']
-#                     ])
-#                 else:
-#                     transcript_text = result['text']
-                
-#                 return "Using Whisper Transcription (No YouTube transcript available):\n\n" + transcript_text
-                
-#             except Exception as e:
-#                 return f"Error with Whisper transcription: {str(e)}"
-    
-#     except Exception as e:
-#         return f"Error: {str(e)}"
-
-# # Create Gradio interface
-# with gr.Blocks() as demo:
-#     gr.Markdown("# YouTube Video Transcription")
-#     gr.Markdown("Uses YouTube transcripts when available, falls back to Whisper model for videos without subtitles")
-    
-#     with gr.Row():
-#         youtube_url = gr.Textbox(
-#             label="YouTube URL",
-#             placeholder="https://www.youtube.com/watch?v=..."
-#         )
-#         use_whisper = gr.Checkbox(
-#             label="Enable Whisper fallback",
-#             value=True
-#         )
-    
-#     with gr.Row():
-#         transcript_output = gr.Textbox(
-#             label="Transcript",
-#             lines=15
-#         )
-    
-#     submit_btn = gr.Button("Get Transcript")
-#     submit_btn.click(
-#         fn=get_transcript,
-#         inputs=[youtube_url, use_whisper],
-#         outputs=[transcript_output]
-#     )
-
-# if __name__ == "__main__":
-#     demo.launch()
-