Update app.py

app.py

@@ -136,170 +136,44 @@ from googleapiclient.discovery import build
 
 YOUTUBE_API_KEY = "AIzaSyD_SDF4lC3vpHVAMnBOcN2ZCTz7dRjUc98"  # Replace with your actual API key
 
-# def extract_video_id(url):
-#     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):
-#     try:
-#         youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
-#         request = youtube.videos().list(part="snippet", id=video_id)
-#         response = request.execute()
-
-#         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 {}
-
-#     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):
-#     try:
-#         sentences = text.split(". ")
-#         words = text.split()
-#         common_words = Counter(words).most_common(10)
-#         key_topics = ", ".join([word for word, count in common_words])
-#         info = {
-#             "key_topics": key_topics,
-#             "sentence_count": len(sentences),
-#             "word_count": len(words),
-#         }
-#         return info
-#     except Exception as e:
-#         return {"error": str(e)}
-
-# 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)}"
-
-# def process_youtube_video(url, keywords):
-#     try:
-#         thumbnail = None
-#         summary = "No transcript available"
-#         sentiment_label = "N/A"
-#         subtitle_info = {}
-#         recommendations = ""
-
-#         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"
-
-#         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)
-#             subtitle_info = extract_subtitle_info(cleaned_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: {cleaned_text[:400]}..."
-
-#         except (TranscriptsDisabled, NoTranscriptFound):
-#             metadata = get_video_metadata(video_id)
-#             summary = metadata.get("description", "No subtitles available")
-#             sentiment_label = "N/A"
-
-#         if keywords.strip():
-#             recommendations = get_recommendations(keywords)
-
-#         return thumbnail, summary, sentiment_label, subtitle_info, recommendations
-
-#     except Exception as e:
-#         return None, f"Error: {str(e)}", "N/A", {}, ""
-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
+    match = re.search(r"(?:v=|\/)([0-9A-Za-z_-]{11})", url)
+    return match.group(1) if match else None
 
-def process_youtube_video(url="", keywords=""):
-    """Process either video URL or keywords or both"""
+def get_video_metadata(video_id):
     try:
-        thumbnail = None
-        summary = ""
-        sentiment_label = "N/A"
-        recommendations = ""
+        youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
+        request = youtube.videos().list(part="snippet", id=video_id)
+        response = request.execute()
 
-        if url.strip():
-            video_id = extract_video_id(url)
-            if video_id:
-                transcript = YouTubeTranscriptApi.get_transcript(video_id)
-                text = " ".join([t['text'] for t in transcript])
-                
-                # Sanitize text
-                text = sanitize_text(text)
-                
-                model = genai.GenerativeModel("gemini-pro")
-                summary = model.generate_content(f"Summarize this: {text}").text
-                
-                sentiment = TextBlob(text).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"
+        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 {}
 
-        if keywords.strip():
-            recommendations = get_recommendations(keywords)
+    except Exception as e:
+        return {"title": "Error fetching metadata", "description": str(e)}
 
-        return (
-            thumbnail,
-            summary or "Enter a video URL for analysis",
-            sentiment_label,
-            recommendations or "Enter keywords for recommendations"
-        )
+def clean_text_for_analysis(text):
+    return " ".join(text.split())
+
+def extract_subtitle_info(text):
+    try:
+        sentences = text.split(". ")
+        words = text.split()
+        common_words = Counter(words).most_common(10)
+        key_topics = ", ".join([word for word, count in common_words])
+        info = {
+            "key_topics": key_topics,
+            "sentence_count": len(sentences),
+            "word_count": len(words),
+        }
+        return info
     except Exception as e:
-        return None, f"Error: {str(e)}", "N/A", ""
+        return {"error": str(e)}
 
 def get_recommendations(keywords, max_results=5):
     if not keywords:
@@ -316,20 +190,214 @@ 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")
-        
+
         return "\n".join(results) if results else "No recommendations found"
     except Exception as e:
         return f"Error: {str(e)}"
 
+def process_youtube_video(url, keywords):
+    try:
+        thumbnail = None
+        summary = "No transcript available"
+        sentiment_label = "N/A"
+        subtitle_info = {}
+        recommendations = ""
+
+        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"
+
+        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)
+            subtitle_info = extract_subtitle_info(cleaned_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: {cleaned_text[:400]}..."
+
+        except (TranscriptsDisabled, NoTranscriptFound):
+            metadata = get_video_metadata(video_id)
+            summary = metadata.get("description", "No subtitles available")
+            sentiment_label = "N/A"
+
+        if keywords.strip():
+            recommendations = get_recommendations(keywords)
+
+        return thumbnail, summary, sentiment_label, subtitle_info, 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()
+    
+#     # 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()
+
 # Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft()) as app:
     # Login Page
@@ -474,5 +542,4 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
     )
 
 if __name__ == "__main__":
-    app.launch()
-
+    app.launch()