Update app.py

app.py

@@ -30,13 +30,7 @@ request_history = deque(maxlen=1000)
 SYMPY_GUIDELINES = """
 When writing SymPy code to verify solutions:
 
-1. Imports and Library Usage:
-   - Start with: from sympy import *
-   - DO NOT use NumPy, SciPy, or other libraries
-   - For numerical integration, use integrate() instead of scipy.integrate.quad()
-   - For any numerical computations, use native SymPy functions only
-
-2. Variable Declaration and Functions:
+1. Variable Declaration and Functions:
    - Always define symbolic variables first, for example:
      ```python
      x, y, z = symbols('x y z')  # For multiple variables
@@ -45,7 +39,7 @@ When writing SymPy code to verify solutions:
    - Use Abs() for absolute value (not abs())
    - Define functions using Function() class when needed
 
-3. Solving and Computing:
+2. Solving and Computing:
    - Never use strings in solve() or other SymPy functions:
      CORRECT:   solve(eq, x)
      INCORRECT: solve(eq, 'x')
@@ -53,7 +47,7 @@ When writing SymPy code to verify solutions:
      CORRECT:   eq = 2*sqrt(h) - sqrt(12) + 5*k
      INCORRECT: eq = 2*sqrt('h') - sqrt(12) + 5*k
 
-4. Printing and Output:
+3. Printing and Output:
    - Include print statements for ALL calculations and results
    - Print intermediate steps and final answers
    - Print variable values after they are computed
@@ -64,7 +58,7 @@ When writing SymPy code to verify solutions:
      print(expression)
      ```
 
-5. Numeric Calculations:
+4. Numeric Calculations:
    - Use Float() for decimal numbers in calculations
    - Use float() for final printing of results
    - Avoid evalf() as it may cause errors
@@ -75,10 +69,10 @@ When writing SymPy code to verify solutions:
      print(float(result))
      ```
 
-6. Working with Series and Sequences:
+5. Working with Series and Sequences:
    - Use Float() for sequence terms
    - Convert sums to float() before printing
-   - For series calculations, print intermediate terms
+   - For series calculations, print intermediate terms   
    """
 
 
@@ -491,54 +485,37 @@ def extract_and_run_sympy_code_simple(response_text):
         
         sympy_code = response_text[code_start:code_end].strip()
         
-        # Add wrapper function to ensure proper symbol definitions
-        wrapper_code = """
-def run_sympy_verification():
-    # Import SymPy
-    from sympy import *
-    
-    # Define standard helper functions
-    def safe_print_expr(label, expr):
-        print(label)
-        if expr is not None:
-            try:
-                float_val = float(expr)
-                print(float_val)
-            except:
-                print(expr)
-
-    # Start user code
-"""
-        
-        # Indent the original code
-        indented_code = '\n'.join('    ' + line for line in sympy_code.split('\n'))
+        # Import SymPy at the module level
+        import sympy
         
-        # Add the execution call
-        full_code = wrapper_code + indented_code + "\n\n# Execute verification\nrun_sympy_verification()"
+        # Create globals dict with all SymPy functions
+        globals_dict = {}
+        globals_dict.update(vars(sympy))  # This adds all SymPy functions
+        globals_dict.update({
+            'print': print,
+            'float': float,
+            'Symbol': sympy.Symbol,
+            'symbols': sympy.symbols,
+            'solve': sympy.solve,
+            'sqrt': sympy.sqrt,
+            'pi': sympy.pi,
+            'diff': sympy.diff,
+            'integrate': sympy.integrate,
+            'simplify': sympy.simplify,
+        })
+        
+        # Remove the sympy import line from the code if present
+        lines = sympy_code.split('\n')
+        filtered_lines = [line for line in lines if not line.strip().startswith('from sympy import') and not line.strip().startswith('import sympy')]
+        modified_code = '\n'.join(filtered_lines)
         
-        # Set up basic SymPy environment
+        # Capture output
         import io
-        import sympy
         from contextlib import redirect_stdout
         
-        # Create a dictionary of allowed names
-        globals_dict = {
-            "sympy": sympy,
-            "Symbol": sympy.Symbol,
-            "solve": sympy.solve,
-            "sqrt": sympy.sqrt,
-            "pi": sympy.pi,
-            "diff": sympy.diff,
-            "integrate": sympy.integrate,
-            "simplify": sympy.simplify,
-            "print": print,
-            "float": float
-        }
-        
-        # Capture output
         output_buffer = io.StringIO()
         with redirect_stdout(output_buffer):
-            exec(full_code, globals_dict)
+            exec(modified_code, globals_dict)
             
         return output_buffer.getvalue().strip() or "No output produced"