Update models.py

models.py

@@ -1,71 +1,185 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel
-
-
-class ChatRequest(BaseModel):
-    message: Optional[str] = None
-    prompt: Optional[str] = None
-    query: Optional[str] = None
-    text: Optional[str] = None
-    user_message: Optional[str] = None
-
-    tone: Optional[float] = 0.5
-    verbosity: Optional[float] = 0.5
-    transparency: Optional[float] = 0.5
-
-    help_mode: Optional[str] = None
-    chat_history: Optional[List[Dict[str, Any]]] = None
-    history: Optional[List[Dict[str, Any]]] = None
-
-    question_text: Optional[str] = None
-    question_id: Optional[str] = None
-    session_id: Optional[str] = None
-    user_id: Optional[str] = None
-
-
-class SessionStartRequest(BaseModel):
-    session_id: str
-    user_id: Optional[str] = None
-    condition: Optional[str] = None
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class EventLogRequest(BaseModel):
-    session_id: str
-    event_type: str
-    timestamp: Optional[str] = None
-    payload: Optional[Dict[str, Any]] = None
-
-
-class SessionFinalizeRequest(BaseModel):
-    session_id: str
-    summary: Optional[Dict[str, Any]] = None
-
-
-@dataclass
-class RetrievedChunk:
-    text: str
-    topic: str = "general"
-    source: str = "local"
-    score: float = 0.0
-
-
-@dataclass
-class SolverResult:
-    reply: str = ""
-    domain: str = "fallback"
-    solved: bool = False
-    help_mode: str = "answer"
-    answer_letter: Optional[str] = None
-    answer_value: Optional[str] = None
-    topic: Optional[str] = None
-    used_retrieval: bool = False
-    used_generator: bool = False
-    internal_answer: Optional[str] = None
-    steps: List[str] = field(default_factory=list)
-    teaching_chunks: List[RetrievedChunk] = field(default_factory=list)
-    meta: Dict[str, Any] = field(default_factory=dict)
+import math
+import re
+from statistics import mean, median
+from typing import Dict, Optional
+
+try:
+    import sympy as sp
+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
+        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}",
+        )
+
+    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 SolverResult(
+        domain="quant",
+        solved=False,
+        topic="general_quant",
+        reply="This looks quantitative but does not match a strong rule-based solver yet.",
+    )