Uploaded files

Dockerfile

@@ -0,0 +1,26 @@
+# For more information, please refer to https://aka.ms/vscode-docker-python
+FROM python:3-slim
+
+EXPOSE 8000
+
+# Keeps Python from generating .pyc files in the container
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Turns off buffering for easier container logging
+ENV PYTHONUNBUFFERED=1
+WORKDIR /app
+# Install pip requirements
+COPY requirements.txt ./app/requirements.txt
+#COPY summarize_mp4_video.py /app/app.py
+RUN python -m pip install -r requirements.txt
+RUN apt-get update && apt-get install -y ffmpeg
+
+# COPY . /app
+
+# Creates a non-root user with an explicit UID and adds permission to access the /app folder
+# For more info, please refer to https://aka.ms/vscode-docker-python-configure-containers
+RUN adduser -u 5678 --disabled-password --gecos "" appuser && chown -R appuser /app
+USER appuser
+
+# During debugging, this entry point will be overridden. For more information, please refer to https://aka.ms/vscode-docker-python-debug
+CMD ["gunicorn", "--bind", "0.0.0.0:8000", "-k", "uvicorn.workers.UvicornWorker", "setup:app"]

app.py

@@ -0,0 +1,150 @@
+# ########## 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

requirements.txt

@@ -0,0 +1,151 @@
+#
+# This file is autogenerated by pip-compile with Python 3.13
+# by the following command:
+#
+#    pip-compile --output-file=requirements.txt requirements.in
+#
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.8.0
+    # via
+    #   httpx
+    #   openai
+    #   starlette
+asttokens==3.0.0
+    # via stack-data
+certifi==2025.1.31
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.1
+    # via requests
+colorama==0.4.6
+    # via
+    #   ipython
+    #   tqdm
+decorator==5.1.1
+    # via
+    #   ipython
+    #   moviepy
+distro==1.9.0
+    # via openai
+executing==2.2.0
+    # via stack-data
+fastapi==0.115.8
+    # via -r requirements.in
+ffmpeg-python==0.2.0
+    # via -r requirements.in
+filelock==3.17.0
+    # via
+    #   huggingface-hub
+    #   transformers
+fsspec==2025.2.0
+    # via huggingface-hub
+future==1.0.0
+    # via ffmpeg-python
+h11==0.14.0
+    # via httpcore
+httpcore==1.0.7
+    # via httpx
+httpx==0.28.1
+    # via openai
+huggingface-hub==0.28.1
+    # via
+    #   tokenizers
+    #   transformers
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+imageio==2.37.0
+    # via moviepy
+ipython==8.32.0
+    # via -r requirements.in
+jedi==0.19.2
+    # via ipython
+jiter==0.8.2
+    # via openai
+matplotlib-inline==0.1.7
+    # via ipython
+moviepy==0.2.3.1
+    # via -r requirements.in
+numpy==1.26.4
+    # via
+    #   imageio
+    #   moviepy
+    #   transformers
+openai==1.63.0
+    # via -r requirements.in
+packaging==24.2
+    # via
+    #   huggingface-hub
+    #   transformers
+parso==0.8.4
+    # via jedi
+pillow==11.1.0
+    # via imageio
+prompt-toolkit==3.0.50
+    # via ipython
+pure-eval==0.2.3
+    # via stack-data
+pydantic==2.10.6
+    # via
+    #   fastapi
+    #   openai
+pydantic-core==2.27.2
+    # via pydantic
+pygments==2.19.1
+    # via ipython
+python-dotenv==1.0.1
+    # via -r requirements.in
+pyyaml==6.0.2
+    # via
+    #   huggingface-hub
+    #   transformers
+regex==2024.11.6
+    # via transformers
+requests==2.32.3
+    # via
+    #   huggingface-hub
+    #   transformers
+safetensors==0.5.3
+    # via transformers
+six==1.17.0
+    # via whisper
+sniffio==1.3.1
+    # via
+    #   anyio
+    #   openai
+stack-data==0.6.3
+    # via ipython
+starlette==0.45.3
+    # via fastapi
+tokenizers==0.21.0
+    # via transformers
+tqdm==4.67.1
+    # via
+    #   huggingface-hub
+    #   moviepy
+    #   openai
+    #   transformers
+traitlets==5.14.3
+    # via
+    #   ipython
+    #   matplotlib-inline
+transformers==4.50.3
+    # via -r requirements.in
+typing-extensions==4.12.2
+    # via
+    #   fastapi
+    #   huggingface-hub
+    #   openai
+    #   pydantic
+    #   pydantic-core
+urllib3==2.3.0
+    # via requests
+wcwidth==0.2.13
+    # via prompt-toolkit
+whisper==1.1.10
+    # via -r requirements.in