Update app.py

Fixed "query" not being assigned in some cases before used in the error handling

app.py

@@ -60,6 +60,9 @@ def parse_questions(content):
 def verify_solution(problem, answer):
     """Verify a mathematical solution using Wolfram Alpha"""
     try:
+        # Initialize query variable
+        query = ""
+        
         # Clean the problem text first
         clean_problem = problem.replace('$$', '').replace('$', '').strip()
         
@@ -71,7 +74,18 @@ def verify_solution(problem, answer):
                 lower, upper, integrand = integrand_match.groups()
                 # Format the query properly
                 query = f"integrate {integrand} from {lower} to {upper}"
-                print(f"Integral query: {query}")
+            else:
+                # Try alternative pattern for integral
+                integrand_match = re.search(r'\int.*?(\d+).*?(\d+).*?\((.*?)\)\s*dx', clean_problem)
+                if integrand_match:
+                    lower, upper, integrand = integrand_match.groups()
+                    query = f"integrate {integrand} from {lower} to {upper}"
+                else:
+                    return {
+                        'verified': False,
+                        'wolfram_solution': None,
+                        'error': "Could not parse integral expression"
+                    }
         
         # Case 2: Implicit Differentiation
         elif 'dy/dx' in clean_problem or 'dy' in clean_problem:
@@ -80,7 +94,12 @@ def verify_solution(problem, answer):
             if equation_match:
                 equation = equation_match.group(1)
                 query = f"d/dx of {equation}"
-                print(f"Differentiation query: {query}")
+            else:
+                return {
+                    'verified': False,
+                    'wolfram_solution': None,
+                    'error': "Could not parse differential equation"
+                }
         
         # Case 3: Mean Value Theorem
         elif 'Mean Value Theorem' in clean_problem:
@@ -90,17 +109,28 @@ def verify_solution(problem, answer):
             if func_match and interval_match:
                 func = func_match.group(1)
                 a, b = interval_match.groups()
-                # Format query to find derivative and then solve f'(c) = [f(b)-f(a)]/(b-a)
                 query = f"solve (d/dx({func})) = ({func.replace('x', str(b))} - {func.replace('x', str(a))})/{b} - {a}"
-                print(f"MVT query: {query}")
+            else:
+                return {
+                    'verified': False,
+                    'wolfram_solution': None,
+                    'error': "Could not parse Mean Value Theorem problem"
+                }
         
         # Default case
         else:
             query = clean_problem
             query = re.sub(r'(?i)find|calculate|solve|evaluate|determine', '', query)
+        
+        # Ensure query is not empty
+        if not query.strip():
+            return {
+                'verified': False,
+                'wolfram_solution': None,
+                'error': "Could not generate valid query"
+            }
             
-        query = query.strip()
-        print(f"Final query to Wolfram Alpha: {query}")
+        print(f"Sending query to Wolfram Alpha: {query}")
         
         result = wolfram_client.query(query)
         
@@ -145,11 +175,16 @@ def verify_solution(problem, answer):
             'wolfram_solution': None,
             'error': "No suitable solution found in Wolfram Alpha response"
         }
+        
     except Exception as e:
+        # Now query will always be defined when we get here
+        error_msg = f"Error during verification: {str(e)}"
+        if query:
+            error_msg += f"\nQuery attempted: {query}"
         return {
             'verified': False,
             'wolfram_solution': None,
-            'error': f"Error during verification: {str(e)}\nQuery attempted: {query}"
+            'error': error_msg
         }
 
 def generate_test(subject):