Update app.py

app.py

@@ -1,101 +1,127 @@
 import streamlit as st
-import requests
-from openai import OpenAI
 from youtube_transcript_api import YouTubeTranscriptApi
 import re
 import tempfile
 import os
+import whisper
+import warnings
+from groq import Groq
 
-# Function to transcribe audio using Hugging Face Inference API
-def transcribe_audio(api_key, file_path):
-    API_URL = "https://api-inference.huggingface.co/models/openai/whisper-large"
-    headers = {"Authorization": f"Bearer {api_key}"}
-    with open(file_path, "rb") as f:
-        data = f.read()
-    response = requests.post(API_URL, headers=headers, data=data)
+# Suppress specific warning
+warnings.filterwarnings("ignore", message="FP16 is not supported on CPU; using FP32 instead")
 
-    try:
-        if response.status_code != 200:
-            return f"Error: Received status code {response.status_code}"
-        if not response.content:
-            return "Error: Empty response from server"
-        if 'application/json' not in response.headers.get('Content-Type', ''):
-            return "Error: Response is not in JSON format"
-        return response.json().get("text", "Error: Could not transcribe audio")
-    except requests.exceptions.JSONDecodeError:
-        return "Error: Could not decode JSON response"
-
-# Function to get YouTube transcript
+# Set up Groq client
+client = Groq(
+    api_key=os.environ.get("GROQ_API_KEY"),
+)
+
+# Function to transcribe audio
+def transcribe_audio(file_path):
+    model = whisper.load_model("base")
+    result = model.transcribe(file_path)
+    return result["text"]
+
+# Function to get transcript from YouTube
 def get_transcript(url):
     try:
         video_id_match = re.search(r"(?:v=|\/)([0-9A-Za-z_-]{11}).*", url)
-        if video_id_match:
-            video_id = video_id_match.group(1)
-        else:
+        if not video_id_match:
             return "Error: Invalid YouTube URL"
 
+        video_id = video_id_match.group(1)
         transcript = YouTubeTranscriptApi.get_transcript(video_id)
         transcript_text = ' '.join([entry['text'] for entry in transcript])
         return transcript_text
     except Exception as e:
         return str(e)
 
-# Function to summarize text using OpenAI API
-def summarize_text(client, text):
-    response = client.chat.completions.create(
-        model="gpt-3.5-turbo",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": f"Summarize the following text:\n\n{text}"}
-        ]
-    )
-    summary = response.choices[0].message.content.strip()
-    return summary
-
-# Function to generate quiz questions using OpenAI API
-def generate_quiz_questions(client, text):
-    response = client.chat.completions.create(
-        model="gpt-3.5-turbo",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": f"Generate ten quiz questions and four multiple choice answers for each question from the following text. Mark the correct answer with an asterisk (*) at the beginning:\n\n{text}"}
-        ]
-    )
-    quiz_questions = response.choices[0].message.content.strip()
-    return quiz_questions
-
-# Function to parse quiz questions
+# Function to summarize text using Groq API
+def summarize_text(text):
+    try:
+        response = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"Summarize the following text:\n\n{text}"
+                }
+            ],
+            model="llama3-8b-8192",
+        )
+        summary = response.choices[0].message.content.strip()
+        return summary
+    except Exception as e:
+        return f"Error summarizing text: {e}"
+
+# Function to generate quiz questions using Groq API
+def generate_quiz_questions(text):
+    try:
+        response = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"Generate quiz questions for the following text:\n\n{text}"
+                }
+            ],
+            model="llama3-8b-8192",
+        )
+        quiz_questions = response.choices[0].message.content.strip()
+        return quiz_questions
+    except Exception as e:
+        return f"Error generating quiz questions: {e}"
+
+# Function to parse quiz questions from generated text
 def parse_quiz_questions(quiz_text):
     questions = []
     question_blocks = quiz_text.split("\n\n")
+    current_question = None
+    current_choices = []
+    correct_answer = None
+    
     for block in question_blocks:
         lines = block.strip().split("\n")
-        if len(lines) >= 5:
-            question = lines[0]
-            choices = [line.replace('*', '').strip() for line in lines[1:5]]
-            correct_answer_lines = [line for line in lines[1:5] if '*' in line]
-            if correct_answer_lines:
-                correct_answer = correct_answer_lines[0].replace('*', '').strip()
-            else:
-                correct_answer = "No correct answer provided"
-            questions.append({"question": question, "choices": choices, "correct_answer": correct_answer})
+        if lines:
+            if re.match(r'^\d+\.', lines[0]):  # This line is a question number
+                if current_question and current_choices and correct_answer:
+                    questions.append({
+                        "question": current_question,
+                        "choices": current_choices,
+                        "correct_answer": correct_answer
+                    })
+                current_question = lines[0]
+                current_choices = lines[1:5]
+                correct_answer = lines[-1].split(": ")[-1].strip() if len(lines) > 5 else None
+            else:  # This line is an answer
+                correct_answer = lines[-1].split(": ")[-1].strip()
+
+    # Add the last question if it exists
+    if current_question and current_choices and correct_answer:
+        questions.append({
+            "question": current_question,
+            "choices": current_choices,
+            "correct_answer": correct_answer
+        })
+    
     return questions
 
-# Function to generate explanation using OpenAI API
-def generate_explanation(client, question, correct_answer, user_answer):
-    prompt = f"Explain why the correct answer to the following question is '{correct_answer}' and not '{user_answer}':\n\n{question}"
-    response = client.chat.completions.create(
-        model="gpt-3.5-turbo",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": prompt}
-        ]
-    )
-    explanation = response.choices[0].message.content.strip()
-    return explanation
+# Function to generate explanation for quiz answers using Groq API
+def generate_explanation(question, correct_answer, user_answer):
+    try:
+        response = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"Explain why the correct answer to the following question is '{correct_answer}' and not '{user_answer}':\n\n{question}"
+                }
+            ],
+            model="llama3-8b-8192",
+        )
+        explanation = response.choices[0].message.content.strip()
+        return explanation
+    except Exception as e:
+        return f"Error generating explanation: {e}"
 
 # Function to check answers and provide feedback
-def check_answers(client, questions, user_answers):
+def check_answers(questions, user_answers):
     feedback = []
     correct_count = 0
     for i, question in enumerate(questions):
@@ -110,7 +136,7 @@ def check_answers(client, questions, user_answers):
             })
             correct_count += 1
         else:
-            explanation = generate_explanation(client, question['question'], correct_answer, user_answer)
+            explanation = generate_explanation(question['question'], correct_answer, user_answer)
             feedback.append({
                 "question": question['question'],
                 "user_answer": user_answer,
@@ -120,60 +146,63 @@ def check_answers(client, questions, user_answers):
             })
     return feedback
 
-# Function to handle uploaded file
+# Function to handle uploaded files
 def handle_uploaded_file(uploaded_file):
     with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
         tmp_file.write(uploaded_file.read())
         tmp_file_path = tmp_file.name
     return tmp_file_path
 
-# Streamlit UI
+# Streamlit app layout and functionality
 st.title("YouTube Transcript Quiz Generator")
+st.markdown("**Instructions:** Paste a YouTube link or upload a media file to generate a quiz.")
 
-st.markdown("**Instructions:** Enter your OpenAI and Hugging Face API keys, and paste a YouTube link or upload a media file to generate a quiz.")
-
-openai_api_key = st.text_input("Enter your OpenAI API Key", type="password")
-hf_api_key = st.text_input("Enter your Hugging Face API Key", type="password")
 option = st.selectbox("Choose input type", ("YouTube URL", "Upload audio/video file"))
 
-if openai_api_key:
-    client = OpenAI(api_key=openai_api_key)
-
 if "generated_quiz" not in st.session_state:
     st.session_state.generated_quiz = False
 
 if option == "YouTube URL":
     url = st.text_input("YouTube URL", value="")
-    if openai_api_key and hf_api_key and url:
+    if url:
         if st.button("Generate Quiz"):
             transcript_text = get_transcript(url)
             if "Error" not in transcript_text:
-                summary = summarize_text(client, transcript_text)
-                quiz_text = generate_quiz_questions(client, transcript_text)
+                summary = summarize_text(transcript_text)
+                quiz_text = generate_quiz_questions(transcript_text)
                 questions = parse_quiz_questions(quiz_text)
 
-                st.session_state.summary = summary
-                st.session_state.questions = questions
-                st.session_state.user_answers = {}
-                st.session_state.generated_quiz = True
+                if not questions:
+                    st.error("No valid quiz questions could be generated.")
+                else:
+                    st.session_state.summary = summary
+                    st.session_state.questions = questions
+                    st.session_state.user_answers = {}
+                    st.session_state.generated_quiz = True
+            else:
+                st.error(transcript_text)
 
 if option == "Upload audio/video file":
     uploaded_file = st.file_uploader("Choose an audio or video file", type=["mp3", "wav", "mp4", "mov"])
-    if uploaded_file and openai_api_key and hf_api_key:
+    if uploaded_file:
         if st.button("Generate Quiz"):
             tmp_file_path = handle_uploaded_file(uploaded_file)
-            with st.spinner('Transcribing audio...'):
-                transcript_text = transcribe_audio(hf_api_key, tmp_file_path)
+            transcript_text = transcribe_audio(tmp_file_path)
             os.remove(tmp_file_path)
             if "Error" not in transcript_text:
-                summary = summarize_text(client, transcript_text)
-                quiz_text = generate_quiz_questions(client, transcript_text)
+                summary = summarize_text(transcript_text)
+                quiz_text = generate_quiz_questions(transcript_text)
                 questions = parse_quiz_questions(quiz_text)
 
-                st.session_state.summary = summary
-                st.session_state.questions = questions
-                st.session_state.user_answers = {}
-                st.session_state.generated_quiz = True
+                if not questions:
+                    st.error("No valid quiz questions could be generated.")
+                else:
+                    st.session_state.summary = summary
+                    st.session_state.questions = questions
+                    st.session_state.user_answers = {}
+                    st.session_state.generated_quiz = True
+            else:
+                st.error(transcript_text)
 
 if st.session_state.generated_quiz:
     st.write("## Summary")
@@ -192,7 +221,7 @@ if st.session_state.generated_quiz:
     if st.button("Submit Answers"):
         if "questions" in st.session_state and st.session_state.questions:
             with st.spinner('Processing your answers...'):
-                feedback = check_answers(client, st.session_state.questions, st.session_state.user_answers)
+                feedback = check_answers(st.session_state.questions, st.session_state.user_answers)
                 st.write("## Feedback")
                 for i, item in enumerate(feedback):
                     with st.expander(f"Question {i+1} Feedback"):