Update models.py

models.py

@@ -1,185 +1,76 @@
 from __future__ import annotations
 
-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.",
-    )
+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
+    input: Optional[str] = None
+    content: Optional[str] = None
+
+    tone: Optional[float] = 0.5
+    verbosity: Optional[float] = 0.5
+    transparency: Optional[float] = 0.5
+
+    help_mode: Optional[str] = None
+    intent: Optional[str] = None
+    category: Optional[str] = None
+    chat_history: Optional[List[Dict[str, Any]]] = None
+    history: Optional[List[Dict[str, Any]]] = None
+
+    question_text: Optional[str] = None
+    options_text: Optional[List[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)