Update app.py

app.py

@@ -319,56 +319,83 @@ def extract_and_run_sympy_code(response_text):
     Returns the execution output as a string.
     """
     try:
+        logger.debug("Starting SymPy code extraction")
+        
         # Find the SymPy code block
         sympy_start = response_text.find('```python')
         if sympy_start == -1:
+            logger.debug("No SymPy code block found")
             return "No SymPy code found in the response."
         
-        # Extract the code (excluding the ```python and ``` markers)
+        # Extract the code
         code_start = response_text.find('\n', sympy_start) + 1
         code_end = response_text.find('```', code_start)
         if code_end == -1:
+            logger.debug("Malformed code block - couldn't find ending ```")
             return "Malformed SymPy code block."
         
         sympy_code = response_text[code_start:code_end].strip()
+        logger.debug(f"Extracted code:\n{sympy_code}")
         
-        # Remove any sympy import lines since we've already imported everything
-        sympy_code = '\n'.join(line for line in sympy_code.split('\n') 
-                              if not line.strip().startswith('from sympy') 
-                              and not line.strip().startswith('import sympy'))
+        # Remove sympy imports
+        original_lines = sympy_code.split('\n')
+        filtered_lines = [line for line in original_lines 
+                         if not line.strip().startswith('from sympy') 
+                         and not line.strip().startswith('import sympy')]
+        sympy_code = '\n'.join(filtered_lines)
+        logger.debug(f"Code after removing imports:\n{sympy_code}")
         
-        # Create a string buffer to capture print output
-        import io
-        import sys
-        from contextlib import redirect_stdout
+        # Create globals dict
+        sympy_globals = {
+            'sympy': sympy,
+            '__builtins__': __builtins__
+        }
         
-        # Create string buffer for output
-        output_buffer = io.StringIO()
+        # Add all sympy attributes
+        for name in dir(sympy):
+            sympy_globals[name] = getattr(sympy, name)
         
-        # Create globals dict with all SymPy symbols and add sympy module itself
-        sympy_globals = {'sympy': sympy}  # Add sympy module itself
-        sympy_globals.update({name: getattr(sympy, name) for name in dir(sympy)})
-        sympy_globals['__builtins__'] = __builtins__  # Add built-ins
+        logger.debug(f"Global namespace keys: {list(sympy_globals.keys())}")
         
-        # Create locals dict to capture new variables
+        # Create locals dict and output buffer
         local_vars = {}
+        output_buffer = io.StringIO()
+        
+        logger.debug("Attempting to execute code")
+        # Execute with try/except to catch specific error
+        try:
+            exec(sympy_code, sympy_globals, local_vars)
+        except NameError as e:
+            logger.error(f"NameError during execution: {str(e)}")
+            # Log the actual error traceback
+            import traceback
+            logger.error(f"Full traceback:\n{traceback.format_exc()}")
+            return f"Error executing SymPy code: {str(e)}"
+        except Exception as e:
+            logger.error(f"Other error during execution: {str(e)}")
+            return f"Error executing SymPy code: {str(e)}"
         
-        # Execute the original code
-        exec(sympy_code, sympy_globals, local_vars)
+        logger.debug("Code executed successfully")
+        logger.debug(f"Local variables created: {list(local_vars.keys())}")
         
-        # Print all variables that were created (excluding built-ins and modules)
+        # Print results
         with redirect_stdout(output_buffer):
             print("SymPy Calculation Results:")
             print("-" * 25)
             for var_name, value in local_vars.items():
                 if (not var_name.startswith('__') and 
                     not hasattr(value, '__module__') and 
-                    var_name != 'sympy'):  # Don't print the sympy module itself
+                    var_name != 'sympy'):
                     print(f"{var_name}: {value}")
         
-        return output_buffer.getvalue()
+        result = output_buffer.getvalue()
+        logger.debug(f"Final output:\n{result}")
+        return result
         
     except Exception as e:
+        logger.error(f"Top-level error in extract_and_run_sympy_code: {str(e)}")
+        import traceback
+        logger.error(f"Full traceback:\n{traceback.format_exc()}")
         return f"Error executing SymPy code: {str(e)}"
         
 # Create Gradio interface