Update quant_solver.py

quant_solver.py

@@ -1,185 +1,130 @@
 from __future__ import annotations
 
-import math
-import re
-from statistics import mean, median
-from typing import Dict, Optional
+from typing import List, Optional
 
 try:
-    import sympy as sp
+    from transformers import pipeline
 except Exception:
-    sp = None
-
-from models import SolverResult
-from utils import clean_math_text, normalize_spaces
-
-
-def extract_choices(text: str) -> Dict[str, str]:
-    text = text or ""
-    matches = list(
-        re.finditer(
-            r"(?i)\b([A-E])[\)\.:]\s*(.*?)(?=\s+\b[A-E][\)\.:]\s*|$)",
-            text,
-        )
-    )
-    return {m.group(1).upper(): normalize_spaces(m.group(2)) for m in matches}
-
-
-def _solve_successive_percent(text: str) -> Optional[SolverResult]:
-
-    t = clean_math_text(text).lower()
-
-    percents = re.findall(r"(\d+(?:\.\d+)?)\s*%", t)
-    if len(percents) < 2:
-        return None
-
-    values = [float(p) for p in percents]
-
-    mult = 1
-    for p in values:
-        if "decrease" in t or "discount" in t:
-            mult *= 1 - p / 100
+    pipeline = None
+
+from models import RetrievedChunk
+
+
+class GeneratorEngine:
+    def __init__(self, model_name: str = "google/flan-t5-small"):
+        self.model_name = model_name
+        self.pipe = None
+
+        if pipeline is not None:
+            try:
+                self.pipe = pipeline("text2text-generation", model=model_name)
+            except Exception:
+                self.pipe = None
+
+    def available(self) -> bool:
+        return self.pipe is not None
+
+    def _notes_block(self, retrieval_context: List[RetrievedChunk]) -> str:
+        if not retrieval_context:
+            return ""
+        lines = []
+        for chunk in retrieval_context[:3]:
+            text = (chunk.text or "").strip().replace("\n", " ")
+            if len(text) > 220:
+                text = text[:217].rstrip() + "…"
+            lines.append(f"- {chunk.topic}: {text}")
+        return "\n".join(lines)
+
+    def _template_fallback(
+        self,
+        user_text: str,
+        question_text: Optional[str],
+        topic: str,
+        intent: str,
+        retrieval_context: Optional[List[RetrievedChunk]] = None,
+    ) -> str:
+        question = (question_text or user_text or "").strip()
+        notes = self._notes_block(retrieval_context or [])
+
+        if intent == "hint":
+            base = "Start by identifying the exact relationship between the quantities before doing any arithmetic."
+        elif intent in {"instruction", "method"}:
+            base = "Translate the wording into an equation, ratio, or percent relationship, then solve one step at a time."
+        elif intent in {"walkthrough", "step_by_step", "explain", "concept"}:
+            base = "First identify what the question is asking, then map the values into the correct quantitative structure, and only then compute."
         else:
-            mult *= 1 + p / 100
-
-    net = (mult - 1) * 100
-
-    return SolverResult(
-        domain="quant",
-        solved=True,
-        topic="percent",
-        answer_value=f"{net:.2f}%",
-        internal_answer=f"{net:.2f}%",
-        steps=[
-            "Convert each percent change to a multiplier.",
-            "Multiply the successive multipliers.",
-            "Convert the final multiplier back to a percent change.",
-        ],
-    )
-
-
-def _solve_ratio_total(text: str) -> Optional[SolverResult]:
-
-    t = clean_math_text(text)
-
-    ratio = re.search(r"(\d+)\s*:\s*(\d+)", t)
-    total = re.search(r"total\s*(?:is|=)?\s*(\d+)", t.lower())
-
-    if not ratio or not total:
-        return None
-
-    a = int(ratio.group(1))
-    b = int(ratio.group(2))
-    total_val = int(total.group(1))
-
-    part_sum = a + b
-    unit = total_val / part_sum
-
-    return SolverResult(
-        domain="quant",
-        solved=True,
-        topic="ratio",
-        answer_value=f"{a * unit:g}",
-        internal_answer=f"{a * unit:g}",
-        steps=[
-            "Add the ratio parts.",
-            "Divide the total by the sum of the ratio.",
-            "Multiply by the requested ratio component.",
-        ],
-    )
-
-
-def _solve_remainder(text: str) -> Optional[SolverResult]:
-
-    t = clean_math_text(text).lower()
-
-    m = re.search(r"remainder.*?(\d+).*?divided by (\d+)", t)
-
-    if not m:
-        return None
-
-    a = int(m.group(1))
-    b = int(m.group(2))
-
-    r = a % b
-
-    return SolverResult(
-        domain="quant",
-        solved=True,
-        topic="number_theory",
-        answer_value=str(r),
-        internal_answer=str(r),
-        steps=[
-            "Divide the number by the divisor.",
-            "The remainder is the leftover after division.",
-        ],
-    )
-
-
-def _solve_percent(text: str) -> Optional[SolverResult]:
-
-    lower = clean_math_text(text).lower()
-
-    m = re.search(r"(\d+)% of a number is (\d+)", lower)
-
-    if m:
-        p = float(m.group(1))
-        val = float(m.group(2))
-
-        ans = val / (p / 100)
-
-        return SolverResult(
-            domain="quant",
-            solved=True,
-            topic="percent",
-            answer_value=f"{ans:g}",
-            internal_answer=f"{ans:g}",
+            base = "This does not match a strong solver rule yet, so begin by identifying the target quantity and the relationship connecting the numbers."
+
+        if notes:
+            return f"{base}\n\nRelevant notes:\n{notes}"
+        return base
+
+    def _build_prompt(
+        self,
+        user_text: str,
+        question_text: Optional[str],
+        topic: str,
+        intent: str,
+        retrieval_context: Optional[List[RetrievedChunk]] = None,
+    ) -> str:
+        question = (question_text or user_text or "").strip()
+        notes = self._notes_block(retrieval_context or [])
+
+        prompt = [
+            "You are a concise GMAT tutor.",
+            f"Topic: {topic or 'general'}",
+            f"Intent: {intent or 'answer'}",
+            "",
+            f"Question: {question}",
+        ]
+
+        if notes:
+            prompt.extend(["", "Relevant teaching notes:", notes])
+
+        prompt.extend(
+            [
+                "",
+                "Respond briefly and clearly.",
+                "If the problem is not fully solvable from the parse, give the next best method step.",
+                "Do not invent facts.",
+            ]
         )
 
-    return None
-
-
-def _solve_linear_equation(text: str) -> Optional[SolverResult]:
-
-    if sp is None:
-        return None
-
-    m = re.search(r"([a-z])\s*/\s*(\d+)\s*=\s*(\d+)", text)
-
-    if not m:
-        return None
-
-    var = m.group(1)
-    a = float(m.group(2))
-    b = float(m.group(3))
-
-    ans = a * b
-
-    return SolverResult(
-        domain="quant",
-        solved=True,
-        topic="algebra",
-        answer_value=str(ans),
-        internal_answer=str(ans),
-    )
-
-
-def solve_quant(text: str) -> SolverResult:
-
-    for fn in (
-        _solve_successive_percent,
-        _solve_ratio_total,
-        _solve_remainder,
-        _solve_percent,
-        _solve_linear_equation,
-    ):
-        result = fn(text)
-        if result:
-            return result
+        return "\n".join(prompt)
+
+    def generate(
+        self,
+        user_text: str,
+        question_text: Optional[str] = None,
+        topic: str = "",
+        intent: str = "answer",
+        retrieval_context: Optional[List[RetrievedChunk]] = None,
+        chat_history=None,
+        max_new_tokens: int = 96,
+        **kwargs,
+    ) -> Optional[str]:
+        prompt = self._build_prompt(
+            user_text=user_text,
+            question_text=question_text,
+            topic=topic,
+            intent=intent,
+            retrieval_context=retrieval_context or [],
+        )
 
-    return SolverResult(
-        domain="quant",
-        solved=False,
-        topic="general_quant",
-        reply="This looks quantitative but does not match a strong rule-based solver yet.",
-    )
+        if self.pipe is not None:
+            try:
+                out = self.pipe(prompt, max_new_tokens=max_new_tokens, do_sample=False)
+                if out and isinstance(out, list):
+                    text = str(out[0].get("generated_text", "")).strip()
+                    if text:
+                        return text
+            except Exception:
+                pass
+
+        return self._template_fallback(
+            user_text=user_text,
+            question_text=question_text,
+            topic=topic,
+            intent=intent,
+            retrieval_context=retrieval_context or [],
+        )