Update app.py

app.py

@@ -319,105 +319,50 @@ 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
+        # 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:
-            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 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 output buffer
+        # Create a string buffer to capture print output
         import io
         import sys
         from contextlib import redirect_stdout
-        output_buffer = io.StringIO()
         
-        # Import SymPy 
-        import sympy
-        
-        # Create globals dict with SymPy module
-        globals_dict = {
-            '__builtins__': __builtins__,
-            'Symbol': sympy.Symbol,
-            'symbols': sympy.symbols,
-            'solve': sympy.solve,
-            'diff': sympy.diff,
-            'integrate': sympy.integrate,
-            'limit': sympy.limit,
-            'oo': sympy.oo,
-            'Sum': sympy.Sum,
-            'simplify': sympy.simplify,
-            'expand': sympy.expand,
-            'factor': sympy.factor,
-            'sin': sympy.sin,
-            'cos': sympy.cos,
-            'tan': sympy.tan,
-            'exp': sympy.exp,
-            'log': sympy.log,
-            'sqrt': sympy.sqrt,
-            'pi': sympy.pi
-        }
+        # Create string buffer for output
+        output_buffer = io.StringIO()
         
-        logger.debug(f"Globals dictionary contains: {list(globals_dict.keys())}")
+        # Create globals dict with all SymPy symbols
+        sympy_globals = {}
+        sympy_globals.update({name: getattr(sympy, name) for name in dir(sympy)})
         
-        # Create locals dict to store variables
+        # Create locals dict to capture new variables
         local_vars = {}
         
-        # Execute the code and capture its output
-        try:
-            with redirect_stdout(output_buffer):
-                exec(sympy_code, globals_dict, local_vars)
-            stdout_output = output_buffer.getvalue()
-            logger.debug(f"Code execution stdout: {stdout_output}")
-        except Exception as e:
-            logger.error(f"Error during code execution: {str(e)}")
-            return f"Error executing code: {str(e)}"
+        # Execute the original code
+        exec(sympy_code, sympy_globals, local_vars)
         
-        # Format the final output
-        output_lines = ["SymPy Calculation Results:", "-" * 25]
+        # Print all variables that were created (excluding built-ins and modules)
+        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__'):
+                    print(f"{var_name}: {value}")
         
-        # Add stdout if there was any
-        if stdout_output.strip():
-            output_lines.extend(["", "Output:", stdout_output.strip()])
-        
-        # Add variables
-        output_lines.extend(["", "Variables:"])
-        for name, value in local_vars.items():
-            if not name.startswith('__') and not hasattr(value, '__module__'):
-                output_lines.append(f"{name} = {value}")
-        
-        # Join all lines
-        final_output = "\n".join(output_lines)
-        logger.debug(f"Final formatted output:\n{final_output}")
-        
-        return final_output
+        return output_buffer.getvalue()
         
     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
 with gr.Blocks() as interface:
     gr.Markdown("# Advanced Mathematics Question Generator")