Update app.py

app.py

@@ -316,111 +316,112 @@ STRICT REQUIREMENTS:
         return f"Error: {str(e)}", None, None
 
 def extract_and_run_sympy_code(response_text):
-    """
-    Extract SymPy code from the response and execute it.
-    Returns only the essential calculation results as a string.
-    """
-    try:
-        # Find the SymPy code block
-        sympy_start = response_text.find('```python')
-        if sympy_start == -1:
-            return "No SymPy code found in the response."
-        
-        # Extract the code (excluding the ```python and ``` markers)
-        code_start = response_text.find('\n', sympy_start) + 1
-        code_end = response_text.find('```', code_start)
-        if code_end == -1:
-            return "Malformed SymPy code block."
-        
-        sympy_code = response_text[code_start:code_end].strip()
+   """
+   Extract SymPy code from the response and execute it.
+   Returns only the essential calculation results as a string.
+   """
+   try:
+       # Find the SymPy code block
+       sympy_start = response_text.find('```python')
+       if sympy_start == -1:
+           return "No SymPy code found in the response."
+       
+       # Extract the code (excluding the ```python and ``` markers)
+       code_start = response_text.find('\n', sympy_start) + 1
+       code_end = response_text.find('```', code_start)
+       if code_end == -1:
+           return "Malformed SymPy code block."
+       
+       sympy_code = response_text[code_start:code_end].strip()
 
-        if "print" not in sympy_code and any(x in sympy_code for x in ['diff', 'integrate', 'solve']):
-            lines = sympy_code.split('\n')
-            modified_lines = []
-            for line in lines:
-                modified_lines.append(line)
-                # If line assigns a value and looks like it creates an expression
-                if ('=' in line and '#' not in line and 'import' not in line 
-                    and any(x in line for x in ['diff', 'integrate', 'solve', 'sqrt', 'log'])):
-                    var_name = line.split('=')[0].strip()
-                    modified_lines.append(f"print('{var_name} = ')")
-                    modified_lines.append(f"print(simplify({var_name}))")
-            sympy_code = '\n'.join(modified_lines)
-        
-        # Import necessary modules
-        import io
-        import sympy
-        from contextlib import redirect_stdout
+       if "print" not in sympy_code and any(x in sympy_code for x in ['diff', 'integrate', 'solve']):
+           lines = sympy_code.split('\n')
+           modified_lines = []
+           for line in lines:
+               modified_lines.append(line)
+               # If line assigns a value and looks like it creates an expression
+               if ('=' in line and '#' not in line and 'import' not in line 
+                   and any(x in line for x in ['diff', 'integrate', 'solve', 'sqrt', 'log'])):
+                   var_name = line.split('=')[0].strip()
+                   modified_lines.append(f"print('{var_name} = ', {var_name})")
+           sympy_code = '\n'.join(modified_lines)
+       
+       # Import necessary modules
+       import io
+       import sympy
+       from contextlib import redirect_stdout
 
-        # Create a string buffer to capture print output
-        output_buffer = io.StringIO()
-        
-        # Create globals dict with minimal SymPy elements
-        sympy_globals = {
-            "Symbol": sympy.Symbol,
-            "symbols": sympy.symbols,
-            "solve": sympy.solve,
-            "integrate": sympy.integrate,
-            "diff": sympy.diff,
-            "limit": sympy.limit,
-            "sqrt": sympy.sqrt,
-            "exp": sympy.exp,
-            "simplify": sympy.simplify,
-            "expand": sympy.expand,
-            "log": sympy.log, 
-            "print": print,  # Allow print statements
-            "pi": sympy.pi,
-            "N": sympy.N,
-            "evalf": lambda x: x.evalf()
-        }
-        
-        # Create locals dict to capture new variables
-        local_vars = {}
-
-        # Execute the code and capture output
-        with redirect_stdout(output_buffer):
-            exec(sympy_code, sympy_globals, local_vars)
-        
-        # Get the printed output
-        printed_output = output_buffer.getvalue().strip()
-        
-        # Initialize result string
-        result = []
-        
-        # Add numerical and symbolic calculation results
-        for name, value in local_vars.items():
-            # Skip private variables and functions
-            if name.startswith('__') or callable(value) or isinstance(value, type):
-                continue
-                
-            # Skip module references
-            if hasattr(value, '__module__'):
-                continue
-                
-            # Format the output
-            try:
-                # If it's a sympy expression or numerical result
-                if isinstance(value, (sympy.Basic, int, float)) or hasattr(value, 'free_symbols'):
-                    result.append(f"{name} = {value}")
-                # If it's a list or tuple of sympy expressions
-                elif isinstance(value, (list, tuple)) and all(isinstance(x, (sympy.Basic, int, float)) for x in value):
-                    result.append(f"{name} = {value}")
-            except:
-                continue
-        
-        # Add printed output if it exists and isn't just whitespace
-        if printed_output and not printed_output.isspace():
-            result.insert(0, printed_output)
-        
-        # If we have no results, provide a message
-        if not result:
-            return "No calculation results produced."
-        
-        return "\n".join(result)
-    
-    except Exception as e:
-        return f"Error executing SymPy code: {str(e)}"
+       # Create a string buffer to capture print output
+       output_buffer = io.StringIO()
+       
+       # Create globals dict with minimal SymPy elements
+       sympy_globals = {
+           "Symbol": sympy.Symbol,
+           "symbols": sympy.symbols,
+           "solve": sympy.solve,
+           "integrate": sympy.integrate,
+           "diff": sympy.diff,
+           "limit": sympy.limit,
+           "sqrt": sympy.sqrt,
+           "exp": sympy.exp,
+           "simplify": sympy.simplify,
+           "expand": sympy.expand,
+           "log": sympy.log, 
+           "print": print,  # Allow print statements
+           "pi": sympy.pi,
+           "N": sympy.N,
+           "evalf": lambda x: x.evalf()
+       }
+       
+       # Create locals dict to capture new variables
+       local_vars = {}
 
+       # Execute the code and capture output
+       with redirect_stdout(output_buffer):
+           exec(sympy_code, sympy_globals, local_vars)
+       
+       # Get the printed output
+       printed_output = output_buffer.getvalue().strip()
+       
+       # Initialize result string
+       result = []
+       
+       # Add numerical and symbolic calculation results
+       for name, value in local_vars.items():
+           # Skip private variables and functions
+           if name.startswith('__') or callable(value) or isinstance(value, type):
+               continue
+               
+           # Skip module references
+           if hasattr(value, '__module__'):
+               continue
+               
+           try:
+               # If it's a sympy expression or numerical result
+               if isinstance(value, (sympy.Basic, int, float)) or hasattr(value, 'free_symbols'):
+                   result.append(f"{name} = {value}")
+               # If it's a list of solutions from solve()
+               elif isinstance(value, list):
+                   result.append(f"{name} = {value}")
+               # If it's a list or tuple of sympy expressions
+               elif isinstance(value, (list, tuple)) and all(isinstance(x, (sympy.Basic, int, float)) for x in value):
+                   result.append(f"{name} = {value}")
+           except:
+               continue
+       
+       # Add printed output if it exists and isn't just whitespace
+       if printed_output and not printed_output.isspace():
+           result.insert(0, printed_output)
+       
+       # If we have no results, provide a message
+       if not result:
+           return "No calculation results produced."
+       
+       return "\n".join(result)
+   
+   except Exception as e:
+       return f"Error executing SymPy code: {str(e)}"
+       
 def check_and_resolve_discrepancy(initial_response, sympy_output):
     """
     Compare the SymPy output with the initial response and resolve any discrepancies