Create app.py

app.py

@@ -0,0 +1,150 @@
+import streamlit as st
+import os
+from models import Model
+from prompt import Prompt  # Updated import
+from config import Config
+import yt_dlp
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+# Initialize OpenAI client
+@st.cache_resource
+def init_openai_client():
+    from openai import OpenAI
+    return OpenAI(api_key=Config.get_openai_api_key())
+
+client = init_openai_client()
+
+def download_audio(url):
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }],
+        'outtmpl': '%(id)s.%(ext)s',
+    }
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        return f"{info['id']}.mp3"
+
+def get_transcript_from_file(uploaded_file):
+    if uploaded_file is not None:
+        with st.spinner("Transcribing... This may take a few minutes."):
+            transcript = client.audio.transcriptions.create(
+                model="whisper-1", 
+                file=uploaded_file
+            )
+        return transcript.text.strip()
+    return None
+
+def get_transcript_from_url(url):
+    try:
+        if url != '':
+            with st.spinner("Downloading audio..."):
+                mp3_file = download_audio(url)
+            
+            file_stats = os.stat(mp3_file)
+            logging.info(f'Size of audio file in Bytes: {file_stats.st_size}')
+            
+            if file_stats.st_size <= 25000000:  # OpenAI has a 25MB limit
+                with st.spinner("Transcribing... This may take a few minutes."):
+                    with open(mp3_file, "rb") as audio_file:
+                        try:
+                            transcript = client.audio.transcriptions.create(
+                                model="whisper-1", 
+                                file=audio_file
+                            )
+                            result = transcript.text.strip()
+                        except Exception as api_error:
+                            logging.error(f"API Error: {str(api_error)}")
+                            result = f"API Error: {str(api_error)}"
+                
+                # Clean up the downloaded file
+                os.remove(mp3_file)
+                
+                return result
+            else:
+                os.remove(mp3_file)
+                return "Error: The audio file is too large. Please choose a shorter video (up to ~25MB audio file size)."
+    except Exception as e:
+        logging.error(f"An error occurred: {str(e)}")
+        return f"An error occurred: {str(e)}"
+
+def generate_notes(transcript):
+    # Using the updated Prompt class
+    return Model.openai_chatgpt(transcript=transcript, prompt=Prompt.prompt1())
+
+def generate_quiz(transcript):
+    # Using the updated Prompt class
+    raw_quiz = Model.openai_chatgpt(transcript, Prompt.prompt1(ID='quiz'))
+    return parse_quiz_content(raw_quiz)
+
+def parse_quiz_content(raw_quiz):
+    quiz_content = []
+    questions = raw_quiz.strip().split("\n\n")
+
+    for question in questions:
+        lines = question.split("\n")
+        if len(lines) < 6:  # Question + 4 options + correct answer
+            continue
+
+        question_text = lines[0].split(".", 1)[-1].strip()
+        options = [line.split(")", 1)[-1].strip() for line in lines[1:5]]
+        correct_answer = lines[-1].split(":")[-1].strip()
+
+        quiz_content.append({
+            "question": question_text,
+            "options": options,
+            "correct_answer": correct_answer
+        })
+
+    return quiz_content[:10]  # Ensure we return at most 10 questions
+
+def main():
+    st.title("AI-Powered Teaching Assistant")
+
+    # Choose input method
+    input_method = st.radio("Choose input method:", ("Upload File", "YouTube URL"))
+
+    transcript = None
+
+    if input_method == "Upload File":
+        uploaded_file = st.file_uploader("Choose an audio file", type=Config.ALLOWED_EXTENSIONS)
+        if uploaded_file is not None:
+            file_details = {"FileName": uploaded_file.name, "FileType": uploaded_file.type, "FileSize": uploaded_file.size}
+            st.write(file_details)
+            if uploaded_file.size <= 25000000:  # 25 MB in bytes
+                transcript = get_transcript_from_file(uploaded_file)
+            else:
+                st.error("File size exceeds 25 MB limit. Please upload a smaller file.")
+    else:
+        url = st.text_input("Enter YouTube URL:")
+        if url:
+            transcript = get_transcript_from_url(url)
+
+    if transcript:
+        st.subheader("Transcript")
+        st.text_area("Generated Transcript", transcript, height=200)
+
+        if st.button("Generate Notes and Quiz"):
+            with st.spinner("Generating notes..."):
+                notes = generate_notes(transcript)
+            st.subheader("Generated Notes")
+            st.markdown(notes)
+
+            with st.spinner("Generating quiz..."):
+                quiz = generate_quiz(transcript)
+            st.subheader("Generated Quiz")
+            for i, q in enumerate(quiz, 1):
+                st.write(f"{i}. {q['question']}")
+                for j, option in enumerate(q['options']):
+                    st.write(f"   {chr(65+j)}. {option}")
+                st.write(f"   Correct Answer: {q['correct_answer']}")
+                st.write("")
+
+if __name__ == "__main__":
+    main()