add error logging

app.py

@@ -4,6 +4,12 @@ from anthropic import Anthropic
 from datetime import datetime, timedelta
 from collections import deque
 import random
+import logging
+import tempfile
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
 
 # Initialize Anthropic client
 anthropic = Anthropic(
@@ -14,94 +20,84 @@ anthropic = Anthropic(
 MAX_REQUESTS_PER_DAY = 25
 request_history = deque(maxlen=1000)
 
-def check_api_key():
-    """Verify API key is configured"""
-    if not os.environ.get('ANTHROPIC_API_KEY'):
-        raise ValueError("Anthropic API key not found. Please configure it in HuggingFace Spaces settings.")
-
-def check_rate_limit():
-    """Check if we're within rate limits"""
-    now = datetime.now()
-    while request_history and (now - request_history[0]) > timedelta(days=1):
-        request_history.popleft()
-    return len(request_history) < MAX_REQUESTS_PER_DAY
-
-def clean_latex(text):
-    """Simple LaTeX cleaning"""
-    text = text.replace('\n', '\n\n')
-    return text
-
 def create_latex_document(content, questions_only=False):
     """Create a complete LaTeX document"""
-    latex_header = r"""\documentclass{article}
+    try:
+        latex_header = r"""\documentclass{article}
 \usepackage{amsmath,amssymb}
 \usepackage[margin=1in]{geometry}
 \begin{document}
 \title{Mathematics Test}
 \maketitle
 """
-    latex_footer = r"\end{document}"
-    
-    if questions_only:
-        # Extract only the questions (everything before "Solution:")
-        processed_content = []
-        current_question = []
-        for line in content.split('\n'):
-            if 'Solution:' in line:
-                processed_content.append('\n'.join(current_question))
-                current_question = []
-                continue
-            if any(line.startswith(f"{i})") for i in range(1, 4)):
-                if current_question:
+        latex_footer = r"\end{document}"
+        
+        if questions_only:
+            processed_content = []
+            current_question = []
+            for line in content.split('\n'):
+                if 'Solution:' in line:
                     processed_content.append('\n'.join(current_question))
-                current_question = [line]
-            elif current_question:
-                current_question.append(line)
-        if current_question:
-            processed_content.append('\n'.join(current_question))
-        content = '\n\n'.join(processed_content)
-    
-    return f"{latex_header}\n{content}\n{latex_footer}"
+                    current_question = []
+                    continue
+                if any(line.startswith(f"{i})") for i in range(1, 4)):
+                    if current_question:
+                        processed_content.append('\n'.join(current_question))
+                    current_question = [line]
+                elif current_question:
+                    current_question.append(line)
+            if current_question:
+                processed_content.append('\n'.join(current_question))
+            content = '\n\n'.join(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 generate_test(subject):
     """Generate a math test"""
     try:
-        check_api_key()
-        if not check_rate_limit():
+        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 test for subject: {subject}")
+        
+        # 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(datetime.now())
+        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"],
-            # ... add topics for other subjects
         }
         
         selected_topics = random.sample(topics.get(subject, ["general"]), min(3, len(topics.get(subject, ["general"]))))
-        difficulty_distribution = random.choice([
-            "one easy, one medium, one challenging",
-            "two medium, one very challenging",
-            "one medium, two challenging"
-        ])
+        logger.debug(f"Selected topics: {selected_topics}")
         
         system_prompt = f"""You will write math exam questions. Follow these requirements EXACTLY:
         1. Write exactly 3 university-level questions focusing on these specific topics: {', '.join(selected_topics)}
-        2. Make the questions {difficulty_distribution}
-        3. ALL questions must be computational or proof-based problems. NO conceptual or explanation questions.
-        4. Each question must require mathematical work, calculations, or formal proofs
-        5. For LaTeX math formatting:
+        2. ALL questions must be computational or proof-based problems. NO conceptual or explanation questions.
+        3. Each question must require mathematical work, calculations, or formal proofs
+        4. For LaTeX math formatting:
            - Use $ for simple inline math
            - For equations and solution steps, use $$ on separate lines
            - For multi-step solutions, put each step on its own line in $$ $$
            - DO NOT use \\begin{{aligned}} or any other environments
-        6. Number each question as 1), 2), 3)
-        7. Include detailed solutions after each question
-        8. Keep formatting simple and clear
-        
-        Important: Every question must require mathematical computation or proof. Do not ask for explanations, descriptions, or concepts."""
+        5. Number each question as 1), 2), 3)
+        6. Include detailed solutions after each question
+        7. Keep formatting simple and clear"""
         
+        logger.debug("Sending request to Anthropic API")
         message = anthropic.messages.create(
             model="claude-3-opus-20240229",
             max_tokens=1500,
@@ -112,34 +108,36 @@ def generate_test(subject):
             }]
         )
         
-        if hasattr(message, 'content') and len(message.content) > 0:
-            response_text = message.content[0].text
-            cleaned_text = clean_latex(response_text)
+        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")
+        
+        # Create temporary files
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.tex', delete=False) as f_questions:
+            questions_latex = create_latex_document(response_text, questions_only=True)
+            f_questions.write(questions_latex)
+            questions_path = f_questions.name
             
-            # Create both versions of the LaTeX document
-            full_latex = create_latex_document(cleaned_text, questions_only=False)
-            questions_latex = create_latex_document(cleaned_text, questions_only=True)
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.tex', delete=False) as f_full:
+            full_latex = create_latex_document(response_text, questions_only=False)
+            f_full.write(full_latex)
+            full_path = f_full.name
             
-            return cleaned_text, questions_latex, full_latex
-        else:
-            return "Error: No content in response", None, None
+        logger.debug("Successfully created temporary files")
+        
+        return (
+            response_text,
+            (questions_path, "questions.tex"),
+            (full_path, "full_test.tex")
+        )
             
     except Exception as e:
+        logger.error(f"Error generating test: {str(e)}")
         return f"Error: {str(e)}", None, None
 
-subjects = [
-    "Single Variable Calculus",
-    "Multivariable Calculus", 
-    "Linear Algebra",
-    "Differential Equations",
-    "Real Analysis",
-    "Complex Analysis",
-    "Abstract Algebra",
-    "Probability Theory",
-    "Numerical Analysis",
-    "Topology"
-]
-
 # Create Gradio interface
 with gr.Blocks() as interface:
     gr.Markdown("# Advanced Mathematics Test Generator")
@@ -148,14 +146,25 @@ with gr.Blocks() as interface:
     
     with gr.Row():
         subject_dropdown = gr.Dropdown(
-            choices=subjects,
+            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 exam questions"
         )
         generate_btn = gr.Button("Generate Test")
     
     output_text = gr.Markdown(
-        label="Generated Test",
+        label="Generated Test Preview",
         latex_delimiters=[
             {"left": "$$", "right": "$$", "display": True},
             {"left": "$", "right": "$", "display": False}
@@ -163,19 +172,19 @@ with gr.Blocks() as interface:
     )
     
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Download LaTeX Files")
-            questions_file = gr.File(label="Questions Only (LaTeX)")
-            full_file = gr.File(label="Full Test with Solutions (LaTeX)")
+        questions_file = gr.File(label="Questions Only (LaTeX)")
+        full_file = gr.File(label="Full Test with Solutions (LaTeX)")
     
     def generate_and_prepare_files(subject):
-        preview, questions_latex, full_latex = generate_test(subject)
+        logger.debug("Starting test generation")
+        preview, questions_path, full_path = generate_test(subject)
         
-        # Create temporary files for download
-        questions_file = {"content": questions_latex.encode(), "name": "questions.tex"}
-        full_file = {"content": full_latex.encode(), "name": "full_test.tex"}
-        
-        return preview, questions_file, full_file
+        if questions_path and full_path:
+            logger.debug("Test generation successful, preparing files")
+            return preview, questions_path, full_path
+        else:
+            logger.error("Test generation failed")
+            return preview, None, None
     
     generate_btn.click(
         generate_and_prepare_files,
@@ -184,4 +193,5 @@ with gr.Blocks() as interface:
     )
 
 if __name__ == "__main__":
+    logger.info("Starting application")
     interface.launch()