Create app.py

app.py

@@ -0,0 +1,171 @@
+import time
+import os
+import requests
+import subprocess
+import tempfile
+
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from webdriver_manager.chrome import ChromeDriverManager
+
+import whisper
+import openai
+import gradio as gr
+
+def get_video_url(page_url):
+    """
+    Uses Selenium in headless mode to load the page and extract the video URL from a <video> element.
+    Adjust the element-finding logic if the video is embedded differently.
+    """
+    # Set Chrome options for headless operation.
+    chrome_options = Options()
+    chrome_options.add_argument("--headless")
+    chrome_options.add_argument("--disable-gpu")
+    chrome_options.add_argument("--no-sandbox")
+
+    # Initialize Chrome driver using webdriver-manager.
+    driver = webdriver.Chrome(ChromeDriverManager().install(), options=chrome_options)
+    driver.get(page_url)
+    
+    # Wait for JavaScript to render video element.
+    time.sleep(5)
+    
+    try:
+        video_element = driver.find_element("tag name", "video")
+        video_url = video_element.get_attribute("src")
+    except Exception as e:
+        driver.quit()
+        raise Exception("Could not locate a <video> element. The page structure may differ: " + str(e))
+    
+    driver.quit()
+    return video_url
+
+def download_video(video_url, output_path):
+    """
+    Downloads the video from the extracted URL to a local file.
+    """
+    response = requests.get(video_url, stream=True)
+    if response.status_code != 200:
+        raise Exception("Failed to download video; status code: " + str(response.status_code))
+    
+    with open(output_path, "wb") as f:
+        for chunk in response.iter_content(chunk_size=8192):
+            if chunk:
+                f.write(chunk)
+    return output_path
+
+def extract_audio(video_file, audio_file):
+    """
+    Uses FFmpeg (which must be installed on your system) to extract the audio track from the video.
+    """
+    command = [
+        "ffmpeg",
+        "-i", video_file,         # Input video file
+        "-vn",                    # Disable video recording
+        "-acodec", "pcm_s16le",   # Audio codec for WAV
+        "-ar", "44100",           # Set audio sample rate
+        "-ac", "2",               # Set number of audio channels
+        audio_file
+    ]
+    try:
+        subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except subprocess.CalledProcessError as e:
+        raise Exception("FFmpeg failed to extract audio: " + str(e))
+    return audio_file
+
+def transcribe_audio(audio_file):
+    """
+    Loads the Whisper model and transcribes the provided audio file.
+    """
+    model = whisper.load_model("base")
+    result = model.transcribe(audio_file)
+    transcription = result["text"]
+    return transcription
+
+def summarize_text(transcription, openai_api_key, model_name="text-davinci-003"):
+    """
+    Uses the OpenAI API to summarize the transcription.
+    """
+    openai.api_key = openai_api_key
+    prompt = (
+        "Please summarize the following transcription of a video lecture concisely:\n\n"
+        f"{transcription}\n\nSummary:"
+    )
+    
+    response = openai.Completion.create(
+        engine=model_name,
+        prompt=prompt,
+        max_tokens=150,
+        temperature=0.5
+    )
+    summary = response.choices[0].text.strip()
+    return summary
+
+def process_page(page_url, openai_api_key):
+    """
+    Processes the given course page URL:
+      1. Scrapes the page to find the embedded video URL.
+      2. Downloads the video.
+      3. Extracts the audio using FFmpeg.
+      4. Transcribes the audio with Whisper.
+      5. Summarizes the transcription via OpenAI.
+    
+    Returns the extracted video URL, full transcription, and summary.
+    """
+    try:
+        # 1. Get the video URL from the course page.
+        video_url = get_video_url(page_url)
+        
+        # 2. Create a temporary file for the video.
+        video_temp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+        video_file = video_temp.name
+        video_temp.close()
+        
+        # Download the video.
+        download_video(video_url, video_file)
+        
+        # 3. Create a temporary file for the audio.
+        audio_temp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+        audio_file = audio_temp.name
+        audio_temp.close()
+        
+        # Extract audio from the video.
+        extract_audio(video_file, audio_file)
+        
+        # 4. Transcribe the audio.
+        transcription = transcribe_audio(audio_file)
+        
+        # 5. Summarize the transcription.
+        summary = summarize_text(transcription, openai_api_key)
+        
+        # Clean up temporary files.
+        os.remove(video_file)
+        os.remove(audio_file)
+        
+        return video_url, transcription, summary
+    except Exception as e:
+        return "Error: " + str(e), "", ""
+
+# Create a Gradio interface for the HF Spaces app.
+interface = gr.Interface(
+    fn=process_page,
+    inputs=[
+        gr.Textbox(label="Course Page URL", placeholder="Enter the deeplearning.ai course page URL here..."),
+        gr.Textbox(label="OpenAI API Key", type="password", placeholder="Enter your OpenAI API key")
+    ],
+    outputs=[
+        gr.Textbox(label="Extracted Video URL"),
+        gr.Textbox(label="Transcription"),
+        gr.Textbox(label="Summary")
+    ],
+    title="Deeplearning.ai Video Analyzer",
+    description=(
+        "Enter a deeplearning.ai course page URL and your OpenAI API key. "
+        "The app will scrape the page to find the embedded video, download it, "
+        "extract the audio, transcribe the speech using Whisper, and summarize the content using GPT."
+        "\n\nNote: Ensure FFmpeg is installed on your system."
+    )
+)
+
+if __name__ == "__main__":
+    interface.launch()