Update services/math_kernel.py

services/math_kernel.py

@@ -1,146 +1,58 @@
 # services/math_kernel.py
-from typing import Any, Dict, Optional
-from dataclasses import dataclass
-from sympy import symbols, Eq, sympify, solve, diff, integrate, sqrt, series
-from sympy import Matrix
-from sympy.parsing.sympy_parser import standard_transformations, convert_xor, implicit_multiplication_application
-from sympy.parsing.sympy_parser import parse_expr
-from sympy.physics.units import G, c
-from sympy import S
-import mpmath as mp
-
-# Optional: small map of physical constants one might use
-CONSTS = {
-    "G": G,   # gravitational constant
-    "c": c,   # speed of light
-}
-
-SAFE_NAMES = {
-    "sqrt": sqrt,
-    "Eq": Eq,
-    # add more SymPy callables if needed
+from typing import Dict, Any, List, Optional
+import sympy as sp
+from sympy.parsing.sympy_parser import (
+    parse_expr, standard_transformations, convert_xor, implicit_multiplication_application
+)
+
+TRANSFORMS = standard_transformations + (convert_xor, implicit_multiplication_application)
+
+SAFE_FUNCS = {
+    "sin": sp.sin, "cos": sp.cos, "tan": sp.tan, "exp": sp.exp, "log": sp.log,
+    "sqrt": sp.sqrt, "Eq": sp.Eq, "diff": sp.diff, "integrate": sp.integrate,
+    "Symbol": sp.Symbol
 }
 
-TRANSFORMS = (standard_transformations + (convert_xor, implicit_multiplication_application))
-
-@dataclass
-class MathPayload:
-    task: str                      # "symbolic" | "numeric"
-    expr: Optional[str] = None     # sympy-string expression, e.g. "Eq(1/sqrt(1-2*G*M/(c**2*r)), 1+z)"
-    solve_for: Optional[list] = None
-    subs: Optional[Dict[str, Any]] = None    # e.g. {"M":"10","r":"4*rs"}; you can keep this symbolic too
-    series_var: Optional[str] = None         # e.g. "x"
-    series_point: Optional[Any] = None       # e.g. 0
-    series_order: int = 3
-
 def _parse(s: str):
-    # parse a sympy string safely with limited names
-    local_dict = {**SAFE_NAMES, **CONSTS}
-    return parse_expr(s, local_dict=local_dict, transformations=TRANSFORMS)
-
-def _sym(v):
-    return symbols(v)
+    return parse_expr(s, local_dict=SAFE_FUNCS, transformations=TRANSFORMS)
 
-def compute(payload: Dict[str, Any]) -> Dict[str, Any]:
+def compute(task: str, expr: str, solve_for: Optional[List[str]] = None, subs: Optional[Dict[str, Any]] = None):
     """
-    payload:
-      task: "symbolic" | "numeric"
-      expr: sympy-string expression (equation or expression)
-      solve_for: [list of symbol names]
-      subs: dict of substitutions (numbers or sympy-strings)
-      series_var, series_point, series_order: optional series expansion controls
-
-    returns:
-      {
-        "steps": [str, ...],
-        "symbolic": str,         # final sympy string
-        "numeric": {"value": float, "note": str} | null,
-        "interpretation": str
-      }
+    task: 'symbolic' | 'numeric'
+    expr: SymPy string or Eq(...)
+    solve_for: symbols to solve for
+    subs: dict like {"M":"1.0", "r":"4"} (strings parsed via SymPy)
     """
-    steps = []
-    try:
-        mp.mp.dps = 50  # high precision numeric eval
-        task = payload.get("task", "symbolic")
-        expr_s = payload.get("expr", "")
-        solve_for = payload.get("solve_for") or []
-        subs_in = payload.get("subs") or {}
-        series_var = payload.get("series_var")
-        series_point = payload.get("series_point", 0)
-        series_order = int(payload.get("series_order", 3))
+    out = {"steps": [], "symbolic": None, "numeric": None, "interpretation": ""}
 
-        if not expr_s:
-            return {"steps": steps, "symbolic": "", "numeric": None, "interpretation": "No expression provided."}
-
-        # parse the main expression
-        expr = _parse(expr_s)
-        steps.append(f"Parsed expression: {expr!s}")
-
-        # normalize substitutions into SymPy objects
-        subs = {}
-        for k, v in subs_in.items():
-            if isinstance(v, (int, float)):
-                subs[k] = S(v)
-            elif isinstance(v, str):
-                subs[k] = _parse(v)
-            else:
-                subs[k] = v
-
-        # If it's an equation and we have solve_for
-        result_sym = expr
-        if solve_for:
-            syms = [symbols(n) for n in solve_for]
-            steps.append(f"Solving for: {', '.join(solve_for)}")
-            sol = solve(expr, *syms, dict=True)
-            steps.append(f"Raw solution: {sol!r}")
-            result_sym = sol
+    try:
+        e = _parse(expr)
+        out["steps"].append(f"Parsed: {e}")
 
-        # Apply substitutions (symbolic)
         if subs:
-            steps.append(f"Applying substitutions: { {k:str(v) for k,v in subs.items()} }")
-            if isinstance(result_sym, list):
-                result_sym = [{k: (vv.subs(subs) if hasattr(vv, 'subs') else vv) for k, vv in d.items()} for d in result_sym]
-            else:
-                result_sym = result_sym.subs(subs)
-
-        # Optional series expansion (for expressions, not solution dicts)
-        if series_var and not isinstance(result_sym, list):
-            x = symbols(series_var)
-            steps.append(f"Series expansion in {series_var} around {series_point} to order {series_order}")
-            try:
-                result_sym = series(result_sym, x, series_point, series_order).removeO()
-            except Exception as _:
-                steps.append("Series expansion failed; leaving symbolic result unchanged.")
-
-        # Optional numeric evaluation
-        numeric_out = None
-        try:
-            to_eval = None
-            if isinstance(result_sym, list):
-                # try numeric evaluation of the first solution if it’s a scalar
-                if result_sym and isinstance(result_sym[0], dict):
-                    first = list(result_sym[0].values())[0]
-                    to_eval = first
+            sdict = {sp.Symbol(k): (_parse(v) if isinstance(v, str) else v) for k, v in subs.items()}
+            e = e.subs(sdict)
+            out["steps"].append(f"Substitutions: {sdict}")
+
+        if task == "symbolic":
+            if solve_for:
+                syms = [sp.Symbol(n) for n in solve_for]
+                sol = sp.solve(e, *syms, dict=True)
+                out["symbolic"] = str(sol)
+                out["interpretation"] = "Solved symbolically."
             else:
-                to_eval = result_sym
+                out["symbolic"] = str(sp.simplify(e))
+                out["interpretation"] = "Simplified symbolically."
 
-            if to_eval is not None and hasattr(to_eval, 'evalf'):
-                val = float(to_eval.evalf())
-                numeric_out = {"value": val, "note": "evalf() with high precision"}
-        except Exception as _:
-            pass
+        elif task == "numeric":
+            val = float(e.evalf())
+            out["numeric"] = {"value": val}
+            out["interpretation"] = "Numeric evaluation complete."
 
-        return {
-            "steps": steps,
-            "symbolic": str(result_sym),
-            "numeric": numeric_out,
-            "interpretation": "Mathematical computation completed."
-        }
+        else:
+            out["interpretation"] = "Unknown task."
 
-    except Exception as e:
-        return {
-            "steps": steps + [f"ERROR: {e}"],
-            "symbolic": "",
-            "numeric": None,
-            "interpretation": f"Computation failed: {e}"
-        }
+        return out
+    except Exception as err:
+        out["interpretation"] = f"Error: {err}"
+        return out