Create app.py

app.py

@@ -0,0 +1,410 @@
+import os
+import re
+import PyPDF2
+import docx
+import googleapiclient.discovery
+import nltk
+from nltk.tokenize import sent_tokenize
+from transformers import pipeline, AutoModelForSeq2SeqLM, AutoTokenizer
+from youtube_transcript_api import YouTubeTranscriptApi
+import streamlit as st
+import pandas as pd
+import random
+from io import StringIO
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Download necessary NLTK resources
+nltk.download('punkt')
+nltk.download('averaged_perceptron_tagger')
+
+class QuizGenerator:
+    def __init__(self):
+        # Initialize the summarizer and question generator models
+        self.summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+        
+        # Load question generation model
+        self.qg_model = AutoModelForSeq2SeqGeneration.from_pretrained("valhalla/t5-base-qg-hl")
+        self.qg_tokenizer = AutoTokenizer.from_pretrained("valhalla/t5-base-qg-hl")
+        
+        # Initialize MCQ generation components
+        self.qa_model = pipeline('question-answering', model='distilbert-base-cased-distilled-squad')
+    
+    def extract_text_from_pdf(self, pdf_file):
+        """Extract text from a PDF file."""
+        try:
+            text = ""
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            for page in pdf_reader.pages:
+                text += page.extract_text() + "\n"
+            return text
+        except Exception as e:
+            logger.error(f"Error extracting text from PDF: {e}")
+            return ""
+
+    def extract_text_from_docx(self, docx_file):
+        """Extract text from a DOCX file."""
+        try:
+            doc = docx.Document(docx_file)
+            text = ""
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+            return text
+        except Exception as e:
+            logger.error(f"Error extracting text from DOCX: {e}")
+            return ""
+
+    def extract_text_from_txt(self, txt_file):
+        """Extract text from a TXT file."""
+        try:
+            return txt_file.read().decode('utf-8')
+        except Exception as e:
+            logger.error(f"Error extracting text from TXT: {e}")
+            return ""
+
+    def get_youtube_transcript(self, video_id):
+        """Extract transcript from a YouTube video."""
+        try:
+            transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+            transcript = ' '.join([item['text'] for item in transcript_list])
+            return transcript
+        except Exception as e:
+            logger.error(f"Error getting YouTube transcript: {e}")
+            return ""
+
+    def summarize_text(self, text, max_length=1000):
+        """Summarize long text to make processing more efficient."""
+        if len(text) <= max_length:
+            return text
+            
+        chunks = self._split_text_into_chunks(text, max_length=3000)
+        summaries = []
+        
+        for chunk in chunks:
+            if len(chunk) < 100:  # Skip chunks that are too small
+                continue
+                
+            summary = self.summarizer(chunk, max_length=300, min_length=100, do_sample=False)
+            summaries.append(summary[0]['summary_text'])
+            
+        return " ".join(summaries)
+
+    def _split_text_into_chunks(self, text, max_length=3000):
+        """Split text into chunks of max_length characters."""
+        sentences = sent_tokenize(text)
+        chunks = []
+        current_chunk = ""
+        
+        for sentence in sentences:
+            if len(current_chunk) + len(sentence) <= max_length:
+                current_chunk += " " + sentence
+            else:
+                chunks.append(current_chunk.strip())
+                current_chunk = sentence
+                
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+            
+        return chunks
+
+    def generate_questions(self, text, num_questions=5):
+        """Generate questions based on the input text."""
+        try:
+            # Summarize text if it's too long
+            processed_text = self.summarize_text(text)
+            
+            # Split into sentences
+            sentences = sent_tokenize(processed_text)
+            
+            questions = []
+            random.shuffle(sentences)  # Randomize to get different questions each time
+            
+            for sentence in sentences[:min(num_questions * 3, len(sentences))]:  # Process more sentences than needed
+                if len(sentence.split()) < 5:  # Skip short sentences
+                    continue
+                    
+                # Format for the question generation model
+                input_text = f"generate question: {sentence}"
+                
+                # Generate question
+                inputs = self.qg_tokenizer.encode(input_text, return_tensors="pt", max_length=512, truncation=True)
+                outputs = self.qg_model.generate(inputs, max_length=64, num_beams=4, early_stopping=True)
+                question = self.qg_tokenizer.decode(outputs[0], skip_special_tokens=True)
+                
+                # Use QA model to get answer
+                qa_input = {
+                    'question': question,
+                    'context': processed_text
+                }
+                answer = self.qa_model(qa_input)
+                
+                if answer['score'] > 0.1:  # Only keep questions with reasonable confidence
+                    questions.append({
+                        'question': question,
+                        'answer': answer['answer'],
+                        'context': sentence
+                    })
+                    
+                if len(questions) >= num_questions:
+                    break
+            
+            return questions
+            
+        except Exception as e:
+            logger.error(f"Error generating questions: {e}")
+            return []
+
+    def generate_mcq(self, questions, num_options=4):
+        """Convert open-ended questions to multiple-choice questions."""
+        mcqs = []
+        
+        for q in questions:
+            correct_answer = q['answer']
+            
+            # Generate distractors (incorrect options)
+            distractors = self._generate_distractors(q['context'], correct_answer, num_options-1)
+            
+            # Create options list with correct answer
+            options = distractors + [correct_answer]
+            random.shuffle(options)
+            
+            # Find position of correct answer
+            correct_index = options.index(correct_answer)
+            
+            mcqs.append({
+                'question': q['question'],
+                'options': options,
+                'correct_answer': correct_answer,
+                'correct_index': correct_index
+            })
+            
+        return mcqs
+    
+    def _generate_distractors(self, context, correct_answer, num_distractors=3):
+        """Generate plausible but incorrect answers."""
+        # Simple approach - extract other nouns from the text
+        words = nltk.word_tokenize(context)
+        pos_tags = nltk.pos_tag(words)
+        
+        # Extract nouns and named entities
+        nouns = [word for word, pos in pos_tags if pos in ('NN', 'NNS', 'NNP', 'NNPS') and word.lower() != correct_answer.lower()]
+        
+        # Deduplicate and filter
+        unique_nouns = list(set(nouns))
+        distractors = [noun for noun in unique_nouns if len(noun) > 2]
+        
+        # If we don't have enough distractors, add some generic ones
+        generic_distractors = ["None of the above", "Cannot be determined", "All of the above"]
+        
+        # Combine and return required number
+        combined = list(distractors) + generic_distractors
+        random.shuffle(combined)
+        
+        return combined[:num_distractors]
+
+    def generate_true_false(self, text, num_questions=5):
+        """Generate true/false questions from text."""
+        try:
+            # Generate factual statements first
+            questions = self.generate_questions(text, num_questions)
+            true_false = []
+            
+            for q in questions:
+                # Original statement is true
+                true_statement = {
+                    'statement': q['context'],
+                    'is_true': True
+                }
+                
+                # Create a false version by negating or changing key parts
+                words = q['context'].split()
+                if len(words) > 4:
+                    # Simple modification: replace a word or add a negation
+                    change_idx = random.randint(0, len(words)-1)
+                    words[change_idx] = random.choice(["not", "never", "rarely", "incorrectly"]) + " " + words[change_idx]
+                    false_statement = {
+                        'statement': " ".join(words),
+                        'is_true': False
+                    }
+                    
+                    true_false.extend([true_statement, false_statement])
+            
+            # Shuffle and return required number
+            random.shuffle(true_false)
+            return true_false[:num_questions]
+            
+        except Exception as e:
+            logger.error(f"Error generating true/false questions: {e}")
+            return []
+
+def create_streamlit_app():
+    st.set_page_config(page_title="QuizWhiz", page_icon="📚", layout="wide")
+    
+    st.title("QuizWhiz - Comprehensive Quiz Generator")
+    st.subheader("Generate quizzes from various sources: text, documents, and YouTube videos")
+    
+    quiz_gen = QuizGenerator()
+    
+    # Sidebar for options
+    st.sidebar.header("Quiz Options")
+    quiz_type = st.sidebar.selectbox(
+        "Question Type",
+        ["Multiple Choice", "True/False", "Open-Ended"]
+    )
+    
+    num_questions = st.sidebar.slider("Number of Questions", 3, 20, 5)
+    
+    # Source selection
+    st.header("Select Your Content Source")
+    source_type = st.radio(
+        "Content Source",
+        ["Text Input", "Document Upload", "YouTube Video", "Topic/Subject"]
+    )
+    
+    text_content = ""
+    
+    # Handle different source types
+    if source_type == "Text Input":
+        text_content = st.text_area("Enter your text content here:", height=250)
+        
+    elif source_type == "Document Upload":
+        uploaded_file = st.file_uploader("Upload your document", type=['pdf', 'docx', 'txt'])
+        
+        if uploaded_file is not None:
+            st.success(f"File '{uploaded_file.name}' uploaded successfully!")
+            
+            # Extract text based on file type
+            if uploaded_file.name.endswith('.pdf'):
+                text_content = quiz_gen.extract_text_from_pdf(uploaded_file)
+            elif uploaded_file.name.endswith('.docx'):
+                text_content = quiz_gen.extract_text_from_docx(uploaded_file)
+            elif uploaded_file.name.endswith('.txt'):
+                text_content = quiz_gen.extract_text_from_txt(uploaded_file)
+                
+            # Show text preview
+            if text_content:
+                with st.expander("Preview Extracted Text"):
+                    st.text(text_content[:500] + "..." if len(text_content) > 500 else text_content)
+            else:
+                st.error("Failed to extract text from the document.")
+                
+    elif source_type == "YouTube Video":
+        youtube_url = st.text_input("Enter YouTube Video URL:")
+        
+        if youtube_url:
+            # Extract video ID from URL
+            video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11}).*', youtube_url)
+            
+            if video_id_match:
+                video_id = video_id_match.group(1)
+                
+                # Show video embed
+                st.video(youtube_url)
+                
+                # Extract transcript
+                with st.spinner("Extracting video transcript..."):
+                    text_content = quiz_gen.get_youtube_transcript(video_id)
+                
+                if text_content:
+                    with st.expander("Preview Transcript"):
+                        st.text(text_content[:500] + "..." if len(text_content) > 500 else text_content)
+                else:
+                    st.error("Failed to extract transcript. This video might not have captions.")
+            else:
+                st.error("Invalid YouTube URL. Please enter a valid URL.")
+                
+    elif source_type == "Topic/Subject":
+        topic = st.text_input("Enter a topic or subject:")
+        
+        if topic:
+            # For this demo, we'll use a predefined text about the topic
+            # In a real app, you might use an API to fetch content about the topic
+            st.info(f"Generating quiz about: {topic}")
+            text_content = f"The topic of {topic} is a fascinating subject to explore. " \
+                          f"There are many important concepts and facts related to {topic} " \
+                          f"that make it an essential area of study. Understanding {topic} " \
+                          f"requires careful consideration of its key principles."
+                          
+            # Placeholder for a real implementation that would gather information about the topic
+            st.warning("In a complete implementation, this would gather information about the topic from reliable sources.")
+    
+    # Generate Quiz Button
+    if text_content:
+        if st.button("Generate Quiz"):
+            with st.spinner("Generating quiz questions..."):
+                if quiz_type == "Multiple Choice":
+                    # Generate questions first
+                    questions = quiz_gen.generate_questions(text_content, num_questions)
+                    # Convert to MCQs
+                    mcqs = quiz_gen.generate_mcq(questions)
+                    
+                    if mcqs:
+                        st.success(f"Generated {len(mcqs)} multiple choice questions!")
+                        
+                        # Display questions
+                        for i, q in enumerate(mcqs, 1):
+                            st.subheader(f"Question {i}: {q['question']}")
+                            
+                            # Display options
+                            option_letters = ['A', 'B', 'C', 'D']
+                            for j, option in enumerate(q['options']):
+                                st.write(f"{option_letters[j]}. {option}")
+                            
+                            # Reveal answer in expander
+                            with st.expander("Reveal Answer"):
+                                st.write(f"Correct Answer: {option_letters[q['correct_index']]}. {q['correct_answer']}")
+                                
+                            st.divider()
+                    else:
+                        st.error("Failed to generate questions. Try with different content.")
+                        
+                elif quiz_type == "True/False":
+                    tf_questions = quiz_gen.generate_true_false(text_content, num_questions)
+                    
+                    if tf_questions:
+                        st.success(f"Generated {len(tf_questions)} true/false questions!")
+                        
+                        # Display questions
+                        for i, q in enumerate(tf_questions, 1):
+                            st.subheader(f"Question {i}: True or False?")
+                            st.write(q['statement'])
+                            
+                            # Reveal answer
+                            with st.expander("Reveal Answer"):
+                                st.write(f"Answer: {'True' if q['is_true'] else 'False'}")
+                                
+                            st.divider()
+                    else:
+                        st.error("Failed to generate true/false questions. Try with different content.")
+                        
+                elif quiz_type == "Open-Ended":
+                    questions = quiz_gen.generate_questions(text_content, num_questions)
+                    
+                    if questions:
+                        st.success(f"Generated {len(questions)} open-ended questions!")
+                        
+                        # Display questions
+                        for i, q in enumerate(questions, 1):
+                            st.subheader(f"Question {i}: {q['question']}")
+                            
+                            # Reveal answer
+                            with st.expander("Reveal Answer"):
+                                st.write(f"Suggested Answer: {q['answer']}")
+                                st.write(f"Context: {q['context']}")
+                                
+                            st.divider()
+                    else:
+                        st.error("Failed to generate questions. Try with different content.")
+    else:
+        st.info("Please provide content or select a source to generate a quiz.")
+    
+    # Footer
+    st.sidebar.divider()
+    st.sidebar.caption("QuizWhiz - Powered by AI")
+    st.sidebar.caption("© 2025 QuizWhiz Technologies")
+
+if __name__ == "__main__":
+    create_streamlit_app()