Update app.py

app.py

@@ -12,62 +12,82 @@ wolfram_client = wolframalpha.Client(os.environ.get('WOLFRAM_APPID'))
 
 def parse_questions(content):
     """Parse questions and their solutions from Claude's output"""
-    # Split content into questions
     questions = []
-    parts = re.split(r'\n\s*(\d+)\)', content)
+    current_question = {}
     
-    # Remove any empty first element
-    if parts[0].strip() == '':
-        parts = parts[1:]
+    # Split content into lines for more reliable parsing
+    lines = content.split('\n')
     
-    # Process pairs of question numbers and content
-    for i in range(0, len(parts)-1, 2):
-        question_num = parts[i]
-        question_content = parts[i+1]
-        
-        try:
-            # Split into problem and solution
-            if "Solution:" in question_content:
-                problem, solution = question_content.split("Solution:", 1)
+    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:
-                continue
+                current_question['problem'] += '\n' + line
                 
-            # Clean up the problem and solution
-            problem = problem.strip()
-            solution = solution.strip()
-            
-            # Extract the final answer (look for last equation or stated answer)
-            final_answer_match = re.search(r'(?:final answer|=)\s*[-+]?(?:\d*\.)?\d+', solution.lower())
-            if final_answer_match:
-                final_answer = re.findall(r'[-+]?(?:\d*\.)?\d+', final_answer_match.group())[-1]
-                questions.append({
-                    'number': question_num,
-                    'problem': problem,
-                    'solution': solution,
-                    'final_answer': final_answer
-                })
-        except Exception as e:
-            print(f"Error parsing question {question_num}: {e}")
-            continue
+        # 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 verify_solution(problem, answer):
     """Verify a mathematical solution using Wolfram Alpha"""
     try:
-        # Format the query for Wolfram Alpha
-        query = problem.replace('$$', '').replace('$', '')  # Remove LaTeX delimiters
+        # Clean up the problem for Wolfram Alpha
+        query = problem.replace('$$', '').replace('$', '')
+        # Remove any text instructions, keep only the mathematical expression
+        query = re.sub(r'(?i)find|calculate|solve|evaluate|determine', '', query)
+        query = query.strip()
+        
         result = wolfram_client.query(query)
         
-        # Try to get the numerical result
+        if not result.success:
+            return {
+                'verified': False,
+                'wolfram_solution': None,
+                'error': "Wolfram Alpha could not process the query"
+            }
+        
+        # Look for numerical results in multiple pods
         for pod in result.pods:
-            if pod.title in ['Result', 'Solution', 'Numerical result']:
+            if pod.title in ['Result', 'Solution', 'Numerical result', 'Decimal approximation']:
                 wolfram_answer = pod.text
                 # Extract numerical value
                 wolfram_nums = re.findall(r'[-+]?(?:\d*\.)?\d+', wolfram_answer)
                 if wolfram_nums:
+                    wolfram_value = float(wolfram_nums[0])
+                    user_value = float(answer)
+                    # Allow for small numerical differences
+                    is_verified = abs(wolfram_value - user_value) < 0.01
                     return {
-                        'verified': abs(float(wolfram_nums[0]) - float(answer)) < 0.001,
+                        'verified': is_verified,
                         'wolfram_solution': wolfram_answer,
                         'error': None
                     }
@@ -75,13 +95,13 @@ def verify_solution(problem, answer):
         return {
             'verified': False,
             'wolfram_solution': None,
-            'error': "Could not extract numerical solution from Wolfram Alpha"
+            'error': "No numerical solution found in Wolfram Alpha response"
         }
     except Exception as e:
         return {
             'verified': False,
             'wolfram_solution': None,
-            'error': str(e)
+            'error': f"Error during verification: {str(e)}"
         }
 
 def generate_test(subject):
@@ -94,7 +114,9 @@ def generate_test(subject):
         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.)"""
+        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"""
         
         message = anthropic.messages.create(
             model="claude-3-opus-20240229",
@@ -115,17 +137,20 @@ def generate_test(subject):
         verification_results = []
         
         for q in questions:
-            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"
+            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 += "⚠️ 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"
+                verification_note += f"\nQuestion {q['number']}:\n⚠️ Could not extract final answer\n"
         
         # Add usage statistics
         usage_stats = f"""