Spaces:
Build error
Build error
| import gradio as gr | |
| import PyPDF2 | |
| import pdf2image | |
| import pytesseract | |
| from transformers import pipeline | |
| import logging | |
| import re | |
| import numpy as np | |
| from PIL import Image | |
| import io | |
| import random | |
| import os | |
| # Configure logging | |
| logging.basicConfig(level=logging.INFO, filename="quiz_game.log") | |
| logger = logging.getLogger(__name__) | |
| # Initialize models | |
| try: | |
| question_generator = pipeline("text2text-generation", model="t5-small", device=-1) | |
| except Exception as e: | |
| logger.error(f"Failed to load T5 model: {str(e)}") | |
| question_generator = None | |
| try: | |
| ocr_pipeline = pipeline("image-to-text", model="microsoft/trocr-small-printed", device=-1) | |
| except Exception as e: | |
| logger.error(f"Failed to load OCR model: {str(e)}") | |
| ocr_pipeline = None | |
| # Global state | |
| questions = [] | |
| current_question = 0 | |
| score = 0 | |
| game_state = {"questions": [], "current_question": 0, "score": 0} | |
| def extract_text_from_pdf(pdf_file): | |
| """Extract text from a PDF using PyPDF2, with OCR as fallback for scanned PDFs.""" | |
| try: | |
| # Handle Gradio file input | |
| if isinstance(pdf_file, str): # Gradio may pass file path | |
| with open(pdf_file, "rb") as f: | |
| pdf_bytes = f.read() | |
| else: # Assume file-like object with content | |
| pdf_bytes = pdf_file # Gradio passes bytes directly | |
| # Try PyPDF2 for text-based PDFs | |
| pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_bytes)) | |
| text = "" | |
| for page in pdf_reader.pages: | |
| page_text = page.extract_text() | |
| if page_text: | |
| text += page_text + "\n" | |
| if text.strip(): | |
| return text.strip() | |
| # Fallback to OCR for scanned PDFs | |
| if not ocr_pipeline: | |
| return "OCR model unavailable. Please use a text-based PDF." | |
| images = pdf2image.convert_from_bytes(pdf_bytes) | |
| ocr_text = "" | |
| for image in images: | |
| ocr_result = ocr_pipeline(image)[0]["generated_text"] | |
| ocr_text += ocr_result + "\n" | |
| return ocr_text.strip() if ocr_text.strip() else "No text extracted from scanned PDF." | |
| except Exception as e: | |
| logger.error(f"PDF text extraction error: {str(e)}") | |
| return f"Error: {str(e)}" | |
| def generate_questions(text, num_questions=5): | |
| """Generate multiple-choice questions from text using T5.""" | |
| if not question_generator: | |
| return [{"question": "Question generation unavailable.", "options": [], "correct": ""}] | |
| try: | |
| questions = [] | |
| chunks = [text[i:i+500] for i in range(0, len(text), 500)] | |
| for _ in range(min(num_questions, len(chunks))): | |
| chunk = random.choice(chunks) | |
| prompt = f"Generate a multiple-choice question with 4 options based on this text: {chunk}" | |
| result = question_generator(prompt, max_length=200)[0]["generated_text"] | |
| question_match = re.search(r"(.*?)\?(\s*a\)\s*(.*?)\s*b\)\s*(.*?)\s*c\)\s*(.*?)\s*d\)\s*(.*?)$", result, re.DOTALL) | |
| if question_match: | |
| question = question_match.group(1).strip() + "?" | |
| options = [ | |
| question_match.group(3).strip(), | |
| question_match.group(4).strip(), | |
| question_match.group(5).strip(), | |
| question_match.group(6).strip() | |
| ] | |
| correct = random.choice(options) | |
| questions.append({"question": question, "options": options, "correct": correct}) | |
| return questions if questions else [{"question": "No questions generated.", "options": [], "correct": ""}] | |
| except Exception as e: | |
| logger.error(f"Question generation error: {str(e)}") | |
| return [{"question": f"Error: {str(e)}", "options": [], "correct": ""}] | |
| def start_game(pdf_file): | |
| """Start a new game by generating questions from the PDF.""" | |
| global questions, current_question, score, game_state | |
| text = extract_text_from_pdf(pdf_file) | |
| if "Error" in text or "unavailable" in text or "No text extracted" in text: | |
| return text, "", [], "", 0 | |
| questions = generate_questions(text, num_questions=5) | |
| current_question = 0 | |
| score = 0 | |
| game_state = {"questions": questions, "current_question": 0, "score": 0} | |
| if not questions or not questions[0]["options"]: | |
| return "Failed to generate questions.", "", [], "", 0 | |
| question = questions[0]["question"] | |
| options = questions[0]["options"] | |
| return "Game started!", question, options, "", score | |
| def answer_question(selected_option): | |
| """Handle answer submission and game logic.""" | |
| global current_question, score, game_state | |
| if current_question >= len(questions) or not questions: | |
| return "Game over!", "", [], "Start a new game.", score | |
| current = questions[current_question] | |
| correct_answer = current["correct"] | |
| if selected_option == correct_answer: | |
| score += 100 | |
| current_question += 1 | |
| game_state["current_question"] = current_question | |
| game_state["score"] = score | |
| if current_question < len(questions): | |
| next_question = questions[current_question]["question"] | |
| next_options = questions[current_question]["options"] | |
| return f"Correct! +100 points", next_question, next_options, "", score | |
| else: | |
| return "Congratulations! You completed the quiz!", "", [], "Start a new game.", score | |
| else: | |
| score = max(0, score - 50) | |
| current_question = 0 | |
| game_state["current_question"] = 0 | |
| game_state["score"] = score | |
| return f"Wrong! -50 points. Starting over.", questions[0]["question"], questions[0]["options"], "", score | |
| def restart_game(): | |
| """Restart the game manually.""" | |
| global current_question, score, game_state | |
| current_question = 0 | |
| score = 0 | |
| game_state["current_question"] = 0 | |
| game_state["score"] = 0 | |
| if questions: | |
| return "Game restarted!", questions[0]["question"], questions[0]["options"], "", score | |
| return "No questions available. Upload a PDF.", "", [], "", 0 | |
| # Gradio interface | |
| with gr.Blocks(css=".gradio-container {font-family: 'Comic Sans MS', Arial; background: #f0f8ff;} h1 {color: #ff4500; text-align: center;}") as demo: | |
| gr.Markdown("# Quiz Planet: AI-Powered PDF Quiz Game") | |
| gr.Markdown("Upload a PDF to generate a quiz. Answer correctly to advance (+100 points), or restart on wrong answers (-50 points).") | |
| with gr.Tabs(): | |
| with gr.Tab("Upload PDF"): | |
| pdf_input = gr.File(label="Upload PDF", file_types=[".pdf"]) | |
| upload_button = gr.Button("Generate Quiz") | |
| upload_status = gr.Textbox(label="Status") | |
| upload_button.click(start_game, pdf_input, [upload_status, gr.Textbox(label="Question"), gr.Radio(label="Options"), gr.Textbox(label="Feedback"), gr.Textbox(label="Score")]) | |
| with gr.Tab("Play Quiz"): | |
| question_display = gr.Textbox(label="Question") | |
| options_radio = gr.Radio(label="Options", choices=[]) | |
| feedback_display = gr.Textbox(label="Feedback") | |
| score_display = gr.Textbox(label="Score", value="0") | |
| answer_button = gr.Button("Submit Answer") | |
| restart_button = gr.Button("Restart Game") | |
| answer_button.click(answer_question, options_radio, [feedback_display, question_display, options_radio, gr.Textbox(label="Feedback"), score_display]) | |
| restart_button.click(restart_game, None, [feedback_display, question_display, options_radio, gr.Textbox(label="Feedback"), score_display]) | |
| if __name__ == "__main__": | |
| demo.launch() |