updated unit_parser

bot_inference.py

@@ -6,12 +6,15 @@ from bot_model import GPT
 # ----------------- Reuse the fixed unit/money parsing -----------------
 # Make sure unit_parser_fixed.py is on your PYTHONPATH or in the same package.
 from unit_parser import (
-    MONEY_RE,
-    UNIT_LIKE_RE,
-    GROUP_LIKE_RE,
-    try_solve_unit_like,  # deterministic unit-price solver (fixed 2000 → 200 bug)
+    canonicalize_nl,
+    try_solve_unit_like,
+    is_addition_query,
+    canonicalize_addition,
+    sum_addends,
 )
 
+
+
 # ----------------- Token helpers -----------------
 def decode(ids, itos):
     return "".join(itos[i] for i in ids)

unit_parser.py

@@ -1,42 +1,46 @@
+# unit_parser_fixed.py
 import re
 from typing import Optional
-from config import CFG, money
-# currency patterns
+
+# =============================
+# Currency / money patterns
+# =============================
 CURRENCY_PREFIX = r"[$£€₹¥₩₦]|A\$|C\$|CHF|د\.إ"
-MONEY_RE = re.compile(rf"(?P<prefix>{CURRENCY_PREFIX})?\s*(?P<val>\d+(?:\.\d{{1,2}})?)\s*(?P<word>(?:[a-zA-Z]+(?:\s[a-zA-Z]+)?)s?)?", re.IGNORECASE)
+MONEY_RE = re.compile(
+    rf"(?P<prefix>{CURRENCY_PREFIX})?\s*(?P<val>\d+(?:,\d{{3}})*(?:\.\d{{1,2}})?)\s*(?P<word>(?:[a-zA-Z]+(?:\s[a-zA-Z]+)?)s?)?",
+    re.IGNORECASE,
+)
 
+# =============================
+# Unit / group price patterns
+# =============================
 UNIT_LIKE_RE = re.compile(
     r"(?P<q1>\d+)\s+(?P<item>[\w\s]+?)\s+(?:is|are|cost|costs|priced at|=)\s+"
-    r"(?P<cost>\d{1,3}(?:,\d{3})*(?:\.\d+)?|\d+(?:\.\d+)?(?:\s*\w+)?)"
-    r"[,\.]?\s*(?:how much|what\s*'?s|price|cost).*(?P<q2>\d+)\s+(?P=item)\b",
+    r"(?P<cost>\d+(?:,\d{3})*(?:\.\d+)?(?:\s*\w+)?)"
+    r"[,\.]?\s*(?:how much|what\s*'?s|price|cost).*?(?P<q2>\d+)\s+(?P=item)\b",
     re.IGNORECASE,
 )
 
-
 GROUP_LIKE_RE = re.compile(
-    r"(?P<q1>\d+)\s+(?P<item>\w+?s?)\s+for\s+(?P<cost>.+?)\b[,\.]?\s*(?:how much|what\s*'?s|price|cost).*(?P<q2>\d+)\s+(?P=item)\b",
+    r"(?P<q1>\d+)\s+(?P<item>\w+?s?)\s+for\s+(?P<cost>.+?)\b[,\.]?\s*(?:how much|what\s*'?s|price|cost).*?(?P<q2>\d+)\s+(?P=item)\b",
     re.IGNORECASE,
 )
 
-ARITH_RES = {
-    '+': re.compile(r"^\s*([\d\s\+]+)(?:=\s*\?\s*|\?|)$"),
-    '-': re.compile(r"^\s*(\d+)\s*[-–]\s*(\d+).*?$"),
-    'x': re.compile(r"^\s*(\d+)\s*[x×*]\s*(\d+).*?$", re.IGNORECASE),
-    '/': re.compile(r"^\s*(\d+)\s*[÷/]\s*(\d+).*?$"),
-}
-
-# Addition embedded in NL, e.g., "what is 2 + 2 = ?" or "find 3+5+7"
-ADD_LIKE_NL = re.compile(r".*?(?P<expr>\d+(?:\s*\+\s*\d+)+).*", re.IGNORECASE)
-
 ADD_RE = re.compile(r"^\s*([\d+\s=\?]+)\s*$")
 NUM_RE = re.compile(r"\d+")
 
+# =============================
+# Helpers
+# =============================
+def money(v: float) -> str:
+    return str(int(round(v))) if abs(v - round(v)) < 1e-9 else f"{v:.2f}"
+
 def parse_money_str(s: str) -> str:
     m = MONEY_RE.search(s)
     if not m:
         return s.strip()
     prefix = (m.group('prefix') or '').strip()
-    val = float(m.group('val'))
+    val = float((m.group('val') or '').replace(',', ''))
     word = (m.group('word') or '').strip()
     if prefix:
         return f"{prefix}{money(val)}"
@@ -46,32 +50,12 @@ def parse_money_str(s: str) -> str:
         return f"{money(val)} {word}"
     return money(val)
 
+# =============================
+# Canonicalizers
+# =============================
 def canonicalize_nl(text: str) -> Optional[str]:
     t = text.strip()
 
-    # Addition inside NL
-    m_add_nl = ADD_LIKE_NL.match(t)
-    if m_add_nl:
-        expr = m_add_nl.group('expr')
-        parts = [p.strip() for p in expr.split('+')]
-        expr = " + ".join(parts)
-        return f"q: {expr} a:"
-
-    # quick arithmetic
-    m = ARITH_RES['-'].match(t)
-    if m:
-        a, b = m.groups()
-        return f"q: {a} - {b} a:"
-    m = ARITH_RES['x'].match(t)
-    if m:
-        a, b = m.groups()
-        return f"q: {a} × {b} a:"
-    m = ARITH_RES['/'].match(t)
-    if m:
-        a, b = m.groups()
-        return f"q: {a} ÷ {b} a:"
-
-    # unit-like
     m = UNIT_LIKE_RE.search(t)
     if m:
         q1 = int(m.group('q1')); item = m.group('item').rstrip('.')
@@ -79,7 +63,6 @@ def canonicalize_nl(text: str) -> Optional[str]:
         q2 = int(m.group('q2'))
         return f"q: {q1} {item} cost {cost}. how much is {q2} {item}? a:"
 
-    # group-like
     m = GROUP_LIKE_RE.search(t)
     if m:
         q1 = int(m.group('q1')); item = m.group('item').rstrip('.')
@@ -91,7 +74,8 @@ def canonicalize_nl(text: str) -> Optional[str]:
 
 def is_addition_query(text: str) -> bool:
     t = text.strip()
-    if not ADD_RE.match(t): return False
+    if not ADD_RE.match(t):
+        return False
     return ('+' in t) and (len(NUM_RE.findall(t)) >= 2)
 
 def canonicalize_addition(text: str) -> str:
@@ -100,3 +84,50 @@ def canonicalize_addition(text: str) -> str:
 
 def sum_addends(text: str) -> int:
     return sum(int(x) for x in NUM_RE.findall(text))
+
+# =============================
+# Deterministic solver
+# =============================
+_NUMBER_TOKEN_RE = re.compile(r"\d+(?:,\d{3})*(?:\.\d+)?")
+
+def try_solve_unit_like(text: str) -> Optional[str]:
+    m = UNIT_LIKE_RE.search(text)
+    if not m:
+        return None
+
+    q1 = int(m.group('q1'))
+    q2 = int(m.group('q2'))
+    item = (m.group('item') or '').strip().rstrip('.')
+    cost_raw = (m.group('cost') or '').strip()
+
+    nums = _NUMBER_TOKEN_RE.findall(cost_raw)
+    if not nums:
+        return None
+    token = max(nums, key=lambda s: len(s.replace(',', '')))
+    cost_val = float(token.replace(',', ''))
+
+    if q1 == 0:
+        return "final answer: undefined"
+
+    unit = cost_val / q1
+    total = unit * q2
+
+    mcur = MONEY_RE.search(cost_raw)
+    prefix = (mcur.group('prefix') or '').strip() if mcur else ''
+    word   = (mcur.group('word') or '').strip()   if mcur else ''
+
+    def _fmt(v: float) -> str:
+        s = money(v)
+        if prefix:
+            return f"{prefix}{s}"
+        if word:
+            sing = word[:-1] if word.lower().endswith('s') and abs(v-1.0) < 1e-9 else word
+            return f"{s} {sing}"
+        return s
+
+    base_item = item[:-1] if item.lower().endswith('s') else item
+    return (
+        f"step 1: find unit price: {_fmt(cost_val)} / {q1} = {_fmt(unit)} per {base_item}. "
+        f"step 2: multiply by {q2}: {_fmt(unit)} × {q2} = {_fmt(total)}. "
+        f"final answer: {_fmt(total)}"
+    )