Update app.py

app.py

@@ -10,18 +10,8 @@ from youtube_transcript_api import YouTubeTranscriptApi
 import openai
 import json
 import os
-from pytube import YouTube
-from pytrends.request import TrendReq
-import torch
 from urllib.parse import urlparse, parse_qs
-
-
-YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-if not YOUTUBE_API_KEY:
-    return "YouTube API key is missing! Please set the `YOUTUBE_API_KEY` environment variable."
-if not OPENAI_API_KEY:
-    return "OpenAI API key is missing! Please set the `OPENAI_API_KEY` environment variable."
+import torch
 
 def extract_video_id(url):
     """Extracts the video ID from a YouTube URL."""
@@ -61,7 +51,6 @@ def get_video_duration(video_id, api_key):
 
 def download_and_transcribe_with_whisper(youtube_url):
     try:
-
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_audio_file = os.path.join(temp_dir, "audio.mp3")
             
@@ -80,81 +69,35 @@ def download_and_transcribe_with_whisper(youtube_url):
             audio.export(wav_file, format="wav")
 
             # Run Whisper transcription
-            model = whisper.load_model("turbo",weights_only=True)
+            model = whisper.load_model("Turbo",weights_only=True)
             result = model.transcribe(wav_file)
-            transcript = result['text']
-            return transcript
+            return result['text']
 
     except Exception as e:
         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."""
-    try:
-        # Fetch available transcripts
-        transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-
-        # Look for manually created transcripts first
-        for transcript in transcript_list:
-            if not transcript.is_generated:  # This checks for manually created transcripts
-                manual_transcript = transcript.fetch()
-                # Check if manual_transcript is iterable (should be a list)
-                if isinstance(manual_transcript, list):
-                    full_transcript = " ".join([segment['text'] for segment in manual_transcript])
-                    return full_transcript  # Return manual transcript immediately
-                else:
-                    print("Manual transcript is not iterable.")
-                    return None
-
-        # If no manual transcript found, proceed to auto-generated transcript
-        if video_length > 15:
-            # Video is longer than 15 minutes, so use auto-generated transcript
-            print("Video is longer than 15 minutes, using auto-generated transcript.")
-            auto_transcript = transcript_list.find_generated_transcript(['en'])
-            if auto_transcript:
-                # Extract the text from the auto-generated transcript
-                full_transcript = " ".join([segment['text'] for segment in auto_transcript.fetch()])
-                return full_transcript  # Return auto-generated transcript
-            else:
-                print("No auto-generated transcript available.")
-                return None
-
-        else:
-            # Video is shorter than 15 minutes, use Whisper for transcription
-            print("Video is shorter than 15 minutes, using Whisper for transcription.")
-            return None  # This will be handled by Whisper in your main function
-
-    except Exception as e:
-        print(f"Error fetching transcript: {e}")
-        return None
-
-
 def get_transcript(youtube_url, api_key):
     """Gets transcript from YouTube API or Whisper if unavailable."""
-    video_id = youtube_url.split("v=")[-1]  # Extract the video ID from URL
+    video_id = extract_video_id(youtube_url)
+    if not video_id:
+        return None
+
     video_length = get_video_duration(video_id, api_key)
 
     if video_length is not None:
         print(f"Video length: {video_length} minutes.")
-
-        # Fetch transcript using YouTube API
-        transcript = get_transcript_from_youtube_api(video_id, video_length)
-
-        # If a transcript is found from YouTube, use it
-        if transcript:
-            print("Transcript found.")
-            return transcript
-        else:
-            # No transcript found from YouTube API, proceed with Whisper
-            print("No transcript found on YouTube, using Whisper for transcription.")
-            return download_and_transcribe_with_whisper(youtube_url)  # Use Whisper for short videos
+        try:
+            transcript = YouTubeTranscriptApi.get_transcript(video_id)
+            return " ".join([segment['text'] for segment in transcript])
+        except Exception as e:
+            print(f"No transcript found via YouTube API: {e}")
+            return download_and_transcribe_with_whisper(youtube_url)
     else:
         print("Error fetching video duration.")
         return None
 
 def summarize_text_huggingface(text):
-    
     """Summarizes text using a Hugging Face summarization model."""
     device = 0 if torch.cuda.is_available() else -1
     summarizer = pipeline("summarization", model="facebook/bart-large-cnn", device=device)
@@ -194,7 +137,6 @@ def generate_optimized_content(api_key, summarized_transcript):
     """
 
     try:
-        # Use the updated OpenAI API format for chat completions
         response = openai.ChatCompletion.create(
             model="gpt-3.5-turbo",
             messages=[
@@ -202,60 +144,39 @@ def generate_optimized_content(api_key, summarized_transcript):
                 {"role": "user", "content": prompt}
             ]
         )
-        # Extract and parse the response
-        response_content = response['choices'][0]['message']['content']
-        content = json.loads(response_content)
-        return content
-
+        return json.loads(response['choices'][0]['message']['content'])
     except Exception as e:
         print(f"Error generating content: {e}")
         return None
 
-
-# Add all your functions like `extract_video_id()`, `get_transcript()`, etc.
-
-# Gradio Function for YouTube SEO
 def youtube_seo_pipeline(youtube_url):
-    print("Starting the SEO pipeline...")  # Debugging line
-    
-    if not YOUTUBE_API_KEY AND not OPENAI_API_KEY:
+    YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+    if not YOUTUBE_API_KEY or not OPENAI_API_KEY:
         return "API keys missing! Please check environment variables."
     
-    print("Extracting video ID...")
     video_id = extract_video_id(youtube_url)
     if not video_id:
         return "Invalid YouTube URL."
-    
-    print(f"Video ID: {video_id}")
 
-    print("Fetching transcript...")
     transcript = get_transcript(youtube_url, YOUTUBE_API_KEY)
-    print(transcript)
     if not transcript:
-        return "Failed to fetch transcript. Try another video."
-    
-    print("Summarizing transcript...")
+        return "Failed to fetch transcript."
+
     summarized_text = summarize_text_huggingface(transcript)
-    print(f"Summarized Text: {summarized_text[:200]}...")  # Show only the first 200 chars
-    
-    print("Generating optimized content...")
     optimized_content = generate_optimized_content(OPENAI_API_KEY, summarized_text)
     
-    if optimized_content:
-        return json.dumps(optimized_content, indent=4)
-    else:
-        return "Failed to generate SEO content."
-
+    return json.dumps(optimized_content, indent=4) if optimized_content else "Failed to generate SEO content."
 
-# Define Gradio Interface
+# Gradio Interface
 iface = gr.Interface(
     fn=youtube_seo_pipeline,
     inputs="text",
     outputs="text",
     title="YouTube SEO Optimizer",
-    description="Enter a YouTube video URL to fetch and optimize SEO content (title, description, tags, and keywords)."
+    description="Enter a YouTube video URL to fetch and optimize SEO content."
 )
 
-# Launch Gradio App
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()