Update app.py

app.py

@@ -1,106 +1,122 @@
-from fastapi import FastAPI, File, UploadFile, Form
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from deepgram import Deepgram
 import openai
-import asyncio
+import gradio as gr
 import os
-
-app = FastAPI()
-
-# Enable CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # For production, specify your Framer website URL
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Retrieve API keys from environment variables
-DEEPGRAM_API_KEY = os.getenv('DEEPGRAM_API_KEY')
-OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
-
-if not DEEPGRAM_API_KEY or not OPENAI_API_KEY:
-    raise Exception("API keys for Deepgram and OpenAI must be set as environment variables.")
-
-deepgram_client = Deepgram(DEEPGRAM_API_KEY)
-openai.api_key = OPENAI_API_KEY
-
-async def transcribe_audio(audio_bytes):
-    source = {'buffer': audio_bytes, 'mimetype': 'audio/wav'}
-    options = {'punctuate': True, 'utterances': True}
-    response = await deepgram_client.transcription.prerecorded(source, options)
-    return response['results']['utterances']
-
-def summarize_segment(segment, lesson_plan):
-    prompt = f"""
-    Lecture Segment (Timestamp: {segment['start']} - {segment['end']} seconds):
-
-    "{segment['transcript']}"
-
-    Based on the lesson plan below, summarize the key points discussed in this segment:
-
-    Lesson Plan:
-    {lesson_plan}
-
-    Provide a concise summary with key takeaways.
-    """
-
-    response = openai.Completion.create(
-        engine='text-davinci-003',
-        prompt=prompt,
-        max_tokens=150,
-        temperature=0.5,
+import time
+from datetime import datetime
+from pydub import AudioSegment
+import io
+import yt_dlp
+import PyPDF2
+
+# Define your OpenAI API key
+openai.api_key = "YOUR_OPENAI_API_KEY"
+
+# Function to convert audio file to text using OpenAI's Whisper
+
+def transcribe_audio(audio_file):
+    # Load the audio file
+    audio = AudioSegment.from_file(audio_file.name)
+    # Export as WAV, which Whisper accepts
+    buffer = io.BytesIO()
+    audio.export(buffer, format="wav")
+    buffer.seek(0)
+
+    response = openai.Audio.transcribe(
+        "whisper-1",
+        file=buffer,
+        model='whisper',
+        response_format='verbose_json'
     )
-
-    return response.choices[0].text.strip()
-
-def generate_lecture_notes(summaries, lesson_plan):
-    summaries_text = "\n".join([f"At {item['timestamp']}: {item['summary']}" for item in summaries])
-
+    return response
+
+# Function to download audio from YouTube URL
+
+def download_youtube_audio(url):
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'outtmpl': 'downloaded_audio.%(ext)s',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }],
+    }
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([url])
+    return 'downloaded_audio.mp3'
+
+# Function to extract text from PDF
+
+def extract_text_from_pdf(pdf_file):
+    pdf_reader = PyPDF2.PdfFileReader(pdf_file)
+    text = ""
+    for page_num in range(pdf_reader.numPages):
+        text += pdf_reader.getPage(page_num).extract_text() + "\n"
+    return text
+
+# Function to generate summarised lecture notes using GPT-3.5
+
+def generate_summary(transcription):
+    transcription_text = "\n".join([f"{segment['start']:.2f}-{segment['end']:.2f}: {segment['text']}" for segment in transcription['segments']])
     prompt = f"""
-    Using the summarized lecture segments below and the lesson plan, create detailed lecture notes.
+    You are an intelligent assistant that will summarize the transcription below.
+    The transcription text is:
+    {transcription_text}
 
-    Summarized Segments:
-    {summaries_text}
-
-    Lesson Plan:
-    {lesson_plan}
-
-    Provide comprehensive lecture notes in a structured format.
+    Summarize the content into 1000 tokens or less, focusing on the key topics and main points.
     """
-
-    response = openai.Completion.create(
-        engine='text-davinci-003',
-        prompt=prompt,
-        max_tokens=1000,
-        temperature=0.5,
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "You are an expert summarizer."},
+            {"role": "user", "content": prompt}
+        ]
     )
-
-    return response.choices[0].text.strip()
-
-@app.post("/process")
-async def process_files(audio_file: UploadFile = File(...), lesson_plan: str = Form(...)):
-    audio_bytes = await audio_file.read()
-
-    # Transcribe audio
-    utterances = await transcribe_audio(audio_bytes)
-
-    # Summarize each segment
-    summarized_texts = []
-    for segment in utterances:
-        summary = summarize_segment(segment, lesson_plan)
-        summarized_texts.append({
-            'timestamp': f"{segment['start']} - {segment['end']}",
-            'summary': summary
-        })
-
-    # Generate detailed lecture notes
-    lecture_notes = generate_lecture_notes(summarized_texts, lesson_plan)
-
-    # Prepare the response
-    return JSONResponse(content={
-        'summarized_texts': summarized_texts,
-        'lecture_notes': lecture_notes
-    })
+    summary = response['choices'][0]['message']['content']
+    return summary
+
+# Define the main function to handle transcription and summary generation
+
+def process_lecture(input_data, lesson_plan):
+    transcription = ""
+    if isinstance(input_data, tuple):  # Audio input
+        input_type, input_value = input_data
+        if input_type == "audio":
+            with gr.File(input_value) as f:
+                transcription = transcribe_audio(f)
+        elif input_type == "youtube":
+            audio_path = download_youtube_audio(input_value)
+            with open(audio_path, "rb") as f:
+                transcription = transcribe_audio(f)
+        elif input_type == "pdf":
+            transcription = extract_text_from_pdf(input_value)
+    
+    transcription_text = "\n".join([f"{segment['start']:.2f}-{segment['end']:.2f}: {segment['text']}" for segment in transcription['segments']])
+    summary = generate_summary(transcription)
+    return transcription_text, summary
+
+# Set up Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Lecture Notes Generation Tool\nConvert your lecture recordings, PDFs, or YouTube links into detailed and structured notes easily!")
+
+    with gr.Tab("Upload"):
+        input_type = gr.Radio(label="Select Input Type", choices=["Audio File", "PDF Document", "YouTube URL"], type="value")
+        audio_input = gr.Audio(label="Upload your lecture audio file (mp3/wav)", visible=False)
+        pdf_input = gr.File(label="Upload PDF Document", visible=False)
+        youtube_input = gr.Textbox(label="Enter YouTube URL", visible=False)
+        lesson_plan_input = gr.Textbox(label="Enter the lesson plan for context", lines=5)
+
+        def update_visibility(input_choice):
+            return gr.update(visible=input_choice == "Audio File"), gr.update(visible=input_choice == "PDF Document"), gr.update(visible=input_choice == "YouTube URL")
+
+        input_type.change(fn=update_visibility, inputs=[input_type], outputs=[audio_input, pdf_input, youtube_input])
+
+        submit_btn = gr.Button("Generate Notes")
+
+        with gr.Tab("Transcription and Notes"):
+            transcription_output = gr.Textbox(label="Lecture Transcription with Timestamps", interactive=False)
+            summary_output = gr.Textbox(label="Summarized Lecture Notes", interactive=False)
+
+    submit_btn.click(fn=process_lecture, inputs=[(input_type, [audio_input, pdf_input, youtube_input]), lesson_plan_input], outputs=[transcription_output, summary_output])
+
+# Launch the interface demo.launch(share=True)