no conceptual questions, added download functionality

Modified the system prompt to explicitly require computational or proof-based problems only, and explicitly forbid conceptual questions

Added functionality to generate both LaTeX and PDF versions of the test
Created a new interface using Gradio Blocks that includes:

Download buttons for questions-only and full test versions
Both LaTeX and PDF format options

Added functions to handle LaTeX document creation and PDF conversion
Improved the UI layout with separate sections for different download options

app.py

@@ -4,6 +4,9 @@ from anthropic import Anthropic
 from datetime import datetime, timedelta
 from collections import deque
 import random
+import tempfile
+import subprocess
+from pathlib import Path
 
 # Initialize Anthropic client
 anthropic = Anthropic(
@@ -31,8 +34,46 @@ def clean_latex(text):
     text = text.replace('\n', '\n\n')
     return text
 
-def generate_test(subject):
-    """Generate a math test with enhanced variety"""
+def create_latex_document(content, questions_only=False):
+    """Create a complete LaTeX document"""
+    latex_header = r"""\documentclass{article}
+    \usepackage{amsmath,amssymb}
+    \usepackage[margin=1in]{geometry}
+    \begin{document}
+    """
+    latex_footer = r"\end{document}"
+    
+    if questions_only:
+        # Extract only the questions (everything before "Solution:")
+        questions = []
+        for question in content.split('\n'):
+            if 'Solution:' in question:
+                continue
+            questions.append(question)
+        content = '\n'.join(questions)
+    
+    return f"{latex_header}\n{content}\n{latex_footer}"
+
+def latex_to_pdf(latex_content):
+    """Convert LaTeX content to PDF"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tex_path = Path(tmpdir) / "output.tex"
+        with open(tex_path, "w", encoding="utf-8") as f:
+            f.write(latex_content)
+        
+        # Run pdflatex twice to resolve references
+        subprocess.run(["pdflatex", "-interaction=nonstopmode", str(tex_path)], 
+                     cwd=tmpdir, capture_output=True)
+        subprocess.run(["pdflatex", "-interaction=nonstopmode", str(tex_path)], 
+                     cwd=tmpdir, capture_output=True)
+        
+        pdf_path = Path(tmpdir) / "output.pdf"
+        if pdf_path.exists():
+            return pdf_path.read_bytes()
+        return None
+
+def generate_test_with_format(subject, output_format):
+    """Generate a math test with specified output format"""
     try:
         check_api_key()
         if not check_rate_limit():
@@ -40,11 +81,10 @@ def generate_test(subject):
         
         request_history.append(datetime.now())
         
-        # Randomly select focus areas and difficulty levels
         topics = {
             "Single Variable Calculus": ["limits", "derivatives", "integrals", "series", "applications"],
-            "Multivariable Calculus": ["partial derivatives", "multiple integrals", "vector fields", "optimization", "surface integrals"],
-            "Linear Algebra": ["matrices", "vector spaces", "eigenvalues", "linear transformations", "inner products"],
+            "Multivariable Calculus": ["partial derivatives", "multiple integrals", "vector fields", "optimization"],
+            "Linear Algebra": ["matrices", "vector spaces", "eigenvalues", "linear transformations"],
             # ... add topics for other subjects
         }
         
@@ -58,8 +98,8 @@ def generate_test(subject):
         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. For each question, use a different type of mathematical thinking (e.g., computation, proof, application, conceptual understanding)
-        4. Ensure questions are unique and not commonly found in textbooks
+        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:
            - Use $ for simple inline math
            - For equations and solution steps, use $$ on separate lines
@@ -69,13 +109,9 @@ def generate_test(subject):
         7. Include detailed solutions after each question
         8. Keep formatting simple and clear
         
-        Important: Make these questions distinct from standard textbook problems. Incorporate real-world applications, 
-        interdisciplinary connections, or creative scenarios where appropriate."""
+        Important: Every question must require mathematical computation or proof. Do not ask for explanations, descriptions, or concepts."""
         
-        # Vary temperature based on subject complexity
-        base_temperature = 0.7
-        complexity_adjustment = random.uniform(-0.1, 0.1)
-        temperature = min(1.0, max(0.5, base_temperature + complexity_adjustment))
+        temperature = 0.7
         
         message = anthropic.messages.create(
             model="claude-3-opus-20240229",
@@ -87,38 +123,32 @@ def generate_test(subject):
             }]
         )
         
-        # Extract usage information
-        input_tokens = message.usage.input_tokens
-        output_tokens = message.usage.output_tokens
-        input_cost = (input_tokens / 1000) * 0.015
-        output_cost = (output_tokens / 1000) * 0.075
-        total_cost = input_cost + output_cost
-        
-        usage_stats = f"""
-        \n---\nUsage Statistics:
-        • Input Tokens: {input_tokens:,}
-        • Output Tokens: {output_tokens:,}
-        • Total Tokens: {input_tokens + output_tokens:,}
-        
-        Cost Breakdown:
-        • Input Cost: ${input_cost:.4f}
-        • Output Cost: ${output_cost:.4f}
-        • Total Cost: ${total_cost:.4f}
-        """
-        
         if hasattr(message, 'content') and len(message.content) > 0:
             response_text = message.content[0].text
-            formatted_response = clean_latex(response_text) + usage_stats
-            return formatted_response
+            return clean_latex(response_text)
         else:
             return "Error: No content in response"
             
-    except ValueError as e:
-        return f"Configuration Error: {str(e)}"
     except Exception as e:
         return f"Error: {str(e)}"
 
-# Subject choices remain the same
+def create_download_files(test_content):
+    """Create downloadable files in different formats"""
+    # Full test (questions and solutions)
+    full_latex = create_latex_document(test_content, questions_only=False)
+    full_pdf = latex_to_pdf(full_latex)
+    
+    # Questions only
+    questions_latex = create_latex_document(test_content, questions_only=True)
+    questions_pdf = latex_to_pdf(questions_latex)
+    
+    return {
+        "full_latex": full_latex,
+        "full_pdf": full_pdf,
+        "questions_latex": questions_latex,
+        "questions_pdf": questions_pdf
+    }
+
 subjects = [
     "Single Variable Calculus",
     "Multivariable Calculus", 
@@ -132,27 +162,73 @@ subjects = [
     "Topology"
 ]
 
+def download_handler(file_content, filename):
+    """Handle file downloads"""
+    return file_content
+
 # Create Gradio interface
-interface = gr.Interface(
-    fn=generate_test,
-    inputs=gr.Dropdown(
-        choices=subjects,
-        label="Select Mathematics Subject",
-        info="Choose a subject for the exam questions"
-    ),
-    outputs=gr.Markdown(
+with gr.Blocks() as interface:
+    gr.Markdown("# Advanced Mathematics Test Generator")
+    gr.Markdown("""Generates unique university-level mathematics exam questions with solutions using Claude 3 Opus.
+    Each test features different topics and difficulty levels. Limited to 25 requests per day.""")
+    
+    with gr.Row():
+        subject_dropdown = gr.Dropdown(
+            choices=subjects,
+            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",
         latex_delimiters=[
             {"left": "$$", "right": "$$", "display": True},
             {"left": "$", "right": "$", "display": False}
         ]
-    ),
-    title="Advanced Mathematics Test Generator",
-    description="""Generates unique university-level mathematics exam questions with solutions using Claude 3 Opus.
-    Each test features different topics and difficulty levels. Limited to 25 requests per day.""",
-    theme="default",
-    allow_flagging="never"
-)
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Download Questions Only")
+            questions_latex_btn = gr.Button("Download Questions (LaTeX)")
+            questions_pdf_btn = gr.Button("Download Questions (PDF)")
+        
+        with gr.Column():
+            gr.Markdown("### Download Full Test with Solutions")
+            full_latex_btn = gr.Button("Download Full Test (LaTeX)")
+            full_pdf_btn = gr.Button("Download Full Test (PDF)")
+    
+    # Hidden components for downloads
+    questions_latex_output = gr.File(label="Questions LaTeX", visible=False)
+    questions_pdf_output = gr.File(label="Questions PDF", visible=False)
+    full_latex_output = gr.File(label="Full LaTeX", visible=False)
+    full_pdf_output = gr.File(label="Full PDF", visible=False)
+    
+    # Event handlers
+    def generate_and_prepare_downloads(subject):
+        test_content = generate_test_with_format(subject, "latex")
+        files = create_download_files(test_content)
+        return (
+            test_content,
+            (files["questions_latex"], "questions.tex"),
+            (files["questions_pdf"], "questions.pdf"),
+            (files["full_latex"], "full_test.tex"),
+            (files["full_pdf"], "full_test.pdf")
+        )
+    
+    generate_btn.click(
+        generate_and_prepare_downloads,
+        inputs=[subject_dropdown],
+        outputs=[output_text, questions_latex_output, questions_pdf_output, 
+                full_latex_output, full_pdf_output]
+    )
+    
+    # Download button clicks
+    questions_latex_btn.click(lambda: questions_latex_output.value)
+    questions_pdf_btn.click(lambda: questions_pdf_output.value)
+    full_latex_btn.click(lambda: full_latex_output.value)
+    full_pdf_btn.click(lambda: full_pdf_output.value)
 
 if __name__ == "__main__":
     interface.launch()