File size: 6,993 Bytes
9823a49
 
94d337b
c277c70
 
9823a49
c277c70
 
9823a49
c277c70
 
9823a49
 
 
c277c70
9823a49
 
 
 
c277c70
b12cec2
 
 
 
 
 
c277c70
9823a49
c277c70
 
 
 
 
 
 
9823a49
 
 
c277c70
 
 
9823a49
c277c70
9823a49
c277c70
 
 
 
 
 
 
 
 
9823a49
 
 
c277c70
 
 
b12cec2
c277c70
 
 
9823a49
c277c70
 
 
b12cec2
 
 
 
 
c277c70
 
9823a49
c277c70
 
 
9823a49
c277c70
 
 
 
9823a49
c277c70
 
9823a49
 
 
 
c277c70
 
9823a49
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
c277c70
 
9823a49
c277c70
 
 
 
 
 
 
 
 
 
 
 
 
9823a49
b12cec2
c277c70
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9823a49
c277c70
4eb77f8
c277c70
 
4eb77f8
04621a9
 
 
 
9823a49
 
c277c70
9823a49
b12cec2
9823a49
c277c70
b12cec2
c277c70
 
9823a49
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
import googleapiclient.discovery
import re
import yt_dlp
import whisper
from pydub import AudioSegment
import tempfile
from transformers import pipeline
from youtube_transcript_api import YouTubeTranscriptApi
import torch
import openai
import json
from urllib.parse import urlparse, parse_qs
import os
import gradio as gr

# Ensure your API keys are set as environment variables
youtube_api_key = os.getenv("YOUTUBE_API_KEY")
openai_api_key = os.getenv("OPENAI_API_KEY")
openai.api_key = openai_api_key

if not youtube_api_key:
    raise ValueError("YOUTUBE_API_KEY is not set. Please set it as an environment variable.")

if not openai_api_key:
    raise ValueError("OPENAI_API_KEY is not set. Please set it as an environment variable.")

def extract_video_id(url):
    """Extracts the video ID from a YouTube URL."""
    try:
        parsed_url = urlparse(url)
        if "youtube.com" in parsed_url.netloc:
            query_params = parse_qs(parsed_url.query)
            return query_params.get('v', [None])[0]
        elif "youtu.be" in parsed_url.netloc:
            return parsed_url.path.strip("/")
        else:
            return None
    except Exception as e:
        return None

def get_video_duration(video_id, api_key):
    """Fetches the video duration in minutes."""
    try:
        youtube = googleapiclient.discovery.build("youtube", "v3", developerKey=api_key)
        request = youtube.videos().list(part="contentDetails", id=video_id)
        response = request.execute()
        if response["items"]:
            duration = response["items"][0]["contentDetails"]["duration"]
            match = re.match(r'PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?', duration)
            hours = int(match.group(1)) if match.group(1) else 0
            minutes = int(match.group(2)) if match.group(2) else 0
            seconds = int(match.group(3)) if match.group(3) else 0
            return hours * 60 + minutes + seconds / 60
        else:
            return None
    except Exception as e:
        return None

def download_and_transcribe_with_whisper(youtube_url):
    """Downloads audio from YouTube and transcribes it 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,
                'postprocessors': [{
                    'key': 'FFmpegExtractAudio',
                    'preferredcodec': 'mp3',
                    'preferredquality': '192',
                }],
            }

            # Download audio using yt-dlp
            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                ydl.download([youtube_url])

            # Convert to wav for Whisper
            audio = AudioSegment.from_file(temp_audio_file)
            wav_file = os.path.join(temp_dir, "audio.wav")
            audio.export(wav_file, format="wav")

            # Run Whisper transcription
            model = whisper.load_model("large")
            result = model.transcribe(wav_file)
            transcript = result['text']
            return transcript

    except Exception as e:
        return None

def get_transcript_from_youtube_api(video_id, video_length):
    """Fetches transcript using YouTube API if available."""
    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)

        return None

    except Exception as e:
        return None

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:
        return "Invalid or unsupported YouTube URL."

    video_length = get_video_duration(video_id, youtube_api_key)
    if video_length is not None:
        transcript = get_transcript_from_youtube_api(video_id, video_length)
        if transcript:
            return transcript
        return download_and_transcribe_with_whisper(youtube_url)
    else:
        return "Error fetching video duration."

def summarize_text_huggingface(text):
    """Summarizes text using a Hugging Face summarization model."""
    summarizer = pipeline("summarization", model="facebook/bart-large-cnn", device=0 if torch.cuda.is_available() else -1)
    max_input_length = 1024
    chunk_overlap = 100
    text_chunks = [
        text[i:i + max_input_length]
        for i in range(0, len(text), max_input_length - chunk_overlap)
    ]
    summaries = [
        summarizer(chunk, max_length=100, min_length=50, do_sample=False)[0]['summary_text']
        for chunk in text_chunks
    ]
    return " ".join(summaries)

def generate_optimized_content(summarized_transcript):
    """Generates optimized video metadata using OpenAI's GPT model."""
    prompt = f"""
    Analyze the following summarized YouTube video transcript and:
    1. Extract the top 10 keywords.
    2. Generate an optimized title (less than 65 characters).
    3. Create an engaging description.
    4. Generate related tags for the video.

    Summarized Transcript:
    {summarized_transcript}

    Provide the results in the following JSON format:
    {{
        "keywords": ["keyword1", "keyword2", ..., "keyword10"],
        "title": "Generated Title",
        "description": "Generated Description",
        "tags": ["tag1", "tag2", ..., "tag10"]
    }}
    """

    try:
        response = openai.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ]
        )
        return json.loads(response.choices[0].message.content)
    except Exception as e:
        return {"error": str(e)}

def process_video(youtube_url):
    """Processes a YouTube URL to generate optimized metadata."""
    transcript = get_transcript(youtube_url)
    if not transcript:
        return {"error": "Could not fetch the transcript. Please try another video."}

    summary = summarize_text_huggingface(transcript)
    optimized_content = generate_optimized_content(summary)
    return optimized_content

iface = gr.Interface(
    fn=process_video,
    inputs=gr.Textbox(label="Enter a YouTube video URL"),
    outputs=gr.JSON(label="Optimized Content"),
    title="YouTube Video Optimization Tool",
    description="Enter a YouTube URL to generate optimized titles, descriptions, and tags."
)

if __name__ == "__main__":
    iface.launch()