Update app.py

app.py

@@ -1,17 +1,17 @@
-import googleapiclient.discovery
-import re
-import yt_dlp
+import gradio as gr
+from transformers import pipeline
 import whisper
 from pydub import AudioSegment
 import tempfile
-from transformers import pipeline
-from pytrends.request import TrendReq
+import os
+import googleapiclient.discovery
 from youtube_transcript_api import YouTubeTranscriptApi
-import torch
 import openai
-import json
-from urllib.parse import urlparse, parse_qs
-import os
+
+# Load API keys from environment variables (recommended)
+YOUTUBE_API_KEY = os.environ.get("YOUTUBE_API_KEY")
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+
 
 def extract_video_id(url):
     """Extracts the video ID from a YouTube URL."""
@@ -29,10 +29,15 @@ def extract_video_id(url):
         print(f"Error parsing URL: {e}")
         return None
 
-def get_video_duration(video_id, api_key):
-    """Fetches the video duration in minutes."""
+
+def get_video_duration(video_id):
+    """Fetches the video duration in minutes (if API key provided)."""
+    if not YOUTUBE_API_KEY:
+        print("Missing YouTube API key. Skipping video duration.")
+        return None
+
     try:
-        youtube = googleapiclient.discovery.build("youtube", "v3", developerKey=api_key)
+        youtube = googleapiclient.discovery.build("youtube", "v3", developerKey=YOUTUBE_API_KEY)
         request = youtube.videos().list(part="contentDetails", id=video_id)
         response = request.execute()
         if response["items"]:
@@ -49,11 +54,12 @@ def get_video_duration(video_id, api_key):
         print(f"Error fetching video duration: {e}")
         return None
 
+
 def download_and_transcribe_with_whisper(youtube_url):
+    """Downloads and transcribes audio using Whisper."""
     try:
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_audio_file = os.path.join(temp_dir, "audio.mp3")
-            
             ydl_opts = {
                 'format': 'bestaudio/best',
                 'outtmpl': temp_audio_file,
@@ -80,47 +86,43 @@ def download_and_transcribe_with_whisper(youtube_url):
         print(f"Error during transcription: {e}")
         return None
 
-def get_transcript_from_youtube_api(video_id, video_length):
-    """Fetches transcript using YouTube API if available."""
+
+def get_transcript_from_youtube_api(video_id):
+    """Fetches transcript using YouTube API (if available)."""
+    if not YOUTUBE_API_KEY:
+        print("Missing YouTube API key. Skipping YouTube transcript.")
+        return None
+
     try:
         transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-
         for transcript in transcript_list:
             if not transcript.is_generated:
                 segments = transcript.fetch()
                 return " ".join(segment['text'] for segment in segments)
-
-        if video_length > 15:
-            auto_transcript = transcript_list.find_generated_transcript(['en'])
-            if auto_transcript:
-                segments = auto_transcript.fetch()
-                return " ".join(segment['text'] for segment in segments)
-
-        print("Manual transcript not available, and video is too short for auto-transcript.")
+        print("Manual transcript not found.")
         return None
 
     except Exception as e:
         print(f"Error fetching transcript: {e}")
         return None
 
-def get_transcript(youtube_url, api_key):
+
+def get_transcript(youtube_url):
     """Gets transcript from YouTube API or Whisper if unavailable."""
     video_id = extract_video_id(youtube_url)
     if not video_id:
         print("Invalid or unsupported YouTube URL.")
         return None
 
-    video_length = get_video_duration(video_id, api_key)
-    if video_length is not None:
-        print(f"Video length: {video_length:.2f} minutes.")
-        transcript = get_transcript_from_youtube_api(video_id, video_length)
+    video_length = get_video_duration(video_id)
+    if video_length:
+        transcript = get_transcript_from_youtube_api(video_id)
         if transcript:
             return transcript
-        print("Using Whisper for transcription.")
-        return download_and_transcribe_with_whisper(youtube_url)
-    else:
-        print("Error fetching video duration.")
-        return None
+
+    print("Using Whisper for transcription.")
+    return download_and_transcribe_with_whisper(youtube_url)
+
 
 def summarize_text_huggingface(text):
     """Summarizes text using a Hugging Face summarization model."""
@@ -137,8 +139,12 @@ def summarize_text_huggingface(text):
     ]
     return " ".join(summaries)
 
-def generate_optimized_content(api_key, summarized_transcript):
-    openai.api_key = api_key
+
+def generate_optimized_content(summarized_transcript):
+    """Generates optimized content using OpenAI (if API key provided)."""
+    if not OPENAI_API_KEY:
+        print("Missing OpenAI API key. Skipping optimized content generation.")
+        return None
 
     prompt = f"""
     Analyze the following summarized YouTube video transcript and:
@@ -178,29 +184,25 @@ def generate_optimized_content(api_key, summarized_transcript):
         return None
 
 
-def main():
-    youtube_url = input("Enter a YouTube video URL: ").strip()
-    youtube_api_key = "AIzaSyDzvaQzykj94MWl5fmY3wIBQchqXiCClUc"  # Set your YouTube API key as an environment variable
-    openai_api_key = "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"    # Set your OpenAI API key as an environment variable
-
-    if not youtube_api_key or not openai_api_key:
-        print("Missing API keys. Please set your YOUTUBE_API_KEY and OPENAI_API_KEY environment variables.")
-        return
-
-    transcript = get_transcript(youtube_url, youtube_api_key)
+def seo_tool(youtube_url):
+    """This function takes a YouTube URL as input and performs SEO optimization tasks."""
+    transcript = get_transcript(youtube_url)
     if not transcript:
-        print("Could not fetch the transcript. Please try another video.")
-        return
+        return "Could not fetch the transcript. Please try another video."
 
     summary = summarize_text_huggingface(transcript)
-    print("\nSummarized Transcript:\n", summary)
+    optimized_content = generate_optimized_content(summary)
+
+    return summary, optimized_content
+
 
-    optimized_content = generate_optimized_content(openai_api_key, summary)
-    if optimized_content:
-        print("\nOptimized Content:")
-        print(json.dumps(optimized_content, indent=4))
-    else:
-        print("Error generating optimized content.")
+interface = gr.Interface(
+    fn=seo_tool,
+    inputs="text",
+    outputs=["text", "json"],
+    title="SEO Tool for YouTube Videos",
+    description="Enter a YouTube URL to get a summary and optimized content suggestions."
+)
 
 if __name__ == "__main__":
-    main()
+    interface.launch()