app.py

import gradio as gr
import PyPDF2
import docx
from openai import OpenAI
import io
import json
import time
from typing import List, Dict, Any, Optional
import spaces

# Global variables to store API key and document text
API_KEY = ""
DOCUMENT_TEXT = ""
MODEL = "google/gemma-3-27b-it:free"

def setup_client(api_key: str):
    """Initialize and test API key"""
    global API_KEY
    try:
        # Test the API key by creating a client and making a simple request
        client = OpenAI(
            base_url="https://openrouter.ai/api/v1",
            api_key=api_key,
        )
        # Store the API key globally
        API_KEY = api_key
        return "✅ API Key configured successfully!"
    except Exception as e:
        return f"❌ Error configuring API: {str(e)}"

def create_client() -> Optional[OpenAI]:
    """Create OpenAI client with stored API key"""
    if not API_KEY:
        return None
    return OpenAI(
        base_url="https://openrouter.ai/api/v1",
        api_key=API_KEY,
    )

def extract_text_from_pdf(file_path: str) -> str:
    """Extract text from PDF file"""
    try:
        with open(file_path, 'rb') as file:
            pdf_reader = PyPDF2.PdfReader(file)
            text = ""
            for page in pdf_reader.pages:
                text += page.extract_text() + "\n"
            return text
    except Exception as e:
        return f"Error reading PDF: {str(e)}"

def extract_text_from_docx(file_path: str) -> str:
    """Extract text from DOCX file"""
    try:
        doc = docx.Document(file_path)
        text = ""
        for paragraph in doc.paragraphs:
            text += paragraph.text + "\n"
        return text
    except Exception as e:
        return f"Error reading DOCX: {str(e)}"

@spaces.GPU
def process_document(file):
    """Process uploaded document and extract text"""
    global DOCUMENT_TEXT
    
    if file is None:
        DOCUMENT_TEXT = ""  # Reset if no file
        return "❌ No file uploaded"
    
    try:
        file_path = file.name
        file_extension = file_path.lower().split('.')[-1]
        
        if file_extension == 'pdf':
            extracted_text = extract_text_from_pdf(file_path)
        elif file_extension in ['docx', 'doc']:
            extracted_text = extract_text_from_docx(file_path)
        else:
            DOCUMENT_TEXT = ""  # Reset on unsupported format
            return "❌ Unsupported file format. Please upload PDF or DOCX files."
        
        # Check if extraction was successful
        if extracted_text.startswith("Error"):
            DOCUMENT_TEXT = ""  # Reset on error
            return extracted_text
        
        # Set the global variable
        DOCUMENT_TEXT = extracted_text.strip()
        
        if DOCUMENT_TEXT and len(DOCUMENT_TEXT) > 0:
            word_count = len(DOCUMENT_TEXT.split())
            preview = DOCUMENT_TEXT[:200] + "..." if len(DOCUMENT_TEXT) > 200 else DOCUMENT_TEXT
            return f"✅ Document processed successfully!\n📄 Word count: {word_count}\n📝 Preview: {preview}"
        else:
            DOCUMENT_TEXT = ""  # Reset if no text extracted
            return "❌ Could not extract text from the document. The document might be empty or contain only images."
            
    except Exception as e:
        DOCUMENT_TEXT = ""  # Reset on any error
        return f"❌ Error processing document: {str(e)}"

@spaces.GPU
def generate_content(prompt: str, max_tokens: int = 2000) -> str:
    """Generate content using the AI model"""
    global DOCUMENT_TEXT
    
    if not API_KEY:
        return "❌ Please configure your API key first"
    
    if not DOCUMENT_TEXT or len(DOCUMENT_TEXT.strip()) == 0:
        return "❌ Please upload and process a document first. Make sure the document contains readable text."
    
    try:
        client = create_client()
        if not client:
            return "❌ Failed to create API client"
            
        completion = client.chat.completions.create(
            extra_headers={
                "HTTP-Referer": "https://educational-assistant.app",
                "X-Title": "Educational Content Creator",
            },
            model=MODEL,
            messages=[
                {
                    "role": "system",
                    "content": "You are an expert educational content creator. Create comprehensive, engaging, and pedagogically sound educational materials based on the provided document content."
                },
                {
                    "role": "user",
                    "content": f"Document Content:\n{DOCUMENT_TEXT}\n\n{prompt}"
                }
            ],
            max_tokens=max_tokens,
            temperature=0.7
        )
        return completion.choices[0].message.content
    except Exception as e:
        return f"❌ Error generating content: {str(e)}"

@spaces.GPU
def generate_summary():
    """Generate comprehensive summary"""
    prompt = """Create a comprehensive summary of this document with the following structure:
    
    ## 📋 Executive Summary
    Provide a brief overview in 2-3 sentences.
    
    ## 🎯 Key Points
    List the main concepts, ideas, or arguments presented.
    
    ## 📚 Detailed Summary
    Provide a thorough summary organized by topics or sections.
    
    ## 💡 Important Takeaways
    Highlight the most crucial information students should remember.
    """
    return generate_content(prompt)

@spaces.GPU
def generate_study_notes():
    """Generate structured study notes"""
    prompt = """Create comprehensive study notes from this document with:
    
    ## 📖 Study Notes
    
    ### 🔑 Key Concepts
    - Define important terms and concepts
    - Explain their significance
    
    ### 📊 Main Topics
    Organize content into clear sections with:
    - Topic headings
    - Key points under each topic
    - Supporting details and examples
    
    ### 🧠 Memory Aids
    - Create mnemonics for complex information
    - Suggest visualization techniques
    - Provide connection points between concepts
    
    ### ⚡ Quick Review Points
    - Bullet points for rapid review
    - Essential facts and figures
    """
    return generate_content(prompt)

@spaces.GPU
def generate_quiz():
    """Generate quiz questions"""
    prompt = """Create a comprehensive quiz based on this document:
    
    ## 📝 Quiz Questions
    
    ### Multiple Choice Questions (5 questions)
    For each question, provide:
    - Clear question
    - 4 options (A, B, C, D)
    - Correct answer
    - Brief explanation
    
    ### Short Answer Questions (5 questions)
    - Questions requiring 2-3 sentence answers
    - Cover key concepts and applications
    
    ### Essay Questions (2 questions)
    - Thought-provoking questions requiring detailed responses
    - Focus on analysis, synthesis, or evaluation
    
    ### Answer Key
    Provide all correct answers with explanations.
    """
    return generate_content(prompt, max_tokens=3000)

@spaces.GPU
def generate_flashcards():
    """Generate flashcards"""
    prompt = """Create 15-20 flashcards based on this document:
    
    ## 🎴 Flashcards
    
    Format each flashcard as:
    **Card X:**
    **Front:** [Question/Term]
    **Back:** [Answer/Definition/Explanation]
    
    Include flashcards for:
    - Key terms and definitions
    - Important concepts
    - Facts and figures
    - Cause and effect relationships
    - Applications and examples
    
    Make questions clear and answers comprehensive but concise.
    """
    return generate_content(prompt, max_tokens=2500)

@spaces.GPU
def generate_mind_map():
    """Generate mind map structure"""
    prompt = """Create a detailed mind map structure for this document:
    
    ## 🧠 Mind Map Structure
    
    **Central Topic:** [Main subject of the document]
    
    ### Primary Branches:
    For each main topic, create branches with:
    - **Branch 1:** [Topic Name]
      - Sub-branch 1.1: [Subtopic]
        - Detail 1.1.1
        - Detail 1.1.2
      - Sub-branch 1.2: [Subtopic]
        - Detail 1.2.1
        - Detail 1.2.2
    
    ### Connections:
    - Identify relationships between different branches
    - Note cross-references and dependencies
    - Highlight cause-effect relationships
    
    ### Visual Elements Suggestions:
    - Color coding recommendations
    - Symbol suggestions for different types of information
    - Emphasis techniques for key concepts
    """
    return generate_content(prompt)

@spaces.GPU
def generate_lesson_plan():
    """Generate lesson plan"""
    prompt = """Create a detailed lesson plan based on this document:
    
    ## 📚 Lesson Plan
    
    ### Learning Objectives
    By the end of this lesson, students will be able to:
    - [Specific, measurable objectives]
    
    ### Prerequisites
    - Required background knowledge
    - Recommended prior reading
    
    ### Lesson Structure (60 minutes)
    
    **Introduction (10 minutes)**
    - Hook/attention grabber
    - Learning objectives overview
    
    **Main Content (35 minutes)**
    - Key concepts presentation
    - Activities and examples
    - Discussion points
    
    **Practice & Application (10 minutes)**
    - Practice exercises
    - Real-world applications
    
    **Wrap-up & Assessment (5 minutes)**
    - Summary of key points
    - Quick assessment questions
    
    ### Materials Needed
    - List of required resources
    
    ### Assessment Methods
    - How to evaluate student understanding
    
    ### Homework/Extension Activities
    - Additional practice opportunities
    """
    return generate_content(prompt, max_tokens=2500)

@spaces.GPU
def generate_concept_explanations():
    """Generate detailed concept explanations"""
    prompt = """Provide detailed explanations of key concepts from this document:
    
    ## 🔍 Concept Deep Dive
    
    For each major concept, provide:
    
    ### Concept Name
    **Definition:** Clear, precise definition
    
    **Explanation:** Detailed explanation in simple terms
    
    **Examples:** Real-world examples and applications
    
    **Analogies:** Helpful comparisons to familiar concepts
    
    **Common Misconceptions:** What students often get wrong
    
    **Connection to Other Concepts:** How it relates to other topics
    
    **Practice Application:** Simple exercise or question
    
    ---
    
    Repeat this structure for all major concepts in the document.
    """
    return generate_content(prompt, max_tokens=3000)

@spaces.GPU
def generate_practice_problems():
    """Generate practice problems"""
    prompt = """Create practice problems based on this document:
    
    ## 💪 Practice Problems
    
    ### Beginner Level (5 problems)
    - Basic application of concepts
    - Direct recall and simple calculations
    - Step-by-step solutions provided
    
    ### Intermediate Level (5 problems)
    - Multi-step problems
    - Requires understanding of relationships
    - Guided solutions with explanations
    
    ### Advanced Level (3 problems)
    - Complex scenarios
    - Requires analysis and synthesis
    - Detailed solution strategies
    
    ### Challenge Problems (2 problems)
    - Extension beyond document content
    - Creative application
    - Multiple solution approaches
    
    **For each problem, include:**
    - Clear problem statement
    - Required formulas/concepts
    - Step-by-step solution
    - Common mistakes to avoid
    """
    return generate_content(prompt, max_tokens=3500)

def check_document_status():
    """Check if document is loaded"""
    global DOCUMENT_TEXT
    if DOCUMENT_TEXT and len(DOCUMENT_TEXT.strip()) > 0:
        word_count = len(DOCUMENT_TEXT.split())
        return f"✅ Document loaded ({word_count} words)"
    else:
        return "❌ No document loaded"

# Create Gradio interface
def create_interface():
    with gr.Blocks(title="📚 Educational Content Creator Assistant", theme=gr.themes.Soft()) as app:
        gr.Markdown("""
        # 📚 Educational Content Creator Assistant
        Transform your documents into comprehensive educational materials using AI!
        
        **Features:** Study Notes • Quizzes • Flashcards • Mind Maps • Lesson Plans • Practice Problems & More!
        
        *Powered by ZeroGPU for enhanced performance*
        """)
        
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 🔑 Setup")
                api_key = gr.Textbox(
                    label="OpenRouter API Key",
                    type="password",
                    placeholder="Enter your OpenRouter API key..."
                )
                setup_btn = gr.Button("🔧 Configure API", variant="primary")
                setup_status = gr.Textbox(label="Status", interactive=False)
                
                gr.Markdown("### 📄 Document Upload")
                file_upload = gr.File(
                    label="Upload Document (PDF or DOCX)",
                    file_types=[".pdf", ".docx", ".doc"]
                )
                process_btn = gr.Button("🔄 Process Document", variant="secondary")
                process_status = gr.Textbox(label="Processing Status", interactive=False)
                
                # Add document status indicator
                doc_status = gr.Textbox(label="Document Status", value="❌ No document loaded", interactive=False)
            
            with gr.Column(scale=2):
                gr.Markdown("### 🎯 Generate Educational Content")
                
                with gr.Row():
                    summary_btn = gr.Button("📋 Generate Summary", variant="primary")
                    notes_btn = gr.Button("📖 Study Notes", variant="primary")
                    quiz_btn = gr.Button("📝 Create Quiz", variant="primary")
                
                with gr.Row():
                    flashcards_btn = gr.Button("🎴 Flashcards", variant="secondary")
                    mindmap_btn = gr.Button("🧠 Mind Map", variant="secondary")
                    lesson_btn = gr.Button("📚 Lesson Plan", variant="secondary")
                
                with gr.Row():
                    concepts_btn = gr.Button("🔍 Concept Explanations", variant="secondary")
                    problems_btn = gr.Button("💪 Practice Problems", variant="secondary")
                
                output = gr.Textbox(
                    label="Generated Content",
                    lines=20,
                    max_lines=30,
                    placeholder="Generated educational content will appear here...",
                    show_copy_button=True
                )
        
        gr.Markdown("""
        ### 📋 How to Use:
        1. **Get API Key:** Sign up at [OpenRouter](https://openrouter.ai/) and get your API key
        2. **Configure:** Enter your API key and click "Configure API"
        3. **Upload:** Upload a PDF or DOCX document
        4. **Process:** Click "Process Document" to extract text
        5. **Generate:** Choose any educational content type to generate
        
        ### 🎯 Content Types:
        - **Summary:** Comprehensive overview with key points
        - **Study Notes:** Structured notes with key concepts and memory aids
        - **Quiz:** Multiple choice, short answer, and essay questions
        - **Flashcards:** Question-answer pairs for memorization
        - **Mind Map:** Visual structure of document concepts
        - **Lesson Plan:** Complete teaching plan with objectives and activities
        - **Concept Explanations:** Deep dive into key concepts with examples
        - **Practice Problems:** Graded exercises from beginner to advanced
        
        ### ⚡ Performance Note:
        This app uses ZeroGPU for enhanced processing. Functions will automatically utilize GPU resources when needed.
        """)
        
        # Event handlers
        setup_btn.click(
            setup_client,
            inputs=[api_key],
            outputs=[setup_status]
        )
        
        def process_and_update_status(file):
            result = process_document(file)
            status = check_document_status()
            return result, status
        
        process_btn.click(
            process_and_update_status,
            inputs=[file_upload],
            outputs=[process_status, doc_status]
        )
        
        summary_btn.click(
            generate_summary,
            outputs=[output]
        )
        
        notes_btn.click(
            generate_study_notes,
            outputs=[output]
        )
        
        quiz_btn.click(
            generate_quiz,
            outputs=[output]
        )
        
        flashcards_btn.click(
            generate_flashcards,
            outputs=[output]
        )
        
        mindmap_btn.click(
            generate_mind_map,
            outputs=[output]
        )
        
        lesson_btn.click(
            generate_lesson_plan,
            outputs=[output]
        )
        
        concepts_btn.click(
            generate_concept_explanations,
            outputs=[output]
        )
        
        problems_btn.click(
            generate_practice_problems,
            outputs=[output]
        )
        
        # Update document status when page loads
        app.load(
            check_document_status,
            outputs=[doc_status]
        )
    
    return app

# Launch the application
if __name__ == "__main__":
    app = create_interface()
    app.launch()