app.py

import streamlit as st
from youtube_transcript_api import YouTubeTranscriptApi
import re
import tempfile
import os
import warnings
from groq import Groq

# Set up Groq client
client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

# Supported file types for Groq API
SUPPORTED_FILE_TYPES = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]

# Function to transcribe audio using Groq Whisper API
def transcribe_audio(file_path):
    file_extension = os.path.splitext(file_path)[1][1:]
    if file_extension not in SUPPORTED_FILE_TYPES:
        return f"Error: Unsupported file type '{file_extension}'. Please upload a valid file."
    
    try:
        with open(file_path, "rb") as file:
            transcription = client.audio.transcriptions.create(
                file=(file_path, file.read()),
                model="whisper-large-v3",
            )
        return transcription.text
    except Exception as e:
        return f"Error during transcription: {e}"

# 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 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 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 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 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(questions, user_answers):
    feedback = []
    correct_count = 0
    for i, question in enumerate(questions):
        correct_answer = question['correct_answer']
        user_answer = user_answers.get(f"question_{i+1}", "")
        if user_answer == correct_answer:
            feedback.append({
                "question": question['question'],
                "user_answer": user_answer,
                "correct_answer": correct_answer,
                "status": "Correct"
            })
            correct_count += 1
        else:
            explanation = generate_explanation(question['question'], correct_answer, user_answer)
            feedback.append({
                "question": question['question'],
                "user_answer": user_answer,
                "correct_answer": correct_answer,
                "status": "Incorrect",
                "explanation": explanation
            })
    return feedback

# Function to handle uploaded files
def handle_uploaded_file(uploaded_file):
    file_path = tempfile.mktemp(suffix=os.path.splitext(uploaded_file.name)[1])
    with open(file_path, "wb") as f:
        f.write(uploaded_file.read())
    return file_path

# 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.")

option = st.selectbox("Choose input type", ("YouTube URL", "Upload audio/video file"))

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 url:
        if st.button("Generate Quiz"):
            transcript_text = get_transcript(url)
            if "Error" not in transcript_text:
                summary = summarize_text(transcript_text)
                quiz_text = generate_quiz_questions(transcript_text)
                questions = parse_quiz_questions(quiz_text)

                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=SUPPORTED_FILE_TYPES)
    if uploaded_file:
        if st.button("Generate Quiz"):
            tmp_file_path = handle_uploaded_file(uploaded_file)
            transcript_text = transcribe_audio(tmp_file_path)
            os.remove(tmp_file_path)
            if "Error" not in transcript_text:
                summary = summarize_text(transcript_text)
                quiz_text = generate_quiz_questions(transcript_text)
                questions = parse_quiz_questions(quiz_text)

                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")
    st.write(st.session_state.summary)

    st.write("## Quiz Questions")
    for i, question in enumerate(st.session_state.questions):
        st.write(f"### Question {i+1}")
        st.write(question['question'])
        st.session_state.user_answers[f"question_{i+1}"] = st.radio(
            label="",
            options=question['choices'],
            key=f"question_{i+1}"
        )

    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(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"):
                        st.write(f"### {item['question']}")
                        st.write(f"**Your answer:** {item['user_answer']}")
                        st.write(f"**Correct answer:** {item['correct_answer']}")
                        if item['status'] == "Incorrect":
                            st.write(f"**Explanation:** {item['explanation']}")
        else:
            st.write("Please generate the quiz first.")