app.py

import os
import gradio as gr
from anthropic import Anthropic
from datetime import datetime, timedelta
from collections import deque
import random
import logging
import tempfile
from pathlib import Path
from sympy import *

# Set up logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Initialize Anthropic client
anthropic = Anthropic(
    api_key=os.environ.get('ANTHROPIC_API_KEY')
)

# Request tracking
MAX_REQUESTS_PER_DAY = 25
request_history = deque(maxlen=1000)

def get_difficulty_parameters(difficulty_level):
    """Return specific parameters and constraints based on difficulty level"""
    parameters = {
        1: {  # Very Easy
            "description": "very easy, suitable for beginners",
            "constraints": [
                "Use only basic concepts and straightforward calculations",
                "Break complex problems into smaller, guided steps",
                "Provide hints within the question when needed",
                "Use simple numbers and avoid complex algebraic expressions"
            ],
            "example_style": "Similar to standard homework problems",
            "model": "claude-3-5-sonnet-20241022"
        },
        2: {  # Easy
            "description": "easy, but requiring some thought",
            "constraints": [
                "Use basic concepts with minor complications",
                "Include two-step problems",
                "Minimal guidance provided",
                "Use moderately complex numbers or expressions"
            ],
            "example_style": "Similar to quiz questions",
            "model": "claude-3-5-sonnet-20241022"
        },
        3: {  # Intermediate
            "description": "intermediate difficulty, testing deeper understanding",
            "constraints": [
                "Combine 2-3 related concepts",
                "Include some non-obvious solution paths",
                "Require multi-step reasoning",
                "Use moderate algebraic complexity"
            ],
            "example_style": "Similar to midterm exam questions",
            "model": "claude-3-5-sonnet-20241022"
        },
        4: {  # Difficult
            "description": "challenging, requiring strong mathematical maturity",
            "constraints": [
                "Combine multiple concepts creatively",
                "Require insight and deep understanding",
                "Include non-standard approaches",
                "Use sophisticated mathematical reasoning"
            ],
            "example_style": "Similar to final exam questions",
            "model": "claude-3-5-sonnet-20241022"
        },
        5: {  # Very Difficult
            "description": "very challenging, testing mastery and creativity at a graduate level",
            "constraints": [
                "Create novel applications of theoretical concepts",
                "Require graduate-level mathematical reasoning",
                "Combine multiple advanced topics in unexpected ways",
                "Demand creative problem-solving approaches",
                "Include rigorous proof construction",
                "Require synthesis across mathematical domains",
                "Test deep theoretical understanding"
            ],
            "example_style": "Similar to graduate qualifying exams or advanced competition problems",
            "model": "claude-3-5-sonnet-20241022"
        }
    }
    
    return parameters.get(difficulty_level)

def create_latex_document(content, questions_only=False):
    """Create a complete LaTeX document"""
    try:
        latex_header = r"""\documentclass{article}
\usepackage{amsmath,amssymb}
\usepackage[margin=1in]{geometry}
\begin{document}
\title{Mathematics Question}
\maketitle
"""
        latex_footer = r"\end{document}"
        
        if questions_only:
            # Modified to handle single question
            processed_content = content.split('Solution:')[0]
            content = processed_content
        
        full_document = f"{latex_header}\n{content}\n{latex_footer}"
        logger.debug(f"Created {'questions-only' if questions_only else 'full'} LaTeX document")
        return full_document
    except Exception as e:
        logger.error(f"Error creating LaTeX document: {str(e)}")
        raise

def save_to_temp_file(content, filename):
    """Save content to a temporary file and return the path"""
    try:
        temp_dir = Path(tempfile.gettempdir()) / "math_test_files"
        temp_dir.mkdir(exist_ok=True)
        file_path = temp_dir / filename
        file_path.write_text(content, encoding='utf-8')
        logger.debug(f"Saved content to temporary file: {file_path}")
        return str(file_path)
    except Exception as e:
        logger.error(f"Error saving temporary file: {str(e)}")
        raise

def get_problem_type_addition(question_type):
    """Return specific requirements based on problem type"""
    problem_type_additions = {
        "application": """
The application question MUST:
- Present a real-world scenario or practical problem
- Require modeling the situation mathematically
- Connect abstract mathematical concepts to concrete situations
- Include realistic context and data
- Require students to:
    1. Identify relevant mathematical concepts
    2. Translate the practical problem into mathematical terms
    3. Solve using appropriate mathematical techniques
    4. Interpret the results in the context of the original problem

Example contexts might include:
- Physics applications (motion, forces, work)
- Engineering scenarios (optimization, rates of change)
- Economics problems (cost optimization, growth models)
- Biological systems (population growth, reaction rates)
- Business applications (profit maximization, inventory management)
- Social science applications (demographic models, social network analysis)
- Data science applications (regression, statistical analysis)
""",
        "proof": """
The proof question MUST:
- Require a formal mathematical proof
- Focus on demonstrating logical reasoning
- Require justification for each step
- Emphasize theoretical understanding

The proof question MAY NOT:
- Include Real-world applications or scenarios
- Include Pure computation problems
- Ask only for numerical answers
""",
        "computation": """
The computation question MUST:
- Require specific algebraic calculations
- Focus on mathematical techniques
- Have concrete answers in the form of algebraic expressions (about half of questions) or numbers (about half of questions)
- Test procedural knowledge

The computation question MAY NOT:
- Include extended real-world applications or scenarios
- Ask for a proof
"""
    }
    return problem_type_additions.get(question_type, "")

def generate_question(subject, difficulty, question_type):
    """Generate a single math question"""
    try:
        if not os.environ.get('ANTHROPIC_API_KEY'):
            logger.error("Anthropic API key not found")
            return "Error: Anthropic API key not configured", None, None
        
        logger.debug(f"Generating {question_type} question for subject: {subject} at difficulty level: {difficulty}")
        
        # Check rate limit
        now = datetime.now()
        while request_history and (now - request_history[0]) > timedelta(days=1):
            request_history.popleft()
        if len(request_history) >= MAX_REQUESTS_PER_DAY:
            return "Daily request limit reached. Please try again tomorrow.", None, None
        
        request_history.append(now)
        
        topics = {
            "Single Variable Calculus": ["limits", "derivatives", "integrals", "series", "applications"],
            "Multivariable Calculus": ["partial derivatives", "multiple integrals", "vector fields", "optimization"],
            "Linear Algebra": ["matrices", "vector spaces", "eigenvalues", "linear transformations"],
            "Differential Equations": ["first order equations", "second order equations", "systems", "stability analysis"],
            "Real Analysis": ["sequences", "series", "continuity", "differentiation", "integration"],
            "Complex Analysis": ["complex functions", "analyticity", "contour integration", "residues"],
            "Abstract Algebra": ["groups", "rings", "fields", "homomorphisms"],
            "Probability Theory": ["probability spaces", "random variables", "distributions", "limit theorems"],
            "Numerical Analysis": ["approximation", "interpolation", "numerical integration", "error analysis"],
            "Topology": ["metric spaces", "continuity", "compactness", "connectedness"]
        }
        
        selected_topic = random.choice(topics.get(subject, ["general"]))
        logger.debug(f"Selected topic: {selected_topic}")
        
        difficulty_params = get_difficulty_parameters(difficulty)
        problem_type_addition = get_problem_type_addition(question_type)

        if difficulty == 5:
            system_prompt = f"""You are an expert mathematics professor creating a graduate-level exam question.
STRICT REQUIREMENTS:
1. Write exactly 1 graduate-level {question_type} question on {subject} covering {selected_topic}.
2. Advanced Difficulty Requirements:
   This question must be suitable for PhD qualifying exams or advanced competitions.
   MUST include:
   - Novel applications of theoretical concepts
   - Graduate-level mathematical reasoning
   - Unexpected connections between different areas of {subject}
   - Creative problem-solving approaches
   - Rigorous proof requirements where applicable
   
   Follow these specific constraints:
   {chr(10).join(f'   - {c}' for c in difficulty_params['constraints'])}
   
   {problem_type_addition}

3. Style Reference:
   Question should be {difficulty_params['example_style']}
4. The question MUST:
   - Bridge multiple mathematical domains
   - Require deep theoretical understanding
   - Test mastery of advanced concepts
   - Demand innovative solution approaches
5. For LaTeX formatting:
   - Use $ for inline math
   - Use $$ on separate lines for equations and solutions
   - Put each solution step on its own line in $$ $$
   - DO NOT use \\begin{{aligned}} or similar environments
6. Include a detailed solution with thorough explanations of advanced concepts used
7. Maintain clear, precise formatting
8. At the end of the LaTeX solution output, print SymPy code that you would use to solve or verify the main equations in the question. """
        else:
            system_prompt = f"""You are an expert mathematics professor creating a {difficulty_params['description']} exam question.
STRICT REQUIREMENTS:
1. Write exactly 1 {question_type} question on {subject} covering {selected_topic}.
2. Difficulty Level Guidelines:
   {difficulty_params['description'].upper()}
   Follow these specific constraints:
   {chr(10).join(f'   - {c}' for c in difficulty_params['constraints'])}
   
   {problem_type_addition}

3. Style Reference:
   Question should be {difficulty_params['example_style']}
4. For LaTeX formatting:
   - Use $ for inline math
   - Use $$ on separate lines for equations and solutions
   - Put each solution step on its own line in $$ $$
   - DO NOT use \\begin{{aligned}} or similar environments
5. Include a detailed solution
6. Maintain clear formatting
7. At the end of the LaTeX solution output, print SymPy code that you would use to solve or verify the main equations in the question."""
        
        logger.debug("Sending request to Anthropic API")
        message = anthropic.messages.create(
            model=difficulty_params['model'],
            max_tokens=4096,
            temperature=0.7,
            messages=[{
                "role": "user",
                "content": f"{system_prompt}\n\nWrite a question for {subject}."
            }]
        )
        
        if not hasattr(message, 'content') or not message.content:
            logger.error("No content received from Anthropic API")
            return "Error: No content received from API", None, None
        
        response_text = message.content[0].text
        logger.debug("Successfully received response from Anthropic API")

        # Execute SymPy code and append results
        sympy_output = extract_and_run_sympy_code(response_text)
        if sympy_output:
            response_text += "\n\nSymPy Verification Results:\n```\n" + sympy_output + "```"
        
        # Then continue with the existing code:
        # Create LaTeX content
        questions_latex = create_latex_document(response_text, questions_only=True)
        full_latex = create_latex_document(response_text, questions_only=False)
        
        # Create LaTeX content
        questions_latex = create_latex_document(response_text, questions_only=True)
        full_latex = create_latex_document(response_text, questions_only=False)
        
        # Save to temporary files
        questions_path = save_to_temp_file(questions_latex, "question.tex")
        full_path = save_to_temp_file(full_latex, "full_question.tex")
        
        logger.debug("Successfully created temporary files")
        
        return response_text, questions_path, full_path
            
    except Exception as e:
        logger.error(f"Error generating question: {str(e)}")
        return f"Error: {str(e)}", None, None

def extract_and_run_sympy_code(response_text):
    """
    Extract SymPy code from the response and execute it.
    Returns only the essential calculation results as a string.
    Filters out debugging info and module imports.
    """
    try:
        # Find the SymPy code block
        sympy_start = response_text.find('```python')
        if sympy_start == -1:
            return "No SymPy code found in the response."
        
        # Extract the code (excluding the ```python and ``` markers)
        code_start = response_text.find('\n', sympy_start) + 1
        code_end = response_text.find('```', code_start)
        if code_end == -1:
            return "Malformed SymPy code block."
        
        sympy_code = response_text[code_start:code_end].strip()
        
        # Import necessary modules
        import io
        import sympy
        from contextlib import redirect_stdout

        # Create a string buffer to capture print output
        output_buffer = io.StringIO()
        
        # Create a clean globals dict with only essential SymPy components
        sympy_globals = {
            "Symbol": sympy.Symbol,
            "symbols": sympy.symbols,
            "solve": sympy.solve,
            "integrate": sympy.integrate,
            "diff": sympy.diff,
            "limit": sympy.limit,
            "sqrt": sympy.sqrt,
            "simplify": sympy.simplify,
            "expand": sympy.expand
        }
        
        # Create locals dict to capture new variables
        local_vars = {}

        # Execute the code and capture output
        with redirect_stdout(output_buffer):
            exec(sympy_code, sympy_globals, local_vars)
        
        # Get the printed output
        printed_output = output_buffer.getvalue().strip()
        
        # Filter the local variables to only include calculation results
        # Exclude built-in variables, modules, and functions
        calculation_results = {
            name: value for name, value in local_vars.items()
            if (
                not name.startswith('__') and
                not hasattr(value, '__call__') and  # Exclude functions
                not hasattr(value, '__module__')    # Exclude modules
            )
        }
        
        # Build the final output string
        result_parts = []
        
        # Add any printed output first
        if printed_output:
            result_parts.append(printed_output)
        
        # Add calculation results if there are any
        if calculation_results:
            if printed_output:  # Add a separator if we already have printed output
                result_parts.append("\nCalculation Results:")
                result_parts.append("-" * 20)
            for var_name, value in calculation_results.items():
                result_parts.append(f"{var_name} = {value}")
        
        # If we have no results at all, provide a message
        if not result_parts:
            return "No calculation results produced."
        
        return "\n".join(result_parts)
    
    except Exception as e:
        return f"Error executing SymPy code: {str(e)}"
        
# Create Gradio interface
with gr.Blocks() as interface:
    gr.Markdown("# Advanced Mathematics Question Generator")
    gr.Markdown("""Generates a unique university-level mathematics question with solution using Claude 3.
    Each question features different topics and difficulty levels. Limited to 25 requests per day.""")
    
    with gr.Row():
        with gr.Column():
            subject_dropdown = gr.Dropdown(
                choices=[
                    "Single Variable Calculus",
                    "Multivariable Calculus", 
                    "Linear Algebra",
                    "Differential Equations",
                    "Real Analysis",
                    "Complex Analysis",
                    "Abstract Algebra",
                    "Probability Theory",
                    "Numerical Analysis",
                    "Topology"
                ],
                label="Select Mathematics Subject",
                info="Choose a subject for the question"
            )
            
            difficulty_slider = gr.Slider(
                minimum=1,
                maximum=5,
                step=1,
                value=3,
                label="Difficulty Level",
                info="1: Very Easy, 2: Easy, 3: Moderate, 4: Difficult, 5: Very Difficult"
            )
            
            question_type = gr.Radio(
                choices=["computation", "proof", "application"],
                label="Question Type",
                info="Select the type of question you want",
                value="computation"
            )
    
    generate_btn = gr.Button("Generate Question")
    
    output_text = gr.Markdown(
        label="Generated Question Preview",
        latex_delimiters=[
            {"left": "$$", "right": "$$", "display": True},
            {"left": "$", "right": "$", "display": False}
        ]
    )
    
    with gr.Row():
        questions_file = gr.File(label="Question Only (LaTeX)")
        full_file = gr.File(label="Question with Solution (LaTeX)")
    
    generate_btn.click(
        generate_question,
        inputs=[
            subject_dropdown,
            difficulty_slider,
            question_type
        ],
        outputs=[output_text, questions_file, full_file]
    )

if __name__ == "__main__":
    logger.info("Starting application")
    interface.launch()