Update app.py

app.py

@@ -267,232 +267,116 @@ from googleapiclient.discovery import build
 #     # Placeholder for fetching recommendations based on keywords
 #     return f"Recommendations for: {keywords}"  # Dummy return for now
 ######################################
-# from textblob import TextBlob
-# from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-# import re
-# from collections import Counter
-# from googleapiclient.discovery import build
-# import os
-
-# # Set your YouTube API key
-# YOUTUBE_API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
-# # Alternatively, you can set it as an environment variable:
-# # YOUTUBE_API_KEY = os.getenv('YOUTUBE_API_KEY')
-
-# def process_youtube_video(url=""):
-#     """
-#     Process a YouTube video URL and return sentiment analysis of its content.
-#     """
-#     try:
-#         # Input validation
-#         if not url.strip():
-#             return {"error": "Please enter a YouTube URL"}
-
-#         # Extract video ID
-#         video_id = extract_video_id(url)
-#         if not video_id:
-#             return {"error": "Invalid YouTube URL"}
-
-#         # Get video transcript
-#         text = get_video_transcript(video_id)
-#         if isinstance(text, dict) and "error" in text:
-#             return text
-
-#         # Get video metadata
-#         metadata = get_video_metadata(video_id)
-#         if "error" in metadata:
-#             return metadata
-
-#         # Perform sentiment analysis
-#         sentiment_result = analyze_sentiment(text)
-        
-#         return {
-#             "success": True,
-#             "metadata": metadata,
-#             "sentiment": sentiment_result,
-#             "video_id": video_id
-#         }
-
-#     except Exception as e:
-#         return {"error": f"An error occurred: {str(e)}"}
-
-# def get_video_metadata(video_id):
-#     """
-#     Fetches video metadata using the YouTube Data API.
-#     """
-#     try:
-#         youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
-#         request = youtube.videos().list(
-#             part="snippet",
-#             id=video_id
-#         )
-#         response = request.execute()
-
-#         if response.get("items"):
-#             snippet = response["items"][0]["snippet"]
-#             return {
-#                 "title": snippet.get("title", ""),
-#                 "description": snippet.get("description", ""),
-#                 "publishedAt": snippet.get("publishedAt", ""),
-#                 "channelTitle": snippet.get("channelTitle", "")
-#             }
-#         return {"error": "Video not found"}
-
-#     except Exception as e:
-#         return {"error": f"Error fetching metadata: {str(e)}"}
-
-# # [Previous functions remain the same: get_video_transcript, analyze_sentiment, 
-# #  extract_video_id, clean_text_for_analysis, get_detailed_sentiment]
-
-# # Example usage with proper error handling:
-# if __name__ == "__main__":
-#     # Example with a real YouTube URL
-#     test_url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"  # Replace with any YouTube URL
-    
-#     # Check if API key is set
-#     if YOUTUBE_API_KEY == "AIzaSyD_SDF4lC3vpHVAMnBOcN2ZCTz7dRjUc98":
-#         print("Error: Please set your YouTube API key first!")
-#     else:
-#         result = process_youtube_video(test_url)
-        
-#         if "error" in result:
-#             print(f"Error: {result['error']}")
-#         else:
-#             print("\n=== Video Information ===")
-#             print(f"Title: {result['metadata']['title']}")
-#             print(f"Channel: {result['metadata']['channelTitle']}")
-            
-#             print("\n=== Sentiment Analysis Results ===")
-#             sentiment = result['sentiment']
-#             print(f"Overall Sentiment: {sentiment['overall_sentiment']}")
-#             print(f"Average Polarity: {sentiment['average_polarity']}")
-            
-#             print("\nSentiment Distribution:")
-#             dist = sentiment['sentiment_distribution']
-#             total = sum(dist.values())
-#             if total > 0:
-#                 print(f"Positive: {dist['positive']} ({(dist['positive']/total*100):.1f}%)")
-#                 print(f"Neutral: {dist['neutral']} ({(dist['neutral']/total*100):.1f}%)")
-#                 print(f"Negative: {dist['negative']} ({(dist['negative']/total*100):.1f}%)")
-            
-#             print(f"\nTotal Sentences Analyzed: {sentiment['total_sentences']}")
-#####################################################################################################
-from pytube import YouTube
-import re
 from textblob import TextBlob
 from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
-import google.generativeai as genai
+import re
+from collections import Counter
+from googleapiclient.discovery import build
+import os
 
-def process_youtube_video(url="", keywords=""):
-    try:
-        thumbnail = None
-        summary = ""
-        sentiment_label = "N/A"
-        recommendations = ""
+# Set your YouTube API key
+YOUTUBE_API_KEY = "AIzaSyB7X-RYjZmUuDSMTQsvCfyzURw5bhqOto4"  # Replace with your actual API key
+# Alternatively, you can set it as an environment variable:
+# YOUTUBE_API_KEY = os.getenv('YOUTUBE_API_KEY')
 
+def process_youtube_video(url=""):
+    """
+    Process a YouTube video URL and return sentiment analysis of its content.
+    """
+    try:
+        # Input validation
         if not url.strip():
-            return thumbnail, "Please enter a YouTube URL", sentiment_label, recommendations
+            return {"error": "Please enter a YouTube URL"}
 
+        # Extract video ID
         video_id = extract_video_id(url)
         if not video_id:
-            return thumbnail, "Invalid YouTube URL", sentiment_label, recommendations
-
-        thumbnail = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
-
-        # Initialize variables for transcript fetching
-        text = ""
-        error_messages = []
-
-        # Method 1: Using YouTube Transcript API
-        try:
-            transcript = YouTubeTranscriptApi.get_transcript(video_id)
-            text = " ".join([t['text'] for t in transcript])
-        except (TranscriptsDisabled, NoTranscriptFound) as e:
-            error_messages.append(f"Transcript API error: {str(e)}")
-        except Exception as e:
-            error_messages.append(f"Transcript API general error: {str(e)}")
-
-        # Method 2: Using PyTube if the first method fails
-        if not text:
-            try:
-                yt = YouTube(url)
-                captions = yt.captions
-                if 'en' in captions:
-                    text = captions['en'].generate_srt_captions()
-                elif 'a.en' in captions:
-                    text = captions['a.en'].generate_srt_captions()
-            except Exception as e:
-                error_messages.append(f"PyTube error: {str(e)}")
-
-        # Method 3: Using auto-generated captions via Transcript API
-        if not text:
-            try:
-                transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-                auto_transcript = transcript_list.find_generated_transcript(['en'])
-                text = " ".join([t['text'] for t in auto_transcript.fetch()])
-            except Exception as e:
-                error_messages.append(f"Auto-generated captions error: {str(e)}")
-
-        # Check if transcript was successfully fetched
-        if not text:
-            error_msg = "\n".join(error_messages)
-            return thumbnail, f"⚠️ Could not access video content. Details: {error_msg}", sentiment_label, recommendations
-
-        # Process valid transcript
-        try:
-            # Clean text for analysis
-            cleaned_text = re.sub(r'[^\w\s.]', '', text)
-            cleaned_text = ' '.join(cleaned_text.split())
-
-            # Sentiment Analysis
-            blob = TextBlob(cleaned_text[:2000])  # Analyze first 2000 characters for performance
-            polarity = blob.sentiment.polarity
-            subjectivity = blob.sentiment.subjectivity
-
-            sentiment_label = (
-                f"Sentiment: {'Positive' if polarity > 0 else 'Negative' if polarity < 0 else 'Neutral'}\n"
-                f"Confidence: {abs(polarity):.2f}\n"
-                f"Subjectivity: {subjectivity:.2f}"
-            )
-
-            # Generate summary using Gemini (Generative AI)
-            genai.configure(api_key="AIzaSyDw4LHOzdkRrU7GunTTC3_f6iS1OsAbmKA")  # Replace with your actual API key
-            model = genai.GenerativeModel("gemini-pro")
-            prompt = f"""Provide a comprehensive summary of this content in clear points:
-            {cleaned_text[:4000]}
-            Include:
-            1. Main topics
-            2. Key points
-            3. Important takeaways"""
-            
-            summary = model.generate_content(prompt).text
+            return {"error": "Invalid YouTube URL"}
 
-        except Exception as e:
-            return thumbnail, f"⚠️ Error processing content: {str(e)}", sentiment_label, recommendations
+        # Get video transcript
+        text = get_video_transcript(video_id)
+        if isinstance(text, dict) and "error" in text:
+            return text
 
-        # Get recommendations based on keywords
-        if keywords.strip():
-            recommendations = get_recommendations(keywords)
+        # Get video metadata
+        metadata = get_video_metadata(video_id)
+        if "error" in metadata:
+            return metadata
 
-        return thumbnail, summary, sentiment_label, recommendations
+        # Perform sentiment analysis
+        sentiment_result = analyze_sentiment(text)
+        
+        return {
+            "success": True,
+            "metadata": metadata,
+            "sentiment": sentiment_result,
+            "video_id": video_id
+        }
 
     except Exception as e:
-        return None, f"Error: {str(e)}", "N/A", ""
+        return {"error": f"An error occurred: {str(e)}"}
 
-def extract_video_id(url):
+def get_video_metadata(video_id):
     """
-    Extracts the video ID from a YouTube URL.
+    Fetches video metadata using the YouTube Data API.
     """
-    match = re.search(r"(?:v=|\/)([0-9A-Za-z_-]{11})", url)
-    return match.group(1) if match else None
+    try:
+        youtube = build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
+        request = youtube.videos().list(
+            part="snippet",
+            id=video_id
+        )
+        response = request.execute()
+
+        if response.get("items"):
+            snippet = response["items"][0]["snippet"]
+            return {
+                "title": snippet.get("title", ""),
+                "description": snippet.get("description", ""),
+                "publishedAt": snippet.get("publishedAt", ""),
+                "channelTitle": snippet.get("channelTitle", "")
+            }
+        return {"error": "Video not found"}
 
-def get_recommendations(keywords):
-    """
-    Fetches related video recommendations based on the provided keywords.
-    """
-    # Placeholder for fetching recommendations based on keywords
-    return f"Recommendations for: {keywords}"  # Dummy return for now
+    except Exception as e:
+        return {"error": f"Error fetching metadata: {str(e)}"}
 
+# [Previous functions remain the same: get_video_transcript, analyze_sentiment, 
+#  extract_video_id, clean_text_for_analysis, get_detailed_sentiment]
+
+# Example usage with proper error handling:
+if __name__ == "__main__":
+    # Example with a real YouTube URL
+    test_url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"  # Replace with any YouTube URL
+    
+    # Check if API key is set
+    if YOUTUBE_API_KEY == "AIzaSyD_SDF4lC3vpHVAMnBOcN2ZCTz7dRjUc98":
+        print("Error: Please set your YouTube API key first!")
+    else:
+        result = process_youtube_video(test_url)
+        
+        if "error" in result:
+            print(f"Error: {result['error']}")
+        else:
+            print("\n=== Video Information ===")
+            print(f"Title: {result['metadata']['title']}")
+            print(f"Channel: {result['metadata']['channelTitle']}")
+            
+            print("\n=== Sentiment Analysis Results ===")
+            sentiment = result['sentiment']
+            print(f"Overall Sentiment: {sentiment['overall_sentiment']}")
+            print(f"Average Polarity: {sentiment['average_polarity']}")
+            
+            print("\nSentiment Distribution:")
+            dist = sentiment['sentiment_distribution']
+            total = sum(dist.values())
+            if total > 0:
+                print(f"Positive: {dist['positive']} ({(dist['positive']/total*100):.1f}%)")
+                print(f"Neutral: {dist['neutral']} ({(dist['neutral']/total*100):.1f}%)")
+                print(f"Negative: {dist['negative']} ({(dist['negative']/total*100):.1f}%)")
+            
+            print(f"\nTotal Sentences Analyzed: {sentiment['total_sentences']}")
+#####################################################################################################
 
 def get_recommendations(keywords, max_results=5):
     if not keywords: