Blame for app.py

# ########## Overview ################################################################
#  The application is divided into three main components:
#  Extracts metadata, transcripts, and thumbnails from YouTube videos.
#  Summarizes the extracted transcripts using the OpenAI API.
#  Builds a Streamlit web interface that ties everything together.
#
#Step 1: Extracting YouTube Data
#	The first step involves extracting the video ID, metadata (title and channel name), 
# 	transcript, and thumbnail image from a YouTube URL. 
#
#Step 2: Summarizing the Transcript
#	With the transcript in hand, the next step is to summarize it. This is done using 
# 	the OpenAI API in summarize_text.py. Before running this script, make sure to set 
# 	your OpenAI API key as an environment variable:
#
#Step 3: Building the Web Interface
#	Finally, the web interface is created using Streamlit. Streamlit is a Python library 
# 	that simplifies the process of creating web applications for data science and machine 
#   learning projects. This file combines the functionality of the other two scripts and 
# 	provides a user-friendly interface.
#Bringing It All Together
#	Extract Video ID and Metadata: When a user inputs a YouTube URL, the app extracts the 
# 	video ID and retrieves the title and channel name using extract_metadata(url).
#	Download Thumbnail: The app downloads the video’s thumbnail and displays it using 
# 	get_thumbnail_from_url(url).
#	Get and Summarize Transcript: The transcript is fetched using get_transcript_from_url(url) 
# 	and summarized using summarize_transcript(transcript, language). The summary is displayed 
# 	in the selected language.
#################################################################################################
# TO RUN, execute on the terminal:
#streamlit run C:\projects\ewp\ai-projects\ewp-sales-bots-repo\ewp-sales-bots-program\notebooks\summarize_mp4_video.py
#

import os
import subprocess
from moviepy.video.io.VideoFileClip import VideoFileClip
from moviepy.audio.io.AudioFileClip import AudioFileClip
import whisper
from openai import OpenAI
from fastapi import FastAPI
from transformers import pipeline

#import os
#os.system("apt-get update && apt-get install -y ffmpeg")

#result = subprocess.run(["ffmpeg", "-version"], capture_output=True, text=True)
#print(result.stdout)

#input_file = "input.mp4"
#output_file = "output.mp3"
#subprocess.run(["ffmpeg", "-i", input_file, output_file])

## create a new FASTAPI app instance
app=FastAPI()

# Initialize the text generation pipeline
#pipe = pipeline("text2text-generation", model="google/flan-t5-small")


@app.get("/")
def home():
    return {"message":"Hello World"}

# Define a function to handle the GET request at `/generate`


@app.get("/generate")
def generate(text:str):
    ## use the pipeline to generate text from given input text
    output=pipe(text)

    ## return the generate text in Json reposne
    return {"output":output[0]['generated_text']}

@app.get("/transcribe")
def get_transcript_mp4(self,mp4_path):
    #path_to_check = r"C:\Program Files\ffmpeg\bin"
    #if path_to_check in os.environ["PATH"]:
        #print(f"{path_to_check} is in the PATH")
    #else:
        #print(f"{path_to_check} is NOT in the PATH")
        #os.environ["PATH"] += os.pathsep + path_to_check
    ffmpeg_version = subprocess.run(["ffmpeg", "-version"], capture_output=True, text=True)
    print(ffmpeg_version.stdout)
    # Assuming the mp4 file has a transcript available
    # This is a placeholder function. You would need to implement actual transcript extraction from mp4.
    # For now, we will return a dummy transcript.
    if os.path.exists(mp4_path):
        print("File exists!: ", mp4_path)
        # construct mp3 path 
        # Replace the .mp4 extension with .mp3
        # Get the file name without extension
        base_name = os.path.splitext(mp4_path)[0]
        mp3_path = f"{base_name}.mp3"  # Append .mp3 extension
        #construct wav file path
        wav_path = f"{base_name}.wav"  # Append .mp3 extension
        # construct the file to store the transcript
        transcript_path = f"{base_name}_transcript.txt"
        video = VideoFileClip(mp4_path)
        video.audio.write_audiofile(mp3_path)
        print("Conversion to mp3 complete!")
        audio = AudioFileClip(mp3_path)
        audio.write_audiofile(wav_path)
        print("Conversion to wav complete!")
        # Initialize the Whisper model (small model is a good balance for speed and accuracy)
        print("Transcribing audio...")
        model = whisper.load_model("tiny.en")  # Options: "tiny", "base", "small", "medium", "large"
        # Transcribe the audio
            
        result = model.transcribe(wav_path)
        print("Transcription completed!")
        meet_data=result["text"]
        with open(transcript_path, "w") as file:
            file.write(meet_data)
            print("Txt written to file: ", transcript_path)
        return meet_data
    else:
        print("File NOT found! Check the path for: ", mp4_path)       
        return "Test summary"
    
@app.get("/summarize")
def summarize_text(self,text, lang='en'):
    OpenAI.api_key = os.getenv("OPENAI_API_KEY")
    client = OpenAI(api_key=OpenAI.api_key)

    prompt = f"""
    The following text is in its original language. Provide the output in this language: {lang}. 
    Format the output as follows:
    
    Summary:
    short summary of the video
    
    Key Takeaways:
    succinct bullet point list of key takeaways
    
    Detailed important points:
    succinct bullet point list of feature details
    
    input text: {text}
    """
    
    response = client.chat.completions.create(
        messages=[{"role": "user", "content": prompt}],
        model="gpt-4o",
        temperature=0,
        #model="gpt-4-turbo", # better performance, slower inference
    )
    
    summary_text = response.to_dict()['choices'][0]['message']['content']
    return summary_text