Update app.py

Added Wolfram API Integration

app.py

@@ -2,59 +2,55 @@
 import os
 import gradio as gr
 from anthropic import Anthropic
+import wolframalpha
 from datetime import datetime, timedelta
 from collections import deque
 
-# Initialize Anthropic client - will use the secret key from HuggingFace
-anthropic = Anthropic(
-    api_key=os.environ.get('ANTHROPIC_API_KEY')
-)
-
-# Request tracking
-MAX_REQUESTS_PER_DAY = 25  # Conservative limit to start
-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()
-    # Remove requests older than 24 hours
-    while request_history and (now - request_history[0]) > timedelta(days=1):
-        request_history.popleft()
-    return len(request_history) < MAX_REQUESTS_PER_DAY
+# Initialize clients
+anthropic = Anthropic(api_key=os.environ.get('ANTHROPIC_API_KEY'))
+wolfram_client = wolframalpha.Client(os.environ.get('WOLFRAM_APPID'))
 
-def clean_latex(text):
-    """Simple LaTeX cleaning"""
-    text = text.replace('\n', '\n\n')
-    return text
-
-def generate_test(subject):
-    """Generate a math test with error handling and rate limiting"""
+def verify_solution(problem, claimed_solution):
+    """Verify a mathematical solution using Wolfram Alpha"""
     try:
-        # Check API key
-        check_api_key()
+        # Clean up the problem and solution for Wolfram Alpha
+        query = f"Solve {problem}"
+        result = wolfram_client.query(query)
         
-        # Check rate limit
-        if not check_rate_limit():
-            return "Daily request limit reached. Please try again tomorrow."
+        # Extract the solution from Wolfram Alpha
+        wolfram_solution = next(result.results).text
         
-        # Record request
-        request_history.append(datetime.now())
+        # Compare solutions (needs sophisticated parsing based on your problem types)
+        solutions_match = compare_solutions(wolfram_solution, claimed_solution)
         
-        system_prompt = """You will write math exam questions. Follow these requirements EXACTLY:
-        1. Write exactly 3 challenging university-level questions
-        2. 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
-        3. Number each question as 1), 2), 3)
-        4. Include solutions after each question
-        5. Keep formatting simple and clear"""
+        return {
+            'verified': solutions_match,
+            'wolfram_solution': wolfram_solution,
+            'match': solutions_match
+        }
+    except Exception as e:
+        return {
+            'verified': False,
+            'error': str(e),
+            'wolfram_solution': None
+        }
+
+def compare_solutions(wolfram_sol, claude_sol):
+    """Compare two solutions for mathematical equivalence"""
+    # This would need sophisticated parsing based on your problem types
+    # Basic example:
+    return abs(float(wolfram_sol) - float(claude_sol)) < 0.001
+
+def generate_test(subject):
+    """Generate and verify a math test"""
+    try:
+        # Generate the test using Claude
+        system_prompt = """Generate 3 university-level math questions with numerical solutions that can be verified.
+        For each question:
+        1. State the problem clearly
+        2. Provide your step-by-step solution
+        3. Give the final answer in a format that can be verified
+        Use simple $$ for all math expressions."""
         
         message = anthropic.messages.create(
             model="claude-3-opus-20240229",
@@ -66,37 +62,48 @@ 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
+        # Extract questions and solutions
+        content = message.content[0].text
+        
+        # Add verification results
+        verification_results = []
         
+        # For each question/solution pair (you'll need to parse the content)
+        # Example structure:
+        verification_note = "\n\n## Solution Verification:\n"
+        for i, (problem, solution) in enumerate(parse_questions(content)):
+            result = verify_solution(problem, solution)
+            verification_note += f"\nQuestion {i+1}:\n"
+            if result['verified']:
+                verification_note += "✅ Solution verified by Wolfram Alpha\n"
+            else:
+                verification_note += "⚠️ Solution needs verification\n"
+                if result['wolfram_solution']:
+                    verification_note += f"Wolfram Alpha got: {result['wolfram_solution']}\n"
+        
+        # Add usage statistics
         usage_stats = f"""
         \n---\nUsage Statistics:
-        • Input Tokens: {input_tokens:,}
-        • Output Tokens: {output_tokens:,}
-        • Total Tokens: {input_tokens + output_tokens:,}
+        • Input Tokens: {message.usage.input_tokens:,}
+        • Output Tokens: {message.usage.output_tokens:,}
+        • Wolfram Alpha calls: {len(verification_results)}
         
         Cost Breakdown:
-        • Input Cost: ${input_cost:.4f}
-        • Output Cost: ${output_cost:.4f}
-        • Total Cost: ${total_cost:.4f}
+        • Claude Cost: ${((message.usage.input_tokens / 1000) * 0.015) + ((message.usage.output_tokens / 1000) * 0.075):.4f}
+        • Wolfram API calls: {len(verification_results)}
         """
         
-        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
-        else:
-            return "Error: No content in response"
+        return content + verification_note + usage_stats
             
-    except ValueError as e:
-        return f"Configuration Error: {str(e)}"
     except Exception as e:
         return f"Error: {str(e)}"
 
+# Update requirements.txt to include:
+# wolframalpha==5.0.0
+# Update environment variables to include WOLFRAM_APPID
+
+# Rest of your Gradio interface code remains the same...
+
 # Subject choices
 subjects = [
     "Single Variable Calculus",