Update app.py

app.py

@@ -316,7 +316,8 @@ STRICT REQUIREMENTS:
 def extract_and_run_sympy_code(response_text):
     """
     Extract SymPy code from the response and execute it.
-    Returns the execution output as a string.
+    Returns only the essential calculation results as a string.
+    Filters out debugging info and module imports.
     """
     try:
         # Find the SymPy code block
@@ -340,29 +341,64 @@ def extract_and_run_sympy_code(response_text):
         # Create a string buffer to capture print output
         output_buffer = io.StringIO()
         
-        # Create globals dict with SymPy explicitly included
-        sympy_globals = {"sympy": sympy}
-        sympy_globals.update(vars(sympy))
+        # Create a clean globals dict with only essential SymPy components
+        sympy_globals = {
+            "Symbol": sympy.Symbol,
+            "symbols": sympy.symbols,
+            "solve": sympy.solve,
+            "integrate": sympy.integrate,
+            "diff": sympy.diff,
+            "limit": sympy.limit,
+            "sqrt": sympy.sqrt,
+            "simplify": sympy.simplify,
+            "expand": sympy.expand
+        }
         
         # Create locals dict to capture new variables
         local_vars = {}
 
-        # Redirect stdout and execute the code
+        # Execute the code and capture output
         with redirect_stdout(output_buffer):
             exec(sympy_code, sympy_globals, local_vars)
         
-        # Append the calculated variables to the output
-        output_buffer.write("\nSymPy Calculation Results:\n")
-        output_buffer.write("-" * 25 + "\n")
-        for var_name, value in local_vars.items():
-            if not var_name.startswith('__') and not hasattr(value, '__module__'):
-                output_buffer.write(f"{var_name}: {value}\n")
+        # Get the printed output
+        printed_output = output_buffer.getvalue().strip()
+        
+        # Filter the local variables to only include calculation results
+        # Exclude built-in variables, modules, and functions
+        calculation_results = {
+            name: value for name, value in local_vars.items()
+            if (
+                not name.startswith('__') and
+                not hasattr(value, '__call__') and  # Exclude functions
+                not hasattr(value, '__module__')    # Exclude modules
+            )
+        }
+        
+        # Build the final output string
+        result_parts = []
         
-        return output_buffer.getvalue()
+        # Add any printed output first
+        if printed_output:
+            result_parts.append(printed_output)
+        
+        # Add calculation results if there are any
+        if calculation_results:
+            if printed_output:  # Add a separator if we already have printed output
+                result_parts.append("\nCalculation Results:")
+                result_parts.append("-" * 20)
+            for var_name, value in calculation_results.items():
+                result_parts.append(f"{var_name} = {value}")
+        
+        # If we have no results at all, provide a message
+        if not result_parts:
+            return "No calculation results produced."
+        
+        return "\n".join(result_parts)
     
     except Exception as e:
         return f"Error executing SymPy code: {str(e)}"
-
+        
 # Create Gradio interface
 with gr.Blocks() as interface:
     gr.Markdown("# Advanced Mathematics Question Generator")