Update app.py

revert to version before solution verification

app.py

@@ -1,215 +1,60 @@
+# app.py
 import os
 import gradio as gr
 from anthropic import Anthropic
-import wolframalpha
 from datetime import datetime, timedelta
 from collections import deque
-import re
 
-# Initialize clients
-anthropic = Anthropic(api_key=os.environ.get('ANTHROPIC_API_KEY'))
-wolfram_client = wolframalpha.Client(os.environ.get('WOLFRAM_APPID'))
+# 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 parse_questions(content):
-    """Parse questions and their solutions from Claude's output"""
-    questions = []
-    current_question = {}
-    
-    # Split content into lines for more reliable parsing
-    lines = content.split('\n')
-    
-    for line in lines:
-        # Start of new question
-        if re.match(r'^\s*\d+\)', line):
-            if current_question:
-                questions.append(current_question)
-            current_question = {
-                'number': re.match(r'^\s*(\d+)\)', line).group(1),
-                'problem': line.split(')', 1)[1].strip(),
-                'solution': '',
-                'final_answer': None
-            }
-        # Solution marker
-        elif 'Solution:' in line and current_question:
-            current_question['problem'] = current_question['problem'].strip()
-            current_question['solution'] = line.split('Solution:', 1)[1].strip()
-        # Add to current problem or solution
-        elif current_question:
-            if current_question['solution']:
-                current_question['solution'] += '\n' + line
-            else:
-                current_question['problem'] += '\n' + line
-                
-        # Extract final answer
-        if current_question and 'final answer' in line.lower():
-            matches = re.findall(r'[-+]?(?:\d*\.)?\d+', line)
-            if matches:
-                current_question['final_answer'] = matches[-1]
-    
-    # Add last question
-    if current_question:
-        questions.append(current_question)
-    
-    # Clean up questions
-    for q in questions:
-        q['problem'] = q['problem'].strip()
-        q['solution'] = q['solution'].strip()
-    
-    return questions
+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
 
-def verify_solution(problem, answer):
-    """Verify a mathematical solution using Wolfram Alpha"""
+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"""
     try:
-        # Initialize query variable
-        query = ""
-        
-        # Clean the problem text first
-        clean_problem = problem.replace('$$', '').replace('$', '').strip()
-        
-        # Case 1: Definite Integral
-        if 'integral' in clean_problem.lower() or '∫' in clean_problem or '\int' in clean_problem:
-            # Use raw string for regex to avoid escape issues
-            integrand_match = re.search(r'(?:\int|∫)_(\d+)\^(\d+)\s*\(?([\dx+\s]+)\)?\s*dx', clean_problem, re.UNICODE)
-            if integrand_match:
-                lower, upper, integrand = integrand_match.groups()
-                # Clean up the integrand
-                integrand = integrand.replace(' ', '')
-                query = f"integrate {integrand} from {lower} to {upper}"
-                print(f"Integral query: {query}")
-            else:
-                # Fallback for simpler pattern
-                integrand_match = re.search(r'(?:\int|∫).*?\(([\dx+\s]+)\)\s*dx', clean_problem, re.UNICODE)
-                if integrand_match:
-                    integrand = integrand_match.group(1).replace(' ', '')
-                    query = f"integrate {integrand} from 0 to 1"  # Common default bounds
-                    print(f"Fallback integral query: {query}")
-        
-        # Case 2: Simple Differentiation
-        elif 'derivative' in clean_problem.lower() or 'd/dx' in clean_problem:
-            # Look for function after equals sign or f(x) =
-            func_match = re.search(r'[f\(x\)\s*=\s*](.*?)$', clean_problem)
-            if func_match:
-                func = func_match.group(1).strip()
-                query = f"derivative of {func}"
-                print(f"Derivative query: {query}")
-        
-        # Case 3: Mean Value Theorem
-        elif 'Mean Value Theorem' in clean_problem:
-            func_match = re.search(r'f\(x\)\s*=\s*(.*?)\s+on', clean_problem)
-            interval_match = re.search(r'\[(\d+),\s*(\d+)\]', clean_problem)
-            if func_match and interval_match:
-                func = func_match.group(1).strip()
-                a, b = interval_match.groups()
-                # Calculate f'(x) first
-                derivative_query = f"derivative of {func}"
-                print(f"MVT derivative query: {derivative_query}")
-                derivative_result = wolfram_client.query(derivative_query)
-                
-                if derivative_result.success:
-                    for pod in derivative_result.pods:
-                        if pod.title in ['Derivative']:
-                            derivative = pod.text
-                            # Now calculate [f(b) - f(a)]/(b-a)
-                            query = f"solve {derivative} = ({func.replace('x', b)} - {func.replace('x', a)})/({b} - {a})"
-                            print(f"MVT final query: {query}")
-                            break
-            
-        # Ensure query is not empty
-        if not query.strip():
-            return {
-                'verified': False,
-                'wolfram_solution': None,
-                'error': "Could not generate valid query from problem"
-            }
-            
-        print(f"Final query to Wolfram Alpha: {query}")
-        result = wolfram_client.query(query)
+        # Check API key
+        check_api_key()
         
-        if not result.success:
-            return {
-                'verified': False,
-                'wolfram_solution': None,
-                'error': f"Wolfram Alpha could not process query: {query}"
-            }
+        # Check rate limit
+        if not check_rate_limit():
+            return "Daily request limit reached. Please try again tomorrow."
         
-        # Process the result
-        for pod in result.pods:
-            if pod.title in ['Result', 'Solution', 'Numerical result', 'Decimal approximation', 'Definite integral', 'Solutions']:
-                wolfram_answer = pod.text
-                print(f"Wolfram pod {pod.title}: {wolfram_answer}")
-                
-                # For MVT problems, handle sqrt expressions
-                if 'Mean Value Theorem' in clean_problem:
-                    # Convert both answers to decimal for comparison
-                    if 'sqrt' in str(answer).lower():
-                        # Convert sqrt expression to decimal
-                        sqrt_match = re.search(r'sqrt\((\d+)/(\d+)\)', str(answer))
-                        if sqrt_match:
-                            num, denom = map(float, sqrt_match.groups())
-                            user_value = (num/denom)**0.5
-                            # Look for decimal in Wolfram result
-                            wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer)
-                            if wolfram_nums:
-                                wolfram_value = float(wolfram_nums[0])
-                                is_verified = abs(wolfram_value - user_value) < 0.01
-                                return {
-                                    'verified': is_verified,
-                                    'wolfram_solution': wolfram_answer,
-                                    'error': None
-                                }
-                
-                # Handle numerical answers
-                if str(answer).replace('.', '').isdigit():
-                    wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer)
-                    if wolfram_nums:
-                        wolfram_value = float(wolfram_nums[0])
-                        user_value = float(answer)
-                        is_verified = abs(wolfram_value - user_value) < 0.01
-                        return {
-                            'verified': is_verified,
-                            'wolfram_solution': wolfram_answer,
-                            'error': None
-                        }
-                # Handle symbolic answers
-                else:
-                    clean_wolfram = re.sub(r'\s+', '', wolfram_answer.lower())
-                    clean_answer = re.sub(r'\s+', '', str(answer).lower())
-                    is_verified = clean_wolfram == clean_answer
-                    return {
-                        'verified': is_verified,
-                        'wolfram_solution': wolfram_answer,
-                        'error': None
-                    }
+        # Record request
+        request_history.append(datetime.now())
         
-        return {
-            'verified': False,
-            'wolfram_solution': None,
-            'error': "No suitable solution found in Wolfram Alpha response"
-        }
-        
-    except Exception as e:
-        error_msg = f"Error during verification: {str(e)}"
-        if query:
-            error_msg += f"\nQuery attempted: {query}"
-        return {
-            'verified': False,
-            'wolfram_solution': None,
-            'error': error_msg
-        }
-
-def generate_test(subject):
-    """Generate and verify a math test"""
-    try:
-        system_prompt = """Generate 3 university-level math questions that can be verified numerically.
-        For each question:
-        1. Number the question as 1), 2), 3)
-        2. State the problem clearly using simple $$ for displayed math
-        3. Include "Solution:" before the solution
-        4. Show step-by-step work
-        5. End each solution with "Final answer = [number]"
-        6. Keep problems relatively simple (basic calculus, algebra, etc.)
-        7. Make sure problems have clear numerical answers
-        8. Avoid word problems - focus on pure mathematical expressions"""
+        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"""
         
         message = anthropic.messages.create(
             model="claude-3-opus-20240229",
@@ -217,53 +62,42 @@ def generate_test(subject):
             temperature=0.7,
             messages=[{
                 "role": "user",
-                "content": f"{system_prompt}\n\nWrite an exam for {subject} with simple numerical answers."
+                "content": f"{system_prompt}\n\nWrite an exam for {subject}."
             }]
         )
         
-        # Get the content and parse questions
-        content = message.content[0].text
-        questions = parse_questions(content)
-        
-        # Add verification results
-        verification_note = "\n\n---\n## Solution Verification:\n"
-        verification_results = []
-        
-        for q in questions:
-            if q['final_answer'] is not None:
-                result = verify_solution(q['problem'], q['final_answer'])
-                verification_results.append(result)
-                verification_note += f"\nQuestion {q['number']}:\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 result: {result['wolfram_solution']}\n"
-                if result['error']:
-                    verification_note += f"Note: {result['error']}\n"
-            else:
-                verification_note += f"\nQuestion {q['number']}:\n⚠️ Could not extract final answer\n"
+        # 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
         
-        # Add usage statistics
         usage_stats = f"""
         \n---\nUsage Statistics:
-        • Input Tokens: {message.usage.input_tokens:,}
-        • Output Tokens: {message.usage.output_tokens:,}
-        • Wolfram Alpha calls: {len(verification_results)}
+        • Input Tokens: {input_tokens:,}
+        • Output Tokens: {output_tokens:,}
+        • Total Tokens: {input_tokens + output_tokens:,}
         
         Cost Breakdown:
-        • Claude Cost: ${((message.usage.input_tokens / 1000) * 0.015) + ((message.usage.output_tokens / 1000) * 0.075):.4f}
-        • Wolfram API calls: {len(verification_results)}
+        • Input Cost: ${input_cost:.4f}
+        • Output Cost: ${output_cost:.4f}
+        • Total Cost: ${total_cost:.4f}
         """
         
-        # Combine everything with proper spacing
-        final_output = content + "\n\n" + verification_note + usage_stats
-        return final_output
+        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"
             
+    except ValueError as e:
+        return f"Configuration Error: {str(e)}"
     except Exception as e:
         return f"Error: {str(e)}"
 
+# Subject choices
 subjects = [
     "Single Variable Calculus",
     "Multivariable Calculus", 
@@ -301,4 +135,4 @@ interface = gr.Interface(
 
 # Launch the interface
 if __name__ == "__main__":
-    interface.launch()
+    interface.launch()