app.py

import os
import pandas as pd
from pdf2image import convert_from_path
import pytesseract
import tempfile
import io
import gradio as gr
import google.generativeai as genai
from typing import List, Tuple
import time
import csv

# Configure Gemini API
def configure_gemini_api(api_key: str):
    """Configure the Gemini API with the provided key"""
    genai.configure(api_key=api_key)
    return "✅ API Key configured successfully!"

def extract_text_from_pdf(pdf_file_path: str) -> str:
    """Extract text from PDF using OCR"""
    try:
        # Convert PDF to images
        pages = convert_from_path(pdf_file_path)
        all_text = ""
        
        for i, page in enumerate(pages):
            text = pytesseract.image_to_string(page)
            all_text += text + "\n"
        
        return all_text
    except Exception as e:
        return f"Error extracting text: {str(e)}"

def chunk_text(text: str, chunk_size: int = 500) -> List[str]:  # Changed default to 500 for more chunks/MCQs
    """Split text into chunks for processing"""
    words = text.split()
    chunks = []
    for i in range(0, len(words), chunk_size):
        chunks.append(' '.join(words[i:i+chunk_size]))
    return chunks

def generate_mcqs_from_chunk(chunk: str, api_key: str, chunk_number: int = 1, mcqs_per_chunk: int = 20) -> List[List[str]]:  # Added mcqs_per_chunk param, default 20
    """Generate MCQs from a text chunk using Gemini API"""
    print(f"\n=== PROCESSING CHUNK {chunk_number} ===")
    print(f"Chunk length: {len(chunk)} characters")
    print(f"Chunk preview: {chunk[:200]}...")
    
    models_to_try = [
        'gemini-2.0-flash-exp',
        'gemini-1.5-flash',
        'gemini-1.5-pro'
    ]
    
    prompt = f"""
    Generate exactly {mcqs_per_chunk} multiple choice questions from the following text.
    Each question must have:
    - A clear, specific question
    - 4 options labeled A, B, C, D
    - One correct answer (A, B, C, or D)
    
    IMPORTANT: Do NOT include any headers or column names in your response.
    Format each question as: Question,OptionA,OptionB,OptionC,OptionD,CorrectAnswer
    
    Rules:
    - Start directly with the first question, no headers
    - Use commas only as field separators
    - If any field contains a comma, wrap it in double quotes
    - Each question should be on a new line
    - Make questions specific and clear based on the text content
    - Ensure all 4 options are plausible but only one is correct
    - The correct answer should be A, B, C, or D only
    
    Text to analyze:
    {chunk}
    """
    
    # Configure API
    genai.configure(api_key=api_key)
    
    mcq_data = []
    response = None
    
    for model_name in models_to_try:
        try:
            print(f"Trying model: {model_name}")
            model = genai.GenerativeModel(model_name)
            response = model.generate_content(prompt)
            
            if response.text:
                print(f"✅ Successfully used model: {model_name}")
                break
        except Exception as e:
            print(f"❌ Error with {model_name}: {e}")
            continue
    
    if response and response.text:
        output = response.text.strip()
        print(f"\n--- RAW AI RESPONSE FOR CHUNK {chunk_number} ---")
        print(output)
        print("--- END RAW RESPONSE ---\n")
        
        lines = [line.strip() for line in output.splitlines() if line.strip()]
        print(f"Total non-empty lines in response: {len(lines)}")
        
        for idx, line in enumerate(lines):
            print(f"Processing line {idx + 1}: {line[:100]}...")
            
            # Skip any header lines that might still appear
            if ('Question' in line and 'OptionA' in line and 'OptionB' in line) or line.startswith('Question,'):
                print(f"❌ Skipped header line: {line[:50]}...")
                continue
            
            # Skip empty lines or lines that don't look like MCQs
            if not line or line.count(',') < 5:
                print(f"❌ Skipped invalid line (comma count: {line.count(',')}): {line[:50]}...")
                continue
            
            # Parse CSV line using proper CSV parsing
            try:
                # Use StringIO to parse the line as CSV
                csv_reader = csv.reader([line])
                parts = next(csv_reader)
                print(f"Parsed parts: {len(parts)} fields")
                
                # Ensure we have exactly 6 parts and the question is not empty
                if len(parts) >= 6 and parts[0].strip() and not parts[0].lower().startswith('question'):
                    # Clean up each part
                    cleaned_parts = [part.strip() for part in parts[:6]]
                    # Validate that correct answer is A, B, C, or D
                    if cleaned_parts[5].upper() in ['A', 'B', 'C', 'D']:
                        mcq_data.append(cleaned_parts)
                        print(f"✅ Added MCQ: {cleaned_parts[0][:50]}... (Answer: {cleaned_parts[5]})")
                    else:
                        print(f"❌ Invalid answer format: {cleaned_parts[5]}")
                else:
                    print(f"❌ Invalid parts count or empty question. Parts: {len(parts)}, First part: '{parts[0] if parts else 'N/A'}'")
                        
            except csv.Error as e:
                print(f"❌ CSV parsing error: {e}")
                # Fallback to simple split if CSV parsing fails
                parts = line.split(',')
                if len(parts) >= 6 and parts[0].strip() and not parts[0].lower().startswith('question'):
                    cleaned_parts = [part.strip().strip('"') for part in parts[:6]]
                    if cleaned_parts[5].upper() in ['A', 'B', 'C', 'D']:
                        mcq_data.append(cleaned_parts)
                        print(f"✅ Added MCQ (fallback): {cleaned_parts[0][:50]}...")
                    else:
                        print(f"❌ Invalid answer format (fallback): {cleaned_parts[5]}")
    else:
        print(f"❌ No response received for chunk {chunk_number}")
    
    print(f"Generated {len(mcq_data)} MCQs from chunk {chunk_number}")
    return mcq_data

def process_pdf_to_mcqs(pdf_file, api_key: str, chunk_size: int = 500, mcqs_per_chunk: int = 20, progress=gr.Progress()) -> Tuple[str, str]:  # Added mcqs_per_chunk param, default 20
    """Main function to process PDF and generate MCQs"""
    if not api_key:
        return "❌ Please provide your Gemini API key", None
    
    if not pdf_file:
        return "❌ Please upload a PDF file", None
    
    try:
        # Extract text from PDF
        progress(0.1, desc="Extracting text from PDF...")
        extracted_text = extract_text_from_pdf(pdf_file.name)
        
        if extracted_text.startswith("Error"):
            return extracted_text, None
        
        # Chunk the text
        progress(0.2, desc="Chunking text...")
        chunks = chunk_text(extracted_text, chunk_size)
        
        if not chunks:
            return "❌ No text could be extracted from the PDF", None
        
        # Generate MCQs from each chunk
        all_mcq_data = []
        total_chunks = len(chunks)
        
        for i, chunk in enumerate(chunks):
            progress((0.2 + (i / total_chunks) * 0.7), desc=f"Processing chunk {i+1}/{total_chunks}...")
            
            chunk_mcqs = generate_mcqs_from_chunk(chunk, api_key, i+1, mcqs_per_chunk)
            all_mcq_data.extend(chunk_mcqs)
            
            # Reduced delay to 0.5s for faster processing (to maximize MCQs, but monitor rate limits)
            time.sleep(0.5)
        
        progress(0.95, desc="Creating Excel file...")
        
        if not all_mcq_data:
            return "❌ No MCQs could be generated from the PDF content", None
        
        # Remove any duplicate questions
        seen_questions = set()
        unique_mcq_data = []
        for mcq in all_mcq_data:
            question_text = mcq[0].lower().strip()
            if question_text not in seen_questions:
                seen_questions.add(question_text)
                unique_mcq_data.append(mcq)
        
        # Create DataFrame
        df = pd.DataFrame(unique_mcq_data, columns=['Question', 'OptionA', 'OptionB', 'OptionC', 'OptionD', 'CorrectAnswer'])
        
        # Create temporary Excel file for download
        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx', mode='wb')
        temp_file.close()  # Close to allow pandas to write to it
        
        # Write Excel file
        with pd.ExcelWriter(temp_file.name, engine='openpyxl') as writer:
            df.to_excel(writer, index=False, sheet_name='MCQs')
        
        progress(1.0, desc="Complete!")
        
        success_message = f"✅ Successfully generated {len(unique_mcq_data)} unique MCQs from {total_chunks} text chunks ({mcqs_per_chunk} targeted per chunk)!"
        
        return success_message, temp_file.name
        
    except Exception as e:
        return f"❌ Error processing PDF: {str(e)}", None

# Create Gradio interface
def create_interface():
    with gr.Blocks(title="PDF to MCQ Generator", theme=gr.themes.Soft()) as demo:
        gr.Markdown(
            """
            # 📚 PDF to MCQ Generator
            
            Upload a PDF document and generate multiple choice questions automatically using Google's Gemini AI.
            
            ## How to use:
            1. Get your Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey)
            2. Enter your API key below
            3. Upload your PDF file
            4. Adjust chunk size if needed (smaller = more chunks/MCQs, but slower; default 500 for max MCQs)
            5. Adjust MCQs per chunk (higher = more MCQs per chunk, but may hit API limits; default 20 for max)
            6. Click "Generate MCQs" and wait for processing
            7. Download the generated Excel file with your MCQs
            """
        )
        
        with gr.Row():
            with gr.Column(scale=2):
                api_key_input = gr.Textbox(
                    label="🔑 Gemini API Key",
                    placeholder="Enter your Gemini API key here...",
                    type="password"
                )
                
                pdf_input = gr.File(
                    label="📄 Upload PDF File",
                    file_types=[".pdf"]
                )
                
                chunk_size_input = gr.Slider(
                    minimum=300,  # Lowered min to allow even smaller chunks
                    maximum=3000,
                    value=500,  # Changed default to 500 for more chunks
                    step=100,
                    label="📝 Chunk Size (words per processing batch)"
                )
                
                mcqs_per_chunk_input = gr.Slider(
                    minimum=5,
                    maximum=50,  # Increased max for more MCQs per chunk
                    value=20,  # New slider for MCQs per chunk, default 20
                    step=5,
                    label="🔢 MCQs per Chunk (higher = more MCQs, but may increase failures)"
                )
                
                generate_btn = gr.Button(
                    "🚀 Generate MCQs",
                    variant="primary",
                    size="lg"
                )
            
            with gr.Column(scale=1):
                status_output = gr.Textbox(
                    label="📊 Status",
                    placeholder="Status updates will appear here...",
                    lines=10
                )
                
                download_file = gr.File(
                    label="⬇️ Download MCQs Excel File",
                    visible=False
                )
        
        # Event handlers
        generate_btn.click(
            fn=process_pdf_to_mcqs,
            inputs=[pdf_input, api_key_input, chunk_size_input, mcqs_per_chunk_input],
            outputs=[status_output, download_file],
            show_progress=True
        ).then(
            fn=lambda file_path: gr.update(visible=bool(file_path)) if file_path else gr.update(visible=False),
            inputs=[download_file],
            outputs=[download_file]
        )
        
        gr.Markdown(
            """
            ## 📋 Features:
            - **OCR Text Extraction**: Converts PDF pages to images and extracts text
            - **Smart Chunking**: Breaks large documents into manageable pieces (smaller chunks = more MCQs)
            - **Configurable MCQs per Chunk**: Now adjustable up to 50 for maximum generation
            - **Multiple AI Models**: Automatically tries different Gemini models for best results
            - **Excel Output**: Download MCQs in a formatted Excel file
            - **Progress Tracking**: Real-time updates on processing status
            
            ## ⚠️ Notes:
            - To maximize MCQs: Use small chunk size (e.g., 300-500) and high MCQs per chunk (e.g., 20-50)
            - Processing time depends on PDF length and settings (more MCQs = longer time)
            - Large PDFs are processed in chunks to avoid timeouts
            - Make sure your PDF contains readable text (not just images)
            - API key is not stored and only used for your session
            - Reduced delay between API calls for faster processing, but monitor for rate limits
            """
        )
    
    return demo

# Launch the app
if __name__ == "__main__":
    demo = create_interface()
    demo.launch(server_name="0.0.0.0", server_port=7860)