Update app.py

app.py

@@ -50,27 +50,27 @@ def clean_latex(latex):
     latex = latex.replace('e', '2.7183')
     return latex
 
-def request_llm_fallback(bad_latex, llm_url):
-    pre_cleaned = re.sub(r'(\\!?pm|\\not=?|\\!|\\L|\\perp|\\bar|\\Sigma|\\boldmath|G|L(?=\^))', '', bad_latex)
-    try:
-        response = requests.post(f"{llm_url}/clean", json={"prompt": pre_cleaned})
-        if response.status_code == 200:
-            return response.json().get("cleaned_latex", pre_cleaned)
-    except Exception as e:
-        print(f"LLM fallback failed: {e}")
-    return pre_cleaned
-
-def request_llm_explanation(prompt, llm_url):
-    try:
-        response = requests.post(f"{llm_url}/explain", json={"prompt": prompt})
-        if response.status_code == 200:
-            return response.json().get("explanation", "❌ No explanation returned.")
-        else:
-            return f"❌ LLM explanation failed: {response.status_code}"
-    except Exception as e:
-        return f"❌ LLM explanation error: {e}"
-
-def solve_polynomial(image, llm_url):
+# def request_llm_fallback(bad_latex, llm_url):
+#     pre_cleaned = re.sub(r'(\\!?pm|\\not=?|\\!|\\L|\\perp|\\bar|\\Sigma|\\boldmath|G|L(?=\^))', '', bad_latex)
+#     try:
+#         response = requests.post(f"{llm_url}/clean", json={"prompt": pre_cleaned})
+#         if response.status_code == 200:
+#             return response.json().get("cleaned_latex", pre_cleaned)
+#     except Exception as e:
+#         print(f"LLM fallback failed: {e}")
+#     return pre_cleaned
+
+# def request_llm_explanation(prompt, llm_url):
+#     try:
+#         response = requests.post(f"{llm_url}/explain", json={"prompt": prompt})
+#         if response.status_code == 200:
+#             return response.json().get("explanation", "❌ No explanation returned.")
+#         else:
+#             return f"❌ LLM explanation failed: {response.status_code}"
+#     except Exception as e:
+#         return f"❌ LLM explanation error: {e}"
+
+def solve_polynomial(image):  # removed llm_url
     try:
         img = preprocess_handwritten_image(image)
         latex_result = model(img)
@@ -86,18 +86,10 @@ def solve_polynomial(image, llm_url):
             if not lhs.is_polynomial():
                 raise ValueError("Not a polynomial")
         except:
-            fixed_latex = request_llm_fallback(cleaned_latex, llm_url)
-            cleaned_latex = clean_latex(fixed_latex)
-            try:
-                expr = parse_latex(cleaned_latex)
-                expr = expr.subs(sp.pi, sp.Float(3.1416)).subs(sp.E, sp.Float(2.7183))
-                if not isinstance(expr, sp.Equality):
-                    raise ValueError("Expression is not an equation.")
-                lhs = expr.lhs - expr.rhs
-                if not lhs.is_polynomial():
-                    raise ValueError("Not a polynomial")
-            except:
-                return f"❌ Could not parse expression after fallback:\n\n```latex\n{cleaned_latex}\n```", cleaned_latex, ""
+            # Commented out LLM fallback
+            # fixed_latex = request_llm_fallback(cleaned_latex, llm_url)
+            # cleaned_latex = clean_latex(fixed_latex)
+            return f"❌ Could not parse expression:\n\n```latex\n{cleaned_latex}\n```", cleaned_latex, ""
 
         output = f"## 📄 Extracted LaTeX\n```latex\n{latex_result}\n```\n"
         output += f"---\n## 🧹 Cleaned LaTeX\n```latex\n{cleaned_latex}\n```\n"
@@ -112,121 +104,82 @@ def solve_polynomial(image, llm_url):
         roots = sp.solve(lhs, x)
         output += "## ✅ Roots\n"
         output += "$$\n\\begin{aligned}\n"
-        root_strs = []
         for i, r in enumerate(roots, 1):
             root_val = sp.N(r, 6)
             output += f"\\text{{Root {i}}}:\\quad x &\\approx {sp.latex(root_val)} \\\\\n"
-            root_strs.append(str(root_val))
         output += "\\end{aligned}\n$$\n"
 
-        # 👇 Build structured prompt
-        prompt = ""
-        try:
-            coeffs = sp.Poly(lhs, x).all_coeffs()
-            if len(coeffs) == 3:
-                a, b, c = [float(k) for k in coeffs]
-                prod = a * c
-                found = False
-                for m in range(-100, 101):
-                    if m == 0 or prod % m != 0:
-                        continue
-                    n = prod / m
-                    if m + n == b:
-                        found = True
-                        prompt = (
-                            f"Equation: {lhs} = 0\n"
-                            f"Factor: {factor} = 0\n"
-                            f"Roots: {root_strs}\n\n"
-                            f"This was solved using middle-term factorization:\n"
-                            f"a = {a}, b = {b}, c = {c}, a*c = {prod}. "
-                            f"{m} and {n} satisfy m*n = ac and m+n = b.\n"
-                            f"Explain the process step-by-step in friendly, simple language."
-                        )
-                        break
-                if not found:
-                    raise Exception("No middle term")
-            else:
-                raise Exception("Not quadratic")
-        except:
-            prompt = (
-                f"Equation: {lhs} = 0\n"
-                f"Factor: {factor} = 0\n"
-                f"Roots: {root_strs}\n\n"
-                f"This was solved using the quadratic formula (Sreedhar Acharya method). "
-                f"Explain the process step-by-step in friendly, simple language."
-            )
-
-        return output, cleaned_latex, prompt
+        return output, cleaned_latex, ""
     except Exception as e:
         return f"❌ Error: {str(e)}", "", ""
 
-def wrapped_solver(img, url):
-    result, cleaned, prompt = solve_polynomial(img, url)
+def wrapped_solver(img):  # removed url
+    result, cleaned, prompt = solve_polynomial(img)
     return result, cleaned, prompt
 
-def solve_from_coeffs(degree, coeff_str):
-    try:
-        coeffs = [float(c.strip()) for c in coeff_str.split(",")]
-        if len(coeffs) != int(degree) + 1:
-            return f"❌ You entered {len(coeffs)} coefficients, but degree {degree} needs {int(degree)+1}.", ""
-
-        x = sp.Symbol("x")
-        poly_expr = sum(coeffs[i] * x**(int(degree) - i) for i in range(len(coeffs)))
-        factored = sp.factor(poly_expr)
-        roots = sp.solve(poly_expr, x)
-
-        result = "## 🧮 Symbolic Roots:\n"
-        for i, r in enumerate(roots, 1):
-            result += f"- Root {i}: $${sp.latex(sp.N(r, 6))}$$\n"
-
-        terms = []
-        for i, c in enumerate(coeffs):
-            power = int(degree) - i
-            if power == 0:
-                terms.append(f"{c}")
-            elif power == 1:
-                terms.append(f"{c}x")
-            else:
-                terms.append(f"{c}x^{power}")
-        equation_str = " + ".join(terms).replace("+ -", "- ") + " = 0"
-        roots_str = f"[{', '.join(str(sp.N(r, 6)) for r in roots)}]"
-        factored_str = sp.pretty(factored)
-
-        llm_prompt = (
-            f"Equation: {equation_str}\n"
-            f"Factor: {factored_str} = 0\n"
-            f"Roots: {roots_str}\n\n"
-            "Explain the solution step-by-step in human language. "
-            "These roots are correct (up to approximation), so base your reasoning on them."
-        )
-
-        return result, llm_prompt
-    except Exception as e:
-        return f"❌ Error: {str(e)}", ""
+# def solve_from_coeffs(degree, coeff_str):
+#     try:
+#         coeffs = [float(c.strip()) for c in coeff_str.split(",")]
+#         if len(coeffs) != int(degree) + 1:
+#             return f"❌ You entered {len(coeffs)} coefficients, but degree {degree} needs {int(degree)+1}.", ""
+
+#         x = sp.Symbol("x")
+#         poly_expr = sum(coeffs[i] * x**(int(degree) - i) for i in range(len(coeffs)))
+#         factored = sp.factor(poly_expr)
+#         roots = sp.solve(poly_expr, x)
+
+#         result = "## 🧮 Symbolic Roots:\n"
+#         for i, r in enumerate(roots, 1):
+#             result += f"- Root {i}: $${sp.latex(sp.N(r, 6))}$$\n"
+
+#         terms = []
+#         for i, c in enumerate(coeffs):
+#             power = int(degree) - i
+#             if power == 0:
+#                 terms.append(f"{c}")
+#             elif power == 1:
+#                 terms.append(f"{c}x")
+#             else:
+#                 terms.append(f"{c}x^{power}")
+#         equation_str = " + ".join(terms).replace("+ -", "- ") + " = 0"
+#         roots_str = f"[{', '.join(str(sp.N(r, 6)) for r in roots)}]"
+#         factored_str = sp.pretty(factored)
+
+#         llm_prompt = (
+#             f"Equation: {equation_str}\n"
+#             f"Factor: {factored_str} = 0\n"
+#             f"Roots: {roots_str}\n\n"
+#             "Explain the solution step-by-step in human language. "
+#             "These roots are correct (up to approximation), so base your reasoning on them."
+#         )
+
+#         return result, llm_prompt
+#     except Exception as e:
+#         return f"❌ Error: {str(e)}", ""
 
 with gr.Blocks() as demo:
     with gr.Tab("🖼️ Parse from Image"):
-        llm_url = gr.Textbox(label="🔗 Enter LLM Microservice URL (from Colab)", placeholder="https://xxxx.ngrok-free.app")
+        # llm_url = gr.Textbox(label="🔗 Enter LLM Microservice URL (from Colab)", placeholder="https://xxxx.ngrok-free.app")
         image_input = gr.Image(type="pil", label="📷 Upload Image of Polynomial")
         hidden_latex = gr.Textbox(visible=False)
         explanation_prompt = gr.Textbox(visible=False)
         output_box = gr.Markdown(label="📋 Step-by-step Solution")
         submit_btn = gr.Button("🔍 Solve")
-        submit_btn.click(fn=wrapped_solver, inputs=[image_input, llm_url], outputs=[output_box, hidden_latex, explanation_prompt])
-        explain_box = gr.Markdown(label="🗣️ Human-style Explanation")
-        explain_btn = gr.Button("🧠 Explain Human-Solution")
-        explain_btn.click(fn=request_llm_explanation, inputs=[explanation_prompt, llm_url], outputs=explain_box)
-
-    with gr.Tab("🧮 Solve by Coefficients"):
-        degree_input = gr.Number(label="Enter Degree of Polynomial (e.g. 3)")
-        coeffs_input = gr.Textbox(label="Enter Coefficients (comma-separated)", placeholder="e.g. 1, 2, 0, -4")
-        roots_output = gr.Markdown(label="✅ Roots")
-        coeff_hidden_equation = gr.Textbox(visible=False)
-        coeff_btn = gr.Button("📌 Solve")
-        coeff_btn.click(fn=solve_from_coeffs, inputs=[degree_input, coeffs_input], outputs=[roots_output, coeff_hidden_equation])
-        coeff_explain_box = gr.Markdown(label="🗣️ Human-style Explanation")
-        coeff_explain_btn = gr.Button("🧠 Explain Human-Solution")
-        coeff_explain_btn.click(fn=request_llm_explanation, inputs=[coeff_hidden_equation, llm_url], outputs=coeff_explain_box)
+        submit_btn.click(fn=wrapped_solver, inputs=[image_input], outputs=[output_box, hidden_latex, explanation_prompt])
+        # explain_box = gr.Markdown(label="🗣️ Human-style Explanation")
+        # explain_btn = gr.Button("🧠 Explain Human-Solution")
+        # explain_btn.click(fn=request_llm_explanation, inputs=[explanation_prompt, llm_url], outputs=explain_box)
+
+    # with gr.Tab("🧮 Solve by Coefficients"):
+    #     degree_input = gr.Number(label="Enter Degree of Polynomial (e.g. 3)")
+    #     coeffs_input = gr.Textbox(label="Enter Coefficients (comma-separated)", placeholder="e.g. 1, 2, 0, -4")
+    #     roots_output = gr.Markdown(label="✅ Roots")
+    #     coeff_hidden_equation = gr.Textbox(visible=False)
+    #     coeff_btn = gr.Button("📌 Solve")
+    #     coeff_btn.click(fn=solve_from_coeffs, inputs=[degree_input, coeffs_input], outputs=[roots_output, coeff_hidden_equation])
+    #     coeff_explain_box = gr.Markdown(label="🗣️ Human-style Explanation")
+    #     coeff_explain_btn = gr.Button("🧠 Explain Human-Solution")
+    #     coeff_explain_btn.click(fn=request_llm_explanation, inputs=[coeff_hidden_equation, llm_url], outputs=coeff_explain_box)
 
 if __name__ == "__main__":
     demo.launch()