Update app.py

app.py

@@ -355,115 +355,7 @@ def extract_and_run_sympy_code_simple(response_text):
     
     except Exception as e:
         return f"Error executing SymPy code: {str(e)}"
-        
-        
-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()
-
-       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
                
-           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