Upload app.py

app.py

@@ -20,6 +20,10 @@ from sympy.parsing.sympy_parser import (
     implicit_multiplication_application
 )
 import re  # MUST be last — 'from sympy import *' would overwrite re otherwise
+import matplotlib
+matplotlib.use('Agg')  # non-interactive backend — required on HuggingFace Spaces
+import matplotlib.pyplot as plt
+import numpy as np
 
 # ── Page config ──────────────────────────────────────────────────────
 st.set_page_config(
@@ -1475,6 +1479,158 @@ def run_sympy(problem: str) -> dict:
 
     return {"type": "general", "result": None, "latex": ""}
 
+# ════════════════════════════════════════════════════════════════════
+# GRAPH PLOTTING — only when user asks to plot/graph/draw/visualize
+# ════════════════════════════════════════════════════════════════════
+def plot_graph(problem: str, sympy_info: dict):
+    """
+    Plot graph only when user explicitly requests it.
+    Keywords: plot, graph, draw, sketch, visualize, show graph.
+    Supports: single function, derivative overlay, ODE solution, equation roots.
+    Safe fallback — never crashes the app.
+    """
+    p = problem.lower().strip()
+
+    # ── Only trigger on explicit plot keywords ──────────────────────
+    if not any(k in p for k in ["plot", "graph", "draw",
+                                  "sketch", "visualize", "show graph"]):
+        return  # user didn't ask for graph — do nothing
+
+    try:
+        x_sym = sp.Symbol('x')
+        tfms  = standard_transformations + (implicit_multiplication_application,)
+        ld    = {
+            "x": x_sym, "e": sp.E, "E": sp.E,
+            "pi": sp.pi, "PI": sp.pi,
+            "sin": sp.sin, "cos": sp.cos, "tan": sp.tan,
+            "exp": sp.exp, "log": sp.log, "ln": sp.log,
+            "sqrt": sp.sqrt
+        }
+
+        def clean_expr(s):
+            s = re.sub(r"\s+", "", s)
+            s = re.sub(r"\^", "**", s)
+            return s
+
+        # ── Extract expression from problem ─────────────────────────
+        expr_sym = None
+        label    = ""
+
+        # Try to extract from sympy_info first (already parsed)
+        if sympy_info.get("type") in ["Derivative", "Integral", "Equation",
+                                       "ODE", "Limit", "Curvature"]:
+            # Extract f(x) from problem text
+            for kw in ["plot", "graph", "draw", "sketch", "visualize",
+                       "of", "for", "function"]:
+                parts = p.split(kw, 1)
+                if len(parts) > 1:
+                    raw = parts[1].strip()
+                    raw = re.sub(r"\s*(dx|with\s*respect.*|at\s+x.*)$", "", raw).strip()
+                    raw = clean_expr(raw)
+                    if raw:
+                        try:
+                            expr_sym = parse_expr(raw, transformations=tfms,
+                                                  local_dict=ld)
+                            label = raw
+                            break
+                        except Exception:
+                            continue
+
+        # Fallback — extract any f(x) = ... or just expression
+        if expr_sym is None:
+            m = re.search(r"(?:f\s*\(x\)\s*=\s*|y\s*=\s*|of\s+|plot\s+|graph\s+|draw\s+)"
+                          r"([^\s,]+(?:\s*[\+\-\*/\^]\s*[^\s,]+)*)", p)
+            if m:
+                raw = clean_expr(m.group(1).strip())
+                try:
+                    expr_sym = parse_expr(raw, transformations=tfms, local_dict=ld)
+                    label = raw
+                except Exception:
+                    pass
+
+        if expr_sym is None:
+            st.info("📊 Could not extract a plottable expression. "
+                    "Try: *plot f(x) = x^2 + 3x - 4*")
+            return
+
+        # ── Determine x range ────────────────────────────────────────
+        x_range_m = re.search(
+            r"(?:from|for|on|between)\s*([-\d\.]+)\s*(?:to|and)\s*([-\d\.]+)", p)
+        if x_range_m:
+            x_min = float(x_range_m.group(1))
+            x_max = float(x_range_m.group(2))
+        else:
+            x_min, x_max = -10, 10  # default range
+
+        # ── Lambdify for fast numpy evaluation ───────────────────────
+        f_num  = sp.lambdify(x_sym, expr_sym, modules=["numpy"])
+        df_sym = sp.diff(expr_sym, x_sym)
+        df_num = sp.lambdify(x_sym, df_sym, modules=["numpy"])
+
+        x_vals = np.linspace(x_min, x_max, 800)
+
+        # Safe evaluation — replace infinities/errors with NaN
+        with np.errstate(all='ignore'):
+            y_vals  = np.array(f_num(x_vals),  dtype=float)
+            dy_vals = np.array(df_num(x_vals), dtype=float)
+
+        y_vals[~np.isfinite(y_vals)]   = np.nan
+        dy_vals[~np.isfinite(dy_vals)] = np.nan
+
+        # ── Build plot ───────────────────────────────────────────────
+        fig, ax = plt.subplots(figsize=(8, 4))
+        fig.patch.set_facecolor('#0f0f0f')
+        ax.set_facecolor('#1a1a1a')
+
+        # Plot f(x)
+        ax.plot(x_vals, y_vals, color='#3b82f6', linewidth=2,
+                label=f'$f(x) = {sp.latex(expr_sym)}$')
+
+        # If derivative type — also plot f'(x)
+        if sympy_info.get("type") == "Derivative":
+            ax.plot(x_vals, dy_vals, color='#f59e0b', linewidth=1.8,
+                    linestyle='--', label=f"$f'(x) = {sp.latex(df_sym)}$")
+
+        # x and y axes
+        ax.axhline(0, color='#444', linewidth=0.8)
+        ax.axvline(0, color='#444', linewidth=0.8)
+
+        # Grid
+        ax.grid(True, color='#2a2a2a', linewidth=0.6, linestyle='--')
+
+        # Labels and title
+        ax.set_xlabel('x', color='#ececec', fontsize=11)
+        ax.set_ylabel('y', color='#ececec', fontsize=11)
+        ax.set_title(f'Graph of $f(x) = {sp.latex(expr_sym)}$',
+                     color='#ffffff', fontsize=12, pad=10)
+
+        # Tick colors
+        ax.tick_params(colors='#888', labelsize=9)
+        for spine in ax.spines.values():
+            spine.set_edgecolor('#2a2a2a')
+
+        # Legend
+        ax.legend(facecolor='#1a1a1a', edgecolor='#2a2a2a',
+                  labelcolor='#ececec', fontsize=9)
+
+        # Smart y-axis limits — ignore outliers
+        valid_y = y_vals[np.isfinite(y_vals)]
+        if len(valid_y) > 0:
+            y_med   = np.median(valid_y)
+            y_std   = np.std(valid_y)
+            y_lo    = max(valid_y.min(), y_med - 5*y_std)
+            y_hi    = min(valid_y.max(), y_med + 5*y_std)
+            padding = (y_hi - y_lo) * 0.1 if y_hi != y_lo else 1
+            ax.set_ylim(y_lo - padding, y_hi + padding)
+
+        plt.tight_layout()
+        st.pyplot(fig)
+        plt.close(fig)  # free memory
+
+    except Exception:
+        pass  # silent fallback — never crash the app
+
+
 # ════════════════════════════════════════════════════════════════════
 # GROQ API — free, fast, Llama 3.3 70B
 # ════════════════════════════════════════════════════════════════════
@@ -1667,7 +1823,7 @@ def ask_ai(problem: str, sympy_info: dict, history: list) -> str:
         "C. State exact trig values directly: $\\sin(\\pi)=0$, $\\cos(\\pi)=-1$ — never recompute.\n"
         "D. For Lagrange/Newton interpolation: DO NOT re-derive the polynomial.\n"
         "   Show basis polynomials then state final polynomial from the verified result.\n"
-        "E. For Euler/RK4: show k-values at each step then give y_{n+1}.\n\n"
+        "E. For Euler/RK4: show k-values at each step then give $y_{n+1}$.\n\n"
 
         "=== THEORY OF NUMBERS RULES ===\n"
         "A. For congruences $ax \\equiv b \\pmod{n}$: always show full Euclidean algorithm steps.\n"
@@ -2015,6 +2171,9 @@ if problem and problem != st.session_state.last_submitted:
         # Step 2: Stream AI response word by word
         answer = ask_ai_streaming(problem, sympy_result, st.session_state.messages)
 
+        # Step 3: Plot graph if user asked for it
+        plot_graph(problem, sympy_result)
+
     # Save to history
     st.session_state.messages.append({"role": "user", "content": problem})
     st.session_state.messages.append({"role": "assistant", "content": answer})