Update app.py

app.py

@@ -1,112 +1,239 @@
-import streamlit as st
+import os
 import openai
-import io
+import streamlit as st
+from PyPDF2 import PdfReader
+from youtube_transcript_api import YouTubeTranscriptApi
+from pydub import AudioSegment
 from fpdf import FPDF
-import os
+from dotenv import load_dotenv
+import random
 
-# Set API key from environment variable
+# Load environment variables from .env file
+load_dotenv()
+
+# Set OpenAI API key
 openai.api_key = os.getenv('OPENAI_API_KEY')
 
+# Function to summarize text using GPT
+def summarize_text(text, model="gpt-3.5-turbo"):
+    response = openai.ChatCompletion.create(
+        model=model,
+        messages=[
+            {"role": "user", "content": text}
+        ],
+        max_tokens=150,
+    )
+    return response['choices'][0]['message']['content']
+
+# Function to transcribe audio using OpenAI Whisper
 def transcribe_audio(audio_file):
-    """
-    Transcribe audio using OpenAI's Whisper model.
-
-    Args:
-        audio_file: Audio file bytes.
-
-    Returns:
-        Transcription text.
-    """
     try:
-        audio_file_obj = io.BytesIO(audio_file.read())
-        audio_file_obj.name = audio_file.name
-        transcript = openai.Audio.transcribe(
-            model="whisper-1",
-            file=audio_file_obj
-        )
-        transcription = transcript.get('text', '')
-        return transcription
-    except openai.error.APIError as e:
-        st.error(f"OpenAI API error: {e}")
+        # Read the uploaded audio file directly as bytes
+        audio_bytes = audio_file.read()
+        
+        # Save the audio bytes temporarily
+        with open("temp_audio_file.wav", "wb") as temp_file:
+            temp_file.write(audio_bytes)
+
+        # Convert to mp3 for Whisper API
+        audio = AudioSegment.from_wav("temp_audio_file.wav")
+        audio.export("temp_audio_file.mp3", format="mp3")
+
+        with open("temp_audio_file.mp3", "rb") as f:
+            # Attempt to transcribe audio
+            transcript_response = openai.Audio.transcribe("whisper-1", f)
+        
+        return transcript_response['text']
+    except Exception as e:
+        st.error(f"Error during transcription: {str(e)}")
         return None
 
-def extract_key_topics(transcription, lesson_plan):
-    """
-    Extract key topics from the transcription using OpenAI GPT-3.5.
-
-    Args:
-        transcription: Transcription text.
-        lesson_plan: List of lesson plan topics.
-
-    Returns:
-        Key topics text.
+# New function to generate quiz questions
+def generate_quiz_questions(summarized_text, num_questions=10):
+    prompt = f"""Based on the following summarized text, generate {num_questions} multiple-choice questions with 4 options each. Format each question as follows:
+    Q: [Question]
+    A) [Option A]
+    B) [Option B]
+    C) [Option C]
+    D) [Option D]
+    Correct: [Correct option letter]
+
+    Summarized text:
+    {summarized_text}
     """
-    prompt = f"Here is a transcription of a lecture: '{transcription}'.\n"
-    prompt += "The following are key topics from the lesson plan:\n"
-    for topic in lesson_plan:
-        prompt += f"- {topic}\n"
-    prompt += "Please find the sentences in the transcription that match these key topics and include timestamps if possible."
-
-    try:
-        response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant."},
-                {"role": "user", "content": prompt}
-            ]
-        )
-        key_topics = response['choices'][0]['message']['content']
-        return key_topics
-    except openai.error.APIError as e:
-        st.error(f"OpenAI API error: {e}")
-        return None
-
-def generate_pdf(notes):
-    """
-    Generate a PDF file from notes.
-
-    Args:
-        notes: List of notes.
-
-    Returns:
-        PDF bytes.
-    """
-    pdf = FPDF()
-    pdf.add_page()
-    pdf.set_font("Arial", size=12)
-
-    for note in notes:
-        pdf.cell(200, 10, txt=note, ln=True)
-
-    return pdf.output(dest='S').encode('latin1')
-
+    
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant that generates quiz questions based on summarized text."},
+            {"role": "user", "content": prompt}
+        ],
+        max_tokens=1000,
+    )
+    
+    return response['choices'][0]['message']['content']
+
+# Function to parse quiz questions
+def parse_quiz_questions(quiz_text):
+    questions = []
+    for q in quiz_text.split('Q:')[1:]:
+        question = {}
+        lines = q.strip().split('\n')
+        question['question'] = lines[0].strip()
+        question['options'] = [line.strip()[3:] for line in lines[1:5]]
+        question['correct'] = lines[5].split(':')[1].strip()
+        questions.append(question)
+    return questions
+
+# Main app
 def main():
-    st.title("AI Teaching Assistant - Lecture Notes Generation")
-    st.sidebar.header("Upload Audio")
-
-    col1, col2 = st.columns(2)
+    st.set_page_config(page_title="AI Physics Summarization Assistant", layout="wide")
+    
+    # Sidebar for navigation
+    page = st.sidebar.selectbox("Choose a page", ["Summarization", "Quiz"])
+    
+    if page == "Summarization":
+        summarization_page()
+    elif page == "Quiz":
+        quiz_page()
+
+def summarization_page():
+    st.title("🧪 AI Physics Summarization Assistant")
+
+    # Layout: Create two columns
+    col1, col2 = st.columns([1, 2])  # Left column for inputs, right column for summaries and chat
+
+    # Input options in the left column
     with col1:
-        audio_file = st.file_uploader("Upload Lecture Audio", type=["wav", "mp3"])
+        st.header("🔍 Input Options")
+
+        # 1. Audio Summarization
+        st.subheader("Upload Audio File for Summarization")
+        audio_file = st.file_uploader("Choose an audio file...", type=["wav", "mp3", "m4a"])
+
+        if audio_file is not None:
+            st.audio(audio_file)  # Display audio player for uploaded file
+            if st.button("🔊 Summarize Audio", key="audio_summary"):
+                audio_text = transcribe_audio(audio_file)
+                if audio_text:
+                    summarized_text = summarize_text(audio_text)
+                    st.session_state.summarized_text = summarized_text  # Save summarized text to session state
+
+        st.markdown("<br>", unsafe_allow_html=True)  # Add spacing between sections
+
+        # 2. PDF Summarization
+        st.subheader("Upload PDF for Summarization")
+        pdf_file = st.file_uploader("Choose a PDF file...", type=["pdf"])
+
+        if pdf_file is not None:
+            pdf_reader = PdfReader(pdf_file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text()
+            
+            st.text_area("Extracted PDF Text", text[:1000])  # Show first 1000 chars
+
+            if st.button("📄 Summarize PDF", key="pdf_summary"):
+                summarized_text = summarize_text(text)
+                st.session_state.summarized_text = summarized_text  # Save summarized text to session state
+
+        st.markdown("<br>", unsafe_allow_html=True)  # Add spacing between sections
+
+        # 3. YouTube Summarization
+        st.subheader("Paste YouTube URL for Summarization")
+        youtube_url = st.text_input("Enter YouTube URL")
+
+        if youtube_url:
+            try:
+                video_id = youtube_url.split("v=")[1]
+                transcript = YouTubeTranscriptApi.get_transcript(video_id)
+                transcript_text = " ".join([entry['text'] for entry in transcript])
+
+                st.write("Extracted YouTube Transcript:")
+                st.text_area("Transcript", transcript_text[:1000])  # Display first 1000 chars
+
+                if st.button("📺 Summarize YouTube", key="youtube_summary"):
+                    summarized_text = summarize_text(transcript_text)
+                    st.session_state.summarized_text = summarized_text  # Save summarized text to session state
+
+            except Exception as e:
+                st.write(f"Error: {str(e)}")
+
+        # 4. Save Summarized Content as PDF
+        st.markdown("<br>", unsafe_allow_html=True)  # Add spacing
+        st.header("💾 Save Summarized Content as PDF")
+        if st.button("Save as PDF") and 'summarized_text' in st.session_state:
+            pdf = FPDF()
+            pdf.add_page()
+            pdf.set_font("Arial", size=12)
+            pdf.multi_cell(0, 10, st.session_state.summarized_text)
+            pdf_output = "summarized_text.pdf"
+            pdf.output(pdf_output)
+            st.success(f"Saved as {pdf_output}")
+        elif 'summarized_text' not in st.session_state:
+            st.warning("No summarized content to save.")
+
+    # Summarized output and chat in the right column
     with col2:
-        if audio_file:
-            st.audio(audio_file, format='audio/wav')
-
-    if audio_file:
-        transcription = transcribe_audio(audio_file)
-        st.success("Transcription complete!")
-        st.write("### Transcription:")
-        st.write(transcription)
-
-        lesson_plan = st.text_input("Enter lesson plan topics (comma-separated):")
-        lesson_plan = [topic.strip() for topic in lesson_plan.split(",")]
-        key_topics = extract_key_topics(transcription, lesson_plan)
-        st.write("### Generated Key Topics:")
-        st.write(key_topics)
-
-        pdf_data = generate_pdf(key_topics.splitlines())
-        st.download_button("Download PDF", data=pdf_data, file_name="lecture_notes.pdf", mime='application/pdf')
-
-    st.sidebar.markdown("[Home](https://studyscribe.framer.ai)", unsafe_allow_html=True)
-
+        st.header("📜 Summarized Output")
+        if 'summarized_text' in st.session_state:
+            st.text_area("Summarized Content", st.session_state.summarized_text, height=300)  # Show the summarized text
+        else:
+            st.write("No summarized content available yet.")
+
+        # Chatbox for interacting with the summarized context
+        st.header("💬 Chat with AI")
+        user_query = st.text_input("Ask your question about the summarized content:")
+        
+        if user_query and 'summarized_text' in st.session_state:
+            combined_input = f"{st.session_state.summarized_text}\n\nUser: {user_query}"
+            response = summarize_text(combined_input)
+            st.write("AI Response:")
+            st.write(response)
+
+def quiz_page():
+    st.title("📝 Quiz on Summarized Content")
+    
+    if 'summarized_text' not in st.session_state:
+        st.warning("Please summarize content first before taking the quiz.")
+        return
+    
+    if 'quiz_questions' not in st.session_state:
+        with st.spinner("Generating quiz questions..."):
+            quiz_text = generate_quiz_questions(st.session_state.summarized_text)
+            st.session_state.quiz_questions = parse_quiz_questions(quiz_text)
+    
+    if 'current_question' not in st.session_state:
+        st.session_state.current_question = 0
+        st.session_state.score = 0
+    
+    if st.session_state.current_question < len(st.session_state.quiz_questions):
+        question = st.session_state.quiz_questions[st.session_state.current_question]
+        st.write(f"Question {st.session_state.current_question + 1} of {len(st.session_state.quiz_questions)}")
+        st.write(question['question'])
+        
+        # Randomize the order of options
+        options = list(zip(['A', 'B', 'C', 'D'], question['options']))
+        random.shuffle(options)
+        
+        answer = st.radio("Choose your answer:", options, format_func=lambda x: f"{x[0]}) {x[1]}")
+        
+        if st.button("Submit Answer"):
+            if answer[0] == question['correct']:
+                st.success("Correct!")
+                st.session_state.score += 1
+            else:
+                st.error(f"Incorrect. The correct answer was {question['correct']}")
+            st.session_state.current_question += 1
+            st.rerun()  # Updated from st.experimental_rerun()
+    else:
+        st.success(f"Quiz completed! Your score: {st.session_state.score}/{len(st.session_state.quiz_questions)}")
+        if st.button("Restart Quiz"):
+            del st.session_state['quiz_questions']
+            del st.session_state['current_question']
+            del st.session_state['score']
+            st.rerun()  # Updated from st.experimental_rerun()
+
+# Run the app
 if __name__ == "__main__":
     main()