Upload 4 files

app.py

@@ -0,0 +1,664 @@
+# app.py — “Jerry” NLP Agent (per‑acre‑per‑year; uses salvage internally for Depr & OCC)
+# ---------------------------------------------------------------------------------
+# Students ALWAYS type: equipment_name, acres (per year), speed_acph (ac/hr), life_years, cost
+# Optional (only when needed): pto_hp, diesel_price, wage, rate
+#
+# Jerry computes EXACTLY ONE cost per prompt (NLP → strict schema), with unit basis aligned:
+#   • repair_per_acre_year       = (cost × repair_fraction@AccumHours) / (life_years × acres)
+#   • fuel_per_acre              = (0.044 × pto_hp × diesel_price) / speed_acph
+#   • lube_per_acre              = 0.15 × fuel_per_acre
+#   • labor_per_acre             = wage / speed_acph
+#   • depreciation_per_acre_year = (C − S) / (life_years × acres)   ← S from salvage table (hidden from students)
+#   • occ_per_acre_year          = rate × ((C + S)/2) / (life_years × acres)   ← S from salvage table
+#
+# Shared formula:
+#   AccumHours = life_years × (acres / speed_acph)
+
+from __future__ import annotations
+from typing import Optional, Dict, Any
+import os, re, json
+import gradio as gr
+
+from repair_table_data import get_repair_fraction  # repair fraction by accumulated hours
+from salvage_lookup import classify_machine_for_salvage, get_salvage_fraction  # salvage fraction (hidden)
+
+from salvage_lookup import classify_machine_for_salvage, get_salvage_fraction  # keep
+# add this helper inside app.py:
+def salvage_parts(equip: str, cost: float, hp, acres: float, speed: float, life: float):
+    """Return (salv_frac, salvage_value, class_used). Fallback frac = 0.20."""
+    try:
+        cls = classify_machine_for_salvage(equip, hp)
+    except Exception:
+        cls = None
+    annual_hours = float(acres) / max(float(speed), 1e-9)
+    try:
+        frac = get_salvage_fraction(cls, annual_hours, float(life)) if cls else None
+    except Exception:
+        frac = None
+    if frac is None:
+        frac = 0.20
+    return float(frac), float(cost) * float(frac), cls
+
+
+import copy
+
+# Which fields we track in the student HUD
+HUD_FIELDS = [
+    "equipment_name", "acres", "speed_acph", "life_years", "cost",
+    "which_cost", "pto_hp", "diesel_price", "wage", "rate"
+]
+
+# Requirements to be able to compute each cost
+REQUIREMENTS = {
+    "repair_per_acre_year":   ["equipment_name", "acres", "speed_acph", "life_years", "cost"],
+    "fuel_per_acre":          ["acres", "speed_acph", "life_years", "cost", "pto_hp", "diesel_price"],
+    "lube_per_acre":          ["acres", "speed_acph", "life_years", "cost", "pto_hp", "diesel_price"],
+    "labor_per_acre":         ["acres", "speed_acph", "life_years", "cost", "wage"],
+    "depreciation_per_acre_year": ["equipment_name", "acres", "speed_acph", "life_years", "cost"],
+    "occ_per_acre_year":      ["equipment_name", "acres", "speed_acph", "life_years", "cost", "rate"],
+    "tax":                    ["cost"],
+    "insurance":              ["cost"],
+    "housing":                ["cost"],
+}
+
+REQUIREMENTS.update({
+    "tax":       ["cost", "acres"],
+    "insurance": ["cost", "acres"],
+    "housing":   ["cost", "acres"],
+})
+
+def _pp(obj):
+    try:
+        return json.dumps(obj, indent=2, ensure_ascii=False, default=str)
+    except Exception:
+        return str(obj)
+
+def merge_into_hud(hud: dict, new_data: dict) -> tuple[dict, list]:
+    """Overwrite HUD with any non-null values from new_data. Return (updated_hud, changed_keys)."""
+    hud = copy.deepcopy(hud)
+    changed = []
+    for k in HUD_FIELDS:
+        if k in new_data and new_data[k] is not None:
+            if hud.get(k) != new_data[k]:
+                hud[k] = new_data[k]
+                changed.append(k)
+    return hud, changed
+
+def missing_for(which_cost: str, hud: dict) -> list:
+    req = REQUIREMENTS.get(which_cost or "", [])
+    miss = [k for k in req if hud.get(k) in (None, "", float("nan"))]
+    return miss
+
+#def _pp(obj):
+#    try:
+#        return json.dumps(obj, indent=2, ensure_ascii=False, default=str)
+#    except Exception:
+#        return str(obj)
+
+# ---- Optional LLM ----
+LLM_OK = False
+client = None
+try:
+    from openai import OpenAI
+    if os.getenv("OPENAI_API_KEY"):
+        client = OpenAI()
+        LLM_OK = True
+except Exception:
+    LLM_OK = False
+
+JERRY_SYSTEM_PROMPT = (
+    "You are JERRY, a farm machinery cost coach **in training**. The student is the boss; "
+    "you do exactly what they ask and nothing extra. Your job is to READ the student's sentence "
+    "and OUTPUT ONLY a **minified JSON** object that our app will compute with.\n"
+
+    "SCHEMA (always output these keys when present):\n"
+    "equipment_name (string), acres (number), speed_acph (number), life_years (number), cost (number), "
+    "which_cost (one of: 'repair_per_acre_year','fuel_per_acre','lube_per_acre','labor_per_acre',"
+    "'depreciation_per_acre_year','occ_per_acre_year'), "
+    "OPTIONAL: pto_hp (number), diesel_price (number), wage (number), rate (number), "
+    "OPTIONAL diagnostics: missing (array of strings listing required-but-missing fields).\n"
+
+    "TEACHING NOTES (formulas are for validation only—DO NOT COMPUTE VALUES):\n"
+    "- Fuel_per_acre  = (0.044 * pto_hp * diesel_price) / speed_acph\n"
+    "- Lube_per_acre  = 0.15 * Fuel_per_acre  (needs same inputs as fuel)\n"
+    "- Labor_per_acre = wage / speed_acph\n"
+    "- Repair_per_acre_year uses a table fraction at AccumHours, where AccumHours = life_years * (acres / speed_acph)\n"
+    "- Depreciation_per_acre_year = (Cost - Salvage) / (life_years * acres)  (salvage is internal; you never output it)\n"
+    "- OCC_per_acre_year = rate * ((Cost + Salvage)/2) / (life_years * acres) (salvage internal)\n"
+
+    "CHECKS & BALANCES (training Jerry):\n"
+    "1) The student ALWAYS supplies the five base items: equipment_name, acres, speed_acph, life_years, cost.\n"
+    "   - If any base item is missing, still output JSON with that field = null and list it in 'missing'.\n"
+    "2) For the requested cost, ensure the extra inputs exist:\n"
+    "   - fuel_per_acre: require pto_hp and diesel_price; if absent set nulls and add to 'missing'.\n"
+    "   - lube_per_acre: require pto_hp and diesel_price; if absent set nulls and add to 'missing'.\n"
+    "   - labor_per_acre: require wage; if absent set null and add to 'missing'.\n"
+    "   - depreciation_per_acre_year, occ_per_acre_year: DO NOT ask for salvage; it is internal.\n"
+    "3) Parse numbers robustly—accept units and symbols and strip them: '$', commas, '%', 'ac/hr', 'acph', 'acres per hour', '/gal'. "
+    "Examples: '$350,000' -> 350000; '3.80/gal' -> 3.80; '12 ac/hr' -> 12; '8%' -> 0.08.\n"
+    "4) Never invent numbers. If unsure, use null and list the field in 'missing'.\n"
+    "5) Map the student’s words to exactly one which_cost (priority by explicit keyword in the text):\n"
+    "   'repair' -> 'repair_per_acre_year';\n"
+    "   'fuel' or 'fuel cost' -> 'fuel_per_acre';\n"
+    "   'lube' or 'lubrication' -> 'lube_per_acre';\n"
+    "   'labor' or 'wage' -> 'labor_per_acre';\n"
+    "   'depreciation' or 'depr' or 'straight line' -> 'depreciation_per_acre_year';\n"
+    "   'occ' or 'opportunity cost' or 'interest' -> 'occ_per_acre_year'.\n"
+    "   If none appears, leave which_cost null.\n"
+    "6) Accept em dashes or punctuation as separators (e.g., '— fuel').\n"
+
+    "OUTPUT RULES:\n"
+    "- Output ONLY a single minified JSON object (no prose, no code block, no comments).\n"
+    "- Keys must match the schema exactly. Use nulls for unknown numerics. Include 'missing' only when nonempty.\n"
+
+    "EXAMPLES (do not echo back; just follow the pattern):\n"
+    "Input: '4WD tractor, acres=1200, speed=12 ac/hr, life=8, cost=$350000, hp=300, diesel=3.80 — fuel'\n"
+    "Output: {\"equipment_name\":\"4WD tractor\",\"acres\":1200,\"speed_acph\":12,\"life_years\":8,\"cost\":350000,"
+    "\"pto_hp\":300,\"diesel_price\":3.8,\"which_cost\":\"fuel_per_acre\"}\n"
+
+    "Input: 'Planter acres 900 speed 9 ac/hr life 12 cost 180000 lube'\n"
+    "Output: {\"equipment_name\":\"Planter\",\"acres\":900,\"speed_acph\":9,\"life_years\":12,\"cost\":180000,"
+    "\"which_cost\":\"lube_per_acre\"}\n"
+
+    "Input: 'Tractor acres=1000 speed=10 ac/hr life=10 cost=$200,000 wage $22 — labor'\n"
+    "Output: {\"equipment_name\":\"Tractor\",\"acres\":1000,\"speed_acph\":10,\"life_years\":10,\"cost\":200000,"
+    "\"wage\":22,\"which_cost\":\"labor_per_acre\"}\n"
+)
+
+
+
+# ---- Computations ----
+
+def accumulated_hours(life_years: float, acres: float, speed_acph: float) -> float:
+    return float(life_years) * (float(acres)/max(speed_acph,1e-9))
+
+
+def _salvage_value_hidden(equipment_name: str, cost: float, acres: float, speed_acph: float,
+                          life_years: float, pto_hp: Optional[float]) -> float:
+    """Hidden salvage value S = cost × salv_frac (from table). Students never see S directly."""
+    machine_class = classify_machine_for_salvage(equipment_name, pto_hp)
+    annual_hours = float(acres)/max(speed_acph,1e-9)
+    salv_frac = get_salvage_fraction(machine_class, annual_hours, float(life_years)) if machine_class else None
+    if salv_frac is None:
+        salv_frac = 0.20  # safety fallback
+    return float(cost) * float(salv_frac)
+
+
+# --- Salvage helper (table-driven; fallback = 20%) ---
+def salvage_value(equip: str, cost: float, hp, acres: float, speed: float, life: float) -> float:
+    """
+    Return salvage $ using your salvage table.
+    - Classify machine with (equip, hp)
+    - annual_hours = acres / speed
+    - age_years = life
+    - salvage = cost * salvage_fraction
+    Fallback to 0.20 if the table can’t classify or returns None.
+    """
+    try:
+        cls = classify_machine_for_salvage(equip, hp)
+    except Exception:
+        cls = None
+
+    try:
+        annual_hours = float(acres) / max(float(speed), 1e-9)
+    except Exception:
+        annual_hours = 0.0
+
+    try:
+        frac = get_salvage_fraction(cls, annual_hours, float(life)) if cls else None
+    except Exception:
+        frac = None
+
+    if frac is None:
+        frac = 0.20
+    return float(cost) * float(frac)
+
+
+def compute_repair_per_acre_year(equip: str, cost: float, life: float, acres: float, speed: float) -> Dict[str, Any]:
+    hrs = accumulated_hours(life, acres, speed)
+    frac, canon, lo, hi = get_repair_fraction(equip, hrs)
+    total_repair = cost * frac
+    val = total_repair / max(life*acres,1e-9)
+    return {"canon":canon,"hours":hrs,"fraction":frac,"repair_per_acre_year":val}
+
+
+def compute_fuel_per_acre(hp: float, diesel: float, speed: float) -> float:
+    return (0.044*hp*diesel)/max(speed,1e-9)
+
+def compute_lube_per_acre(fuel: float) -> float:
+    return 0.15*fuel
+
+def compute_labor_per_acre(wage: float, speed: float) -> float:
+    return wage/max(speed,1e-9)
+
+def compute_depr_per_acre_year(cost: float, salvage_value: float, life: float, acres: float) -> float:
+    return (float(cost) - float(salvage_value)) / max(life * acres, 1e-9)
+
+def compute_occ_per_acre_year(cost: float, salvage: float, rate: float, life: float, acres: float) -> float:
+    avg_invest = 0.5 * (cost + salvage)
+    return float(rate) * avg_invest / max(acres, 1e-9)
+
+def compute_tax_per_acre(cost: float, acres: float) -> float:
+    # Tax = 1% of cost, allocated per acre
+    return 0.01 * float(cost) / max(float(acres), 1e-9)
+
+def compute_insurance_per_acre(cost: float, acres: float) -> float:
+    # Insurance = 0.5% of cost, allocated per acre
+    return 0.005 * float(cost) / max(float(acres), 1e-9)
+
+def compute_housing_per_acre(cost: float, acres: float) -> float:
+    # Housing = 0.5% of cost, allocated per acre
+    return 0.005 * float(cost) / max(float(acres), 1e-9)
+
+
+# ---- Keyword intent + Regex fallback ----
+NUM=r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?"
+
+def _find(pat,s): m=re.search(pat,s,re.I); return float(m.group(1)) if m else None
+
+def _name_guess(s: str) -> Optional[str]:
+    m=re.search(r"^\s*([^,\n]+?)\s*(?:,|acres|$)",s,flags=re.I)
+    return m.group(1).strip() if m else None
+
+
+def which_from_keywords(s: str) -> Optional[str]:
+    t=s.lower()
+    if "repair" in t or "maint" in t: return "repair_per_acre_year"
+    if "fuel" in t: return "fuel_per_acre"
+    if "lube" in t or "lubric" in t: return "lube_per_acre"
+    if "labor" in t or "wage" in t: return "labor_per_acre"
+    if "depr" in t or "straight line" in t: return "depreciation_per_acre_year"
+    if any(k in t for k in ["occ","interest","opportunity cost"]): return "occ_per_acre_year"
+    return None
+
+
+def regex_parse(user:str)->Dict[str,Any]:
+    s=user
+    d:Dict[str,Any]={}
+    d["equipment_name"]=_name_guess(s)
+    d["acres"]=_find(r"acres\s*(?:=|:)?\s*("+NUM+")",s) or _find(r"("+NUM+")\s*acres",s)
+    d["speed_acph"]=_find(r"(speed|acph)\s*(?:=|:)?\s*("+NUM+")",s) or _find(r"("+NUM+")\s*(?:acph|ac/hr|ac\/hr|acres per hour)",s)
+    d["life_years"]=_find(r"(life|years?)\s*(?:=|:)?\s*("+NUM+")",s)
+    d["cost"]=_find(r"(cost|price|purchase)\s*(?:=|:|\$)?\s*("+NUM+")",s) or _find(r"\$("+NUM+")",s)
+    d["pto_hp"]=_find(r"(pto\s*hp|hp|horsepower)\s*(?:=|:)?\s*("+NUM+")",s)
+    d["diesel_price"]=_find(r"(diesel|fuel)\s*(price)?\s*(?:=|:|\$)?\s*("+NUM+")",s)
+    d["wage"]=_find(r"(wage|labor\s*rate)\s*(?:=|:|\$)?\s*("+NUM+")",s)
+    d["rate"]=_find(r"(rate|interest|occ)\s*(?:=|:)?\s*("+NUM+")\s*%?",s)
+    w=which_from_keywords(s)
+    if w: d["which_cost"]=w
+    return {k:v for k,v in d.items() if v is not None}
+
+# ---- LLM parse (same schema) ----
+
+def llm_parse(user:str)->Dict[str,Any]:
+    if not LLM_OK: return {}
+    try:
+        resp=client.chat.completions.create(
+            model="gpt-4o-mini",temperature=0,
+            messages=[{"role":"system","content":JERRY_SYSTEM_PROMPT},{"role":"user","content":user}])
+        txt=(resp.choices[0].message.content or "").strip()
+        if txt.startswith("{"): return json.loads(txt)
+    except: pass
+    return {}
+
+# ---- Orchestrator ----
+DEFAULT_RATE=0.08
+def _to_float(x):
+    if x is None: return None
+    if isinstance(x, (int, float)): return float(x)
+    s = str(x).strip().lower()
+    # strip common decorations
+    s = s.replace("$","").replace(",","")
+    s = s.replace("ac/hr","").replace("acph","").replace("acres per hour","")
+    s = s.replace("%","")
+    # keep only number-ish chars
+    s = re.sub(r"[^0-9eE\.\-\+]", "", s)
+    try:
+        return float(s)
+    except Exception:
+        return None
+
+def which_from_keywords(s: str) -> Optional[str]:
+    t = s.lower()
+    if "fuel" in t: return "fuel_per_acre"
+    if "lube" in t or "lubric" in t: return "lube_per_acre"
+    if "labor" in t or "wage" in t: return "labor_per_acre"
+    if "depr" in t or "depreciation" in t or "straight line" in t: return "depreciation_per_acre_year"
+    if "occ" in t or "opportunity cost" in t or "interest" in t: return "occ_per_acre_year"
+    if "repair" in t or "maint" in t: return "repair_per_acre_year"
+    return None
+
+def normalize_llm_data(data: Dict[str, Any], user_text: str) -> Dict[str, Any]:
+    d = dict(data or {})
+
+    # unify key names the LLM might choose
+    if "hp" in d and "pto_hp" not in d:
+        d["pto_hp"] = d["hp"]
+    if "diesel" in d and "diesel_price" not in d:
+        d["diesel_price"] = d["diesel"]
+    if "life" in d and "life_years" not in d:
+        d["life_years"] = d["life"]
+    if "speed" in d and "speed_acph" not in d:
+        d["speed_acph"] = d["speed"]
+
+    # normalize which_cost
+    wc = str(d.get("which_cost","")).strip().lower()
+    wc_map = {
+        "fuel":"fuel_per_acre",
+        "fuel per acre":"fuel_per_acre",
+        "fuel_per_acre":"fuel_per_acre",
+        "repair":"repair_per_acre_year",
+        "repair_per_acre_year":"repair_per_acre_year",
+        "lube":"lube_per_acre",
+        "lube_per_acre":"lube_per_acre",
+        "labor":"labor_per_acre",
+        "labor_per_acre":"labor_per_acre",
+        "depreciation":"depreciation_per_acre_year",
+        "depr":"depreciation_per_acre_year",
+        "depreciation_sl":"depreciation_per_acre_year",
+        "occ":"occ_per_acre_year",
+        "opportunity cost":"occ_per_acre_year",
+        "interest":"occ_per_acre_year",
+        "occ_per_acre_year":"occ_per_acre_year",
+    }
+    d["which_cost"] = wc_map.get(wc) or which_from_keywords(user_text) or d.get("which_cost")
+
+    # cast numerics (accept strings like "$350,000", "8%")
+    for k in ["acres","speed_acph","life_years","cost","pto_hp","diesel_price","wage","rate"]:
+        if k in d:
+            d[k] = _to_float(d[k])
+
+    # rate may be typed as 8 meaning 8% → 0.08
+    if d.get("rate") is not None and d["rate"] > 1.0:
+        d["rate"] = d["rate"] / 100.0
+
+    return d
+
+def jerry_agent(user: str):
+    # ---------- Parse (LLM first, then regex) ----------
+    raw_llm = llm_parse(user)            # dict or {}
+    if raw_llm:
+        mode = "LLM"
+        raw_regex = {}
+        raw = raw_llm
+    else:
+        mode = "regex"
+        raw_regex = regex_parse(user)     # dict or {}
+        raw = raw_regex
+
+    # Fallback: infer which_cost from the text if parser left it empty
+    def _which_from_text(txt: str):
+        t = (txt or "").lower()
+        if "fuel" in t: return "fuel_per_acre"
+        if "lube" in t or "lubric" in t: return "lube_per_acre"
+        if "labor" in t or "wage" in t: return "labor_per_acre"
+        if "depr" in t or "depreciation" in t or "straight line" in t: return "depreciation_per_acre_year"
+        if "occ" in t or "opportunity cost" in t or "interest" in t: return "occ_per_acre_year"
+        if "tax" in t: return "tax"
+        if "insurance" in t or "ins " in t: return "insurance"
+        if "housing" in t or "house " in t: return "housing"
+        if "repair" in t or "maint" in t: return "repair_per_acre_year"
+        if "tax" in t or "taxes" in t: return "tax"
+        if "insurance" in t or "ins " in t or "insur" in t: return "insurance"
+        if "housing" in t or "house " in t or "storage" in t or "shed" in t: return "housing"
+        return None
+
+    data = dict(raw)
+    if not data.get("which_cost"):
+        guess = _which_from_text(user)
+        if guess: data["which_cost"] = guess
+
+    # ---------- Pull fields with defensive casting ----------
+    def _f(x, default=None):
+        if x is None: return default
+        try: return float(x)
+        except: return default
+
+    equip = str(data.get("equipment_name", "tractor"))
+    acres = _f(data.get("acres"), 0.0)
+    speed = _f(data.get("speed_acph"), 1.0)
+    life  = _f(data.get("life_years"), 1.0)
+    cost  = _f(data.get("cost"), 0.0)
+    which = str(data.get("which_cost") or "")
+
+    hp     = _f(data.get("hp") if data.get("hp") is not None else data.get("pto_hp"))
+    diesel = _f(data.get("diesel_price"))
+    wage   = _f(data.get("wage"))
+    rate   = _f(data.get("rate"), 0.08)
+    if rate is not None and rate > 1.0:  # accept 8 or 8% as 0.08
+        rate = rate / 100.0
+
+    # ---------- Derived diagnostics (for the teacher JSON box) ----------
+    annual_hours  = acres / max(speed, 1e-9)
+    accum_hours   = life * annual_hours
+
+    # Salvage diagnostics
+    machine_class = classify_machine_for_salvage(equip, hp)
+    salv_frac = None
+    if machine_class:
+        try:
+            salv_frac = get_salvage_fraction(machine_class, annual_hours, life)
+        except Exception:
+            salv_frac = None
+    salvage = cost * (salv_frac if salv_frac is not None else 0.20)
+
+    # Repair fraction diagnostics (safe try)
+    repair_frac = None
+    repair_bracket = None
+    canon_name = equip
+    try:
+        rf, canon, lo, hi = get_repair_fraction(equip, accum_hours)
+        repair_frac = rf
+        repair_bracket = {"low": {"hours": lo[0], "frac": lo[1]},
+                          "high":{"hours": hi[0], "frac": hi[1]}}
+        canon_name = canon
+    except Exception:
+        pass
+
+    # ---------- Compute chosen cost ----------
+    ans = None
+    if which == "repair_per_acre_year":
+        # Use the same computation you already rely on
+        r = compute_repair_per_acre_year(equip, cost, life, acres, speed)
+        ans = f"Jerry → REPAIR per acre-year: fraction={r['fraction']:.3f}, value=${r['repair_per_acre_year']:.2f}/ac/yr (mode={mode})"
+    elif which == "fuel_per_acre":
+        if hp is None or diesel is None:
+            ans = f"Jerry → Need hp and diesel. (mode={mode})"
+        else:
+            f = compute_fuel_per_acre(hp, diesel, speed)
+            ans = f"Jerry → FUEL per acre=${f:.2f} (mode={mode})"
+    elif which == "lube_per_acre":
+        if hp is None or diesel is None:
+            ans = f"Jerry → Need hp and diesel. (mode={mode})"
+        else:
+            f = compute_fuel_per_acre(hp, diesel, speed)
+            l = compute_lube_per_acre(f)
+            ans = f"Jerry → LUBE per acre=${l:.2f} (mode={mode})"
+    elif which == "labor_per_acre":
+        if wage is None:
+            ans = f"Jerry → Need wage. (mode={mode})"
+        else:
+            l = compute_labor_per_acre(wage, speed)
+            ans = f"Jerry → LABOR per acre=${l:.2f} (mode={mode})"
+    elif which == "depreciation_per_acre_year":
+        salv_frac, salvage, salvage_class = salvage_parts(equip, cost, hp, acres, speed, life)
+        d = compute_depr_per_acre_year(cost, salvage, life, acres)
+        ans = (
+            f"Jerry → DEPRECIATION per acre-year=${d:.2f} "
+            f"(class={salvage_class}, salvage fraction={salv_frac:.2f}, salvage=${salvage:,.0f}; mode={mode})"
+        )
+    elif which == "occ_per_acre_year":
+        salv_frac, salvage, salvage_class = salvage_parts(equip, cost, hp, acres, speed, life)
+        o = compute_occ_per_acre_year(cost, salvage, rate, life, acres)
+        ans = (
+            f"Jerry → OCC per acre-year=${o:.2f} "
+            f"(class={salvage_class}, salvage fraction={salvage_frac:.2f}, salvage=${salvage:,.0f}; mode={mode})"
+        )
+    elif which == "tax":
+        tval = compute_tax_per_acre(cost, acres)
+        ans = f"Jerry → TAX per acre=${tval:.2f} (mode={mode})"
+    elif which == "insurance":
+        ival = compute_insurance_per_acre(cost, acres)
+        ans = f"Jerry → INSURANCE per acre=${ival:.2f} (mode={mode})"
+    elif which == "housing":
+        hval = compute_housing_per_acre(cost, acres)
+        ans = f"Jerry → HOUSING per acre=${hval:.2f} (mode={mode})"
+    else:
+        ans = f"Jerry → Unknown cost. (mode={mode})"
+
+    # ---------- Build teacher JSON (third box) ----------
+    teacher_json = _pp({
+        "mode": mode,
+        "raw_llm": raw_llm,
+        "raw_regex": raw_regex,
+        "final_data": data,
+        "derived": {
+            "machine_canonical": canon_name,
+            "machine_class_for_salvage": machine_class,
+            "annual_hours": annual_hours,
+            "accum_hours": accum_hours,
+            "salvage_fraction": salv_frac,
+            "salvage_value": salvage,
+            "repair_fraction": repair_frac,
+            "repair_bracket": repair_bracket,
+        }
+    })
+
+    # Return BOTH: (student answer, teacher JSON)
+    return ans, teacher_json
+
+
+# ---- UI ----
+with gr.Blocks(css="footer {visibility: hidden}") as demo:
+    gr.Markdown("## Jerry — NLP Farm Machinery Cost Coach (per-acre per-year, with salvage)")
+
+    # --- Session HUD state (persists across prompts within the browser session) ---
+    hud_state = gr.State({k: None for k in HUD_FIELDS})
+
+    with gr.Row():
+        with gr.Column():
+            q = gr.Textbox(label="Talk to Jerry", lines=4, placeholder="e.g., Tractor, acres=1000, speed=10 ac/hr, life=10, cost=$200000 — repair")
+            ask = gr.Button("Ask Jerry")
+        with gr.Column():
+            out = gr.Textbox(label="Jerry says", lines=8)
+        with gr.Column():
+            gr.Markdown("### Student HUD — what Jerry sees")
+            hud_box = gr.Textbox(label="Final Data (persists this session)", lines=18, value=_pp({k: None for k in HUD_FIELDS}))
+            changed_box = gr.Textbox(label="Fields updated by last prompt", lines=3, value="(none)")
+
+    # Optional: teacher debug accordion if you kept the teacher JSON earlier
+    # (If you added a teacher debug already, you can leave this out or keep your version.)
+    with gr.Accordion("Teacher debug — Parser & JSON (optional)", open=False):
+        dbg = gr.Textbox(label="LLM/Regex + Raw/Final JSON + Diagnostics", lines=22)
+
+    def _ask_with_hud(user_text, hud):
+        # ---- Parse (LLM first, then regex) ----
+        raw_llm = llm_parse(user_text)
+        if raw_llm:
+            mode = "LLM"; raw_regex = {}; raw = raw_llm
+        else:
+            mode = "regex"; raw_regex = regex_parse(user_text); raw = raw_regex
+
+        # Fallback which_cost if missing
+        def _which_from_text(txt: str):
+            t = (txt or "").lower()
+            if "fuel" in t: return "fuel_per_acre"
+            if "lube" in t or "lubric" in t: return "lube_per_acre"
+            if "labor" in t or "wage" in t: return "labor_per_acre"
+            if "depr" in t or "depreciation" in t or "straight line" in t: return "depreciation_per_acre_year"
+            if "occ" in t or "opportunity cost" in t or "interest" in t: return "occ_per_acre_year"
+            if "tax" in t: return "tax"
+            if "insurance" in t or "ins " in t: return "insurance"
+            if "housing" in t or "house " in t: return "housing"
+            if "repair" in t or "maint" in t: return "repair_per_acre_year"
+            return None
+
+        data = dict(raw)
+        if not data.get("which_cost"):
+            guessed = _which_from_text(user_text)
+            if guessed: data["which_cost"] = guessed
+
+        # ---- Merge into HUD memory ----
+        new_hud, changed = merge_into_hud(hud, data)
+
+        # Pull fields safely from HUD (not just this prompt)
+        equip = str(new_hud.get("equipment_name") or "tractor")
+        acres = float(new_hud.get("acres") or 0.0)
+        speed = float(new_hud.get("speed_acph") or 1.0)
+        life  = float(new_hud.get("life_years") or 1.0)
+        cost  = float(new_hud.get("cost") or 0.0)
+        which = str(new_hud.get("which_cost") or "")
+
+        hp     = new_hud.get("hp") if new_hud.get("hp") is not None else new_hud.get("pto_hp")
+        hp     = float(hp) if hp is not None else None
+        diesel = float(new_hud.get("diesel_price")) if new_hud.get("diesel_price") is not None else None
+        wage   = float(new_hud.get("wage")) if new_hud.get("wage") is not None else None
+        rate   = new_hud.get("rate")
+        if rate is not None:
+            rate = float(rate)
+            if rate > 1.0: rate = rate / 100.0  # accept 8 or 8% as 0.08
+        else:
+            rate = 0.08
+
+        # ---- Readiness check for chosen cost ----
+        if not which:
+            msg = "Jerry → Tell me which cost (e.g., fuel, repair, depreciation). Check the HUD to see what I have so far."
+            teacher_dbg = _pp({"mode": mode, "raw_llm": raw_llm, "raw_regex": raw_regex, "final_data": new_hud})
+            return msg, _pp(new_hud), ", ".join(changed) or "(none)", teacher_dbg, new_hud
+
+        missing = missing_for(which, new_hud)
+        if missing:
+            msg = f"Jerry → Not enough data for {which}. Missing: {', '.join(missing)}. Check the HUD and add what's missing."
+            teacher_dbg = _pp({"mode": mode, "raw_llm": raw_llm, "raw_regex": raw_regex, "final_data": new_hud, "missing": missing})
+            return msg, _pp(new_hud), ", ".join(changed) or "(none)", teacher_dbg, new_hud
+
+        # ---- Compute (now that HUD is complete for this cost) ----
+        salv_frac, salvage, salvage_class = salvage_parts(equip, cost, hp, acres, speed, life)
+        if which == "repair_per_acre_year":
+            r = compute_repair_per_acre_year(equip, cost, life, acres, speed)
+            ans = f"Jerry → REPAIR per acre-year: fraction={r['fraction']:.3f}, value=${r['repair_per_acre_year']:.2f}/ac/yr (mode={mode})"
+        elif which == "fuel_per_acre":
+            f = compute_fuel_per_acre(hp, diesel, speed)
+            ans = f"Jerry → FUEL per acre=${f:.2f} (mode={mode})"
+        elif which == "lube_per_acre":
+            f = compute_fuel_per_acre(hp, diesel, speed)
+            l = compute_lube_per_acre(f)
+            ans = f"Jerry → LUBE per acre=${l:.2f} (mode={mode})"
+        elif which == "labor_per_acre":
+            l = compute_labor_per_acre(wage, speed)
+            ans = f"Jerry → LABOR per acre=${l:.2f} (mode={mode})"
+        
+        elif which == "depreciation_per_acre_year":
+            d = compute_depr_per_acre_year(cost, salvage, life, acres)
+            ans = (
+                f"Jerry → DEPRECIATION per acre-year=${d:.2f} "
+                f"(salvage fraction={salv_frac:.2f}, salvage=${salvage:,.0f}; mode={mode})"
+            )
+        elif which == "occ_per_acre_year":
+            o = compute_occ_per_acre_year(cost, salvage, rate, life, acres)
+            ans = (
+                f"Jerry → OCC per acre-year=${o:.2f} "
+                f"(salvage fraction={salv_frac:.2f}, salvage=${salvage:,.0f}; mode={mode})"
+            )
+        elif which == "tax":
+            tval = compute_tax_per_acre(cost, acres)
+            ans = f"Jerry → TAX per acre=${tval:.2f} (mode={mode})"
+        elif which == "insurance":
+           ival = compute_insurance_per_acre(cost, acres)
+           ans = f"Jerry → INSURANCE per acre=${ival:.2f} (mode={mode})"
+        elif which == "housing":
+           hval = compute_housing_per_acre(cost, acres)
+           ans = f"Jerry → HOUSING per acre=${hval:.2f} (mode={mode})"
+        teacher_dbg = _pp({
+            "mode": mode,
+            "raw_llm": raw_llm,
+            "raw_regex": raw_regex,
+            "final_data": new_hud
+        })
+        return ans, _pp(new_hud), ", ".join(changed) or "(none)", teacher_dbg, new_hud
+
+    # Wire it up; we update 5 outputs: student answer, HUD JSON, changed fields, teacher debug, and the state
+    ask.click(_ask_with_hud, [q, hud_state], [out, hud_box, changed_box, dbg, hud_state])
+
+if __name__=="__main__":
+    demo.queue().launch(server_name="0.0.0.0",server_port=int(os.getenv("PORT","7860")))

repair_table_data.py

@@ -0,0 +1,236 @@
+# repair_table_data.py
+# Full Iowa State "Accumulated Repair Costs as a Percentage of New List Price" (Table 3)
+# Source figure: American Society of Agricultural Engineers (1996).
+# Provides: REPAIR_TABLE, get_repair_fraction(machine, hours), list_machines()
+
+from typing import Dict, Tuple, Optional, List
+import re
+
+# ----------------------------
+# 1) Canonical table (fractions, not percents)
+# ----------------------------
+REPAIR_TABLE: Dict[str, Dict[int, float]] = {
+    # --- Tractors ---
+    "Two-wheel drive tractor": {
+        1000: 0.01, 2000: 0.03, 3000: 0.06, 4000: 0.11, 5000: 0.18,
+        6000: 0.25, 7000: 0.34, 8000: 0.45, 9000: 0.57, 10000: 0.70
+    },
+    "Four-wheel drive tractor": {
+        1000: 0.00, 2000: 0.01, 3000: 0.03, 4000: 0.05, 5000: 0.08,
+        6000: 0.11, 7000: 0.15, 8000: 0.19, 9000: 0.24, 10000: 0.30
+    },
+
+    # --- Tillage Implements ---
+    "Moldboard plow": {200:0.02, 400:0.06, 600:0.12, 800:0.19, 1000:0.29,
+                       1200:0.40, 1400:0.53, 1600:0.68, 1800:0.84, 2000:1.01},
+    "Heavy-duty disk": {200:0.01, 400:0.04, 600:0.08, 800:0.12, 1000:0.18,
+                        1200:0.25, 1400:0.32, 1600:0.40, 1800:0.49, 2000:0.58},
+    "Tandem disk": {200:0.01, 400:0.04, 600:0.08, 800:0.12, 1000:0.18,
+                    1200:0.25, 1400:0.32, 1600:0.40, 1800:0.49, 2000:0.58},
+    "Chisel plow": {200:0.03, 400:0.08, 600:0.14, 800:0.20, 1000:0.28,
+                    1200:0.36, 1400:0.45, 1600:0.54, 1800:0.64, 2000:0.74},
+    "Field cultivator": {200:0.03, 400:0.07, 600:0.13, 800:0.20, 1000:0.27,
+                         1200:0.35, 1400:0.43, 1600:0.52, 1800:0.61, 2000:0.71},
+    "Harrow": {200:0.02, 400:0.05, 600:0.08, 800:0.12, 1000:0.16,
+               1200:0.22, 1400:0.29, 1600:0.37, 1800:0.46, 2000:0.56},
+    "Roller-packer, mulcher": {200:0.02, 400:0.05, 600:0.08, 800:0.12, 1000:0.16,
+                               1200:0.22, 1400:0.29, 1600:0.37, 1800:0.46, 2000:0.56},
+    "Rotary hoe": {200:0.02, 400:0.06, 600:0.11, 800:0.17, 1000:0.23,
+                   1200:0.29, 1400:0.37, 1600:0.44, 1800:0.52, 2000:0.60},
+    "Row crop cultivator": {200:0.00, 400:0.02, 600:0.06, 800:0.10, 1000:0.17,
+                            1200:0.25, 1400:0.36, 1600:0.48, 1800:0.62, 2000:0.78},
+
+    # --- Harvesters & Hay ---
+    "Corn picker": {200:0.00, 400:0.02, 600:0.04, 800:0.08, 1000:0.14,
+                    1200:0.21, 1400:0.30, 1600:0.41, 1800:0.54, 2000:0.69},
+    "Combine (pull)": {200:0.00, 400:0.02, 600:0.04, 800:0.08, 1000:0.14,
+                       1200:0.21, 1400:0.30, 1600:0.41, 1800:0.54, 2000:0.69},
+    "Potato harvester": {200:0.02, 400:0.05, 600:0.09, 800:0.14, 1000:0.19,
+                         1200:0.25, 1400:0.32, 1600:0.39, 1800:0.46, 2000:0.54},
+    "Mower-conditioner": {200:0.01, 400:0.04, 600:0.08, 800:0.13, 1000:0.18,
+                          1200:0.24, 1400:0.31, 1600:0.38, 1800:0.46, 2000:0.55},
+    "Mower-conditioner (rotary)": {200:0.01, 400:0.04, 600:0.08, 800:0.13, 1000:0.18,
+                                   1200:0.24, 1400:0.31, 1600:0.38, 1800:0.46, 2000:0.55},
+    "Rake": {200:0.02, 400:0.05, 600:0.09, 800:0.12, 1000:0.16,
+             1200:0.22, 1400:0.27, 1600:0.33, 1800:0.39, 2000:0.45},
+    "Rectangular baler": {200:0.01, 400:0.03, 600:0.06, 800:0.10, 1000:0.15,
+                          1200:0.20, 1400:0.26, 1600:0.32, 1800:0.38, 2000:0.45},
+    "Large square baler": {200:0.01, 400:0.03, 600:0.06, 800:0.10, 1000:0.15,
+                           1200:0.20, 1400:0.26, 1600:0.32, 1800:0.38, 2000:0.45},
+    "Forage harvester (pull)": {200:0.01, 400:0.03, 600:0.07, 800:0.10, 1000:0.15,
+                                1200:0.20, 1400:0.26, 1600:0.32, 1800:0.38, 2000:0.45},
+
+    "Forage harvester (SP)": {300:0.00, 600:0.01, 900:0.02, 1200:0.04, 1500:0.07,
+                              1800:0.10, 2100:0.13, 2400:0.17, 2700:0.22, 3000:0.27},
+    "Combine (SP)": {300:0.00, 600:0.01, 900:0.02, 1200:0.04, 1500:0.07,
+                     1800:0.10, 2100:0.13, 2400:0.17, 2700:0.22, 3000:0.27},
+    "Windrower (SP)": {300:0.01, 600:0.02, 900:0.04, 1200:0.09, 1500:0.15,
+                       1800:0.23, 2100:0.32, 2400:0.42, 2700:0.53, 3000:0.66},
+    "Cotton picker (SP)": {300:0.01, 600:0.04, 900:0.09, 1200:0.15, 1500:0.23,
+                           1800:0.32, 2100:0.42, 2400:0.53, 2700:0.66, 3000:0.79},
+
+    # --- Other Implements / Misc ---
+    "Mower (sickle)": {100:0.01, 200:0.03, 300:0.06, 400:0.10, 500:0.14,
+                       600:0.19, 700:0.25, 800:0.31, 900:0.38, 1000:0.46},
+    "Mower (rotary)": {100:0.00, 200:0.02, 300:0.04, 400:0.07, 500:0.11,
+                       600:0.16, 700:0.22, 800:0.28, 900:0.36, 1000:0.44},
+    "Large round baler": {100:0.01, 200:0.03, 300:0.06, 400:0.10, 500:0.15,
+                          600:0.20, 700:0.26, 800:0.33, 900:0.40, 1000:0.48},
+    "Sugar beet harvester": {100:0.03, 200:0.07, 300:0.12, 400:0.18, 500:0.24,
+                             600:0.30, 700:0.37, 800:0.44, 900:0.51, 1000:0.59},
+    "Rotary tiller": {100:0.01, 200:0.03, 300:0.06, 400:0.09, 500:0.13,
+                      600:0.17, 700:0.22, 800:0.27, 900:0.33, 1000:0.40},
+    "Row crop planter": {100:0.00, 200:0.01, 300:0.03, 400:0.05, 500:0.07,
+                         600:0.09, 700:0.11, 800:0.15, 900:0.20, 1000:0.26},
+    "Grain drill": {100:0.01, 200:0.03, 300:0.06, 400:0.09, 500:0.13,
+                    600:0.19, 700:0.26, 800:0.32, 900:0.40, 1000:0.47},
+    "Fertilizer spreader": {100:0.03, 200:0.08, 300:0.13, 400:0.19, 500:0.26,
+                            600:0.32, 700:0.40, 800:0.47, 900:0.55, 1000:0.63},
+
+    # --- Sprayers & Wagons ---
+    "Boom-type sprayer": {200:0.05, 400:0.12, 600:0.21, 800:0.31, 1000:0.41,
+                          1200:0.52, 1400:0.63, 1600:0.76, 1800:0.88, 2000:1.01},
+    "Air-carrier sprayer": {200:0.02, 400:0.05, 600:0.09, 800:0.14, 1000:0.20,
+                            1200:0.27, 1400:0.34, 1600:0.42, 1800:0.51, 2000:0.61},
+    "Bean puller-windrower": {200:0.02, 400:0.05, 600:0.09, 800:0.14, 1000:0.20,
+                              1200:0.27, 1400:0.34, 1600:0.42, 1800:0.51, 2000:0.61},
+    "Stalk chopper": {200:0.03, 400:0.08, 600:0.14, 800:0.20, 1000:0.28,
+                      1200:0.36, 1400:0.45, 1600:0.54, 1800:0.64, 2000:0.74},
+    "Forage blower": {200:0.01, 400:0.04, 600:0.09, 800:0.15, 1000:0.22,
+                      1200:0.29, 1400:0.37, 1600:0.46, 1800:0.56, 2000:0.67},
+    "Wagon": {200:0.01, 400:0.04, 600:0.07, 800:0.11, 1000:0.16,
+              1200:0.21, 1400:0.27, 1600:0.34, 1800:0.41, 2000:0.49},
+    "Forage wagon": {200:0.02, 400:0.06, 600:0.10, 800:0.14, 1000:0.19,
+                     1200:0.24, 1400:0.29, 1600:0.35, 1800:0.41, 2000:0.47},
+}
+
+# ----------------------------
+# 2) Name normalization / synonyms
+# ----------------------------
+_CANON = {k.lower(): k for k in REPAIR_TABLE.keys()}
+
+_SYNONYMS = {
+    # tractors
+    "2wd": "Two-wheel drive tractor",
+    "two wheel drive": "Two-wheel drive tractor",
+    "two-wheel drive": "Two-wheel drive tractor",
+    "two wheel drive tractor": "Two-wheel drive tractor",
+
+    "4wd": "Four-wheel drive tractor",
+    "four wheel drive": "Four-wheel drive tractor",
+    "four-wheel drive": "Four-wheel drive tractor",
+    "four wheel drive tractor": "Four-wheel drive tractor",
+
+    # common short names
+    "tractor": "Two-wheel drive tractor",  # default if just "tractor"
+    "sp forage harvester": "Forage harvester (SP)",
+    "sp combine": "Combine (SP)",
+    "sp windrower": "Windrower (SP)",
+}
+
+# --- add these course-specific aliases (repair table name mapping) ---
+_SYNONYMS.update({
+    # fertilizer equipment
+    "fertilizer sprayer": "Fertilizer spreader",
+    "fert sprayer": "Fertilizer spreader",
+    "fert spreader": "Fertilizer spreader",
+    "fertiliser sprayer": "Fertilizer spreader",
+    "fertiliser spreader": "Fertilizer spreader",
+
+    # disks
+    "offset disk": "Heavy-duty disk",
+    "offset disc": "Heavy-duty disk",
+    "hd disk": "Heavy-duty disk",
+    "heavy duty disk": "Heavy-duty disk",
+    "heavy-duty disc": "Heavy-duty disk",
+
+    # grain drill
+    "drill seeder": "Grain drill",
+    "drill": "Grain drill",
+    "seeder": "Grain drill",
+})
+
+
+def _normalize_name(s: str) -> Optional[str]:
+    key = re.sub(r"\s+", " ", s.strip().lower())
+    if key in _CANON:
+        return _CANON[key]
+    if key in _SYNONYMS:
+        return _SYNONYMS[key]
+    # try loose contains
+    for alias, canon in _SYNONYMS.items():
+        if alias in key:
+            return canon
+    # last resort: pick a canonical that fully appears
+    for canon_lower, canon in _CANON.items():
+        if canon_lower in key:
+            return canon
+    return None
+
+# ----------------------------
+# 3) Interpolation / extrapolation
+# ----------------------------
+def _sorted_points(machine: str) -> List[Tuple[int, float]]:
+    pts = list(REPAIR_TABLE[machine].items())
+    pts.sort(key=lambda x: x[0])
+    return pts
+
+def _interp(x0: float, y0: float, x1: float, y1: float, x: float) -> float:
+    if x1 == x0:
+        return y0
+    return y0 + (y1 - y0) * ((x - x0) / (x1 - x0))
+
+def get_repair_fraction(machine_name: str, hours: float) -> Tuple[float, str, Tuple[int, float], Tuple[int, float]]:
+    """
+    Returns:
+      fraction (0..1+), canonical_machine_name, (x_lo,y_lo), (x_hi,y_hi)
+    Uses linear interpolation between nearest table points. Extrapolates gently
+    beyond edges (linear using last two points).
+    """
+    if hours < 0:
+        hours = 0.0
+
+    canon = _normalize_name(machine_name) or "Two-wheel drive tractor"
+    pts = _sorted_points(canon)
+    xs = [p[0] for p in pts]
+
+    # below range
+    if hours <= xs[0]:
+        x0, y0 = pts[0]
+        x1, y1 = pts[1]
+        y = _interp(x0, y0, x1, y1, hours)
+        return max(0.0, y), canon, (x0, y0), (x1, y1)
+
+    # above range
+    if hours >= xs[-1]:
+        x0, y0 = pts[-2]
+        x1, y1 = pts[-1]
+        y = _interp(x0, y0, x1, y1, hours)
+        return max(0.0, y), canon, (x0, y0), (x1, y1)
+
+    # interior: find bracketing points
+    for i in range(1, len(pts)):
+        x0, y0 = pts[i-1]
+        x1, y1 = pts[i]
+        if x0 <= hours <= x1:
+            y = _interp(x0, y0, x1, y1, hours)
+            return max(0.0, y), canon, (x0, y0), (x1, y1)
+
+    # should not reach here
+    x0, y0 = pts[0]
+    x1, y1 = pts[1]
+    return y0, canon, (x0, y0), (x1, y1)
+
+# ----------------------------
+# 4) Utilities
+# ----------------------------
+def list_machines() -> List[str]:
+    """Return the list of canonical machine names available in the table."""
+    return sorted(REPAIR_TABLE.keys())
+
+def describe_machine_match(name: str) -> str:
+    """Debug helper: shows which canonical name a user string maps to."""
+    c = _normalize_name(name)
+    if not c:
+        return f"No match for '{name}'. Known: {', '.join(list_machines()[:8])}…"
+    return f"'{name}' → '{c}'"

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.36.1
+scikit-learn
+pypdf
+openai>=1.37.0  # optional; only used if OPENAI_API_KEY is set

salvage_table_data.py

@@ -0,0 +1,78 @@
+# salvage_table_data.py — exact values transcribed from Iowa State PM 710 (Tables 1a & 1b)
+# Format:
+#   For tractors & combines: nested by annual-hours band → { age(years): fraction_of_new_price }
+#   For implements (Table 1b): single band 0 → { age: fraction }  (age-only, no hours dependence)
+
+SALVAGE_TABLE = {
+    # ---------- Table 1a: TRACTORS ----------
+    "30-79 hp tractor": {
+        200: {1:0.65, 2:0.59, 3:0.54, 4:0.51, 5:0.48, 6:0.45, 7:0.42, 8:0.40, 9:0.38,10:0.36,
+              11:0.35,12:0.33,13:0.32,14:0.30,15:0.29,16:0.28,17:0.26,18:0.25,19:0.24,20:0.23},
+        400: {1:0.60, 2:0.54, 3:0.49, 4:0.46, 5:0.43, 6:0.40, 7:0.38, 8:0.36, 9:0.34,10:0.32,
+              11:0.31,12:0.29,13:0.28,14:0.27,15:0.25,16:0.24,17:0.23,18:0.22,19:0.21,20:0.20},
+        600: {1:0.56, 2:0.50, 3:0.46, 4:0.43, 5:0.40, 6:0.37, 7:0.35, 8:0.33, 9:0.31,10:0.30,
+              11:0.28,12:0.27,13:0.25,14:0.24,15:0.23,16:0.22,17:0.21,18:0.20,19:0.19,20:0.18},
+    },
+
+    "80-149 hp tractor": {
+        200: {1:0.69, 2:0.62, 3:0.57, 4:0.53, 5:0.50, 6:0.47, 7:0.44, 8:0.42, 9:0.40,10:0.38,
+              11:0.36,12:0.34,13:0.33,14:0.31,15:0.30,16:0.28,17:0.27,18:0.26,19:0.25,20:0.24},
+        400: {1:0.68, 2:0.62, 3:0.57, 4:0.53, 5:0.49, 6:0.46, 7:0.44, 8:0.41, 9:0.39,10:0.37,
+              11:0.35,12:0.34,13:0.32,14:0.31,15:0.29,16:0.28,17:0.27,18:0.25,19:0.24,20:0.23},
+        600: {1:0.68, 2:0.61, 3:0.56, 4:0.52, 5:0.49, 6:0.46, 7:0.43, 8:0.41, 9:0.39,10:0.37,
+              11:0.35,12:0.33,13:0.32,14:0.30,15:0.29,16:0.27,17:0.26,18:0.25,19:0.24,20:0.23},
+    },
+
+    "150+ hp tractor": {
+        200: {1:0.69, 2:0.61, 3:0.55, 4:0.51, 5:0.47, 6:0.43, 7:0.40, 8:0.38, 9:0.35,10:0.33,
+              11:0.31,12:0.29,13:0.27,14:0.25,15:0.24,16:0.22,17:0.21,18:0.20,19:0.19,20:0.17},
+        400: {1:0.67, 2:0.59, 3:0.54, 4:0.49, 5:0.45, 6:0.42, 7:0.39, 8:0.36, 9:0.34,10:0.32,
+              11:0.30,12:0.28,13:0.26,14:0.24,15:0.23,16:0.21,17:0.20,18:0.19,19:0.18,20:0.17},
+        600: {1:0.66, 2:0.58, 3:0.52, 4:0.48, 5:0.44, 6:0.41, 7:0.38, 8:0.35, 9:0.33,10:0.31,
+              11:0.29,12:0.27,13:0.25,14:0.24,15:0.22,16:0.21,17:0.19,18:0.18,19:0.17,20:0.16},
+    },
+
+    # ---------- Table 1a: COMBINE / FORAGE HARVESTER ----------
+    "combine/forage harvester": {
+        100: {1:0.79, 2:0.67, 3:0.59, 4:0.52, 5:0.47, 6:0.42, 7:0.38, 8:0.35, 9:0.31,10:0.28,
+              11:0.26,12:0.23,13:0.21,14:0.19,15:0.17,16:0.16,17:0.14,18:0.13,19:0.11,20:0.10},
+        300: {1:0.69, 2:0.58, 3:0.50, 4:0.44, 5:0.39, 6:0.35, 7:0.31, 8:0.28, 9:0.25,10:0.23,
+              11:0.20,12:0.18,13:0.16,14:0.14,15:0.13,16:0.11,17:0.10,18:0.09,19:0.08,20:0.07},
+        500: {1:0.63, 2:0.52, 3:0.45, 4:0.39, 5:0.34, 6:0.30, 7:0.27, 8:0.24, 9:0.21,10:0.19,
+              11:0.17,12:0.15,13:0.13,14:0.12,15:0.10,16:0.09,17:0.08,18:0.07,19:0.06,20:0.05},
+    },
+
+    # ---------- Table 1b: IMPLEMENTS (age-only) ----------
+    "plows": { 0: {1:0.47, 2:0.44, 3:0.42, 4:0.40, 5:0.39, 6:0.38, 7:0.36, 8:0.35, 9:0.34,10:0.33,
+                    11:0.32,12:0.32,13:0.31,14:0.30,15:0.29,16:0.29,17:0.28,18:0.27,19:0.27,20:0.26}},
+    "other tillage": { 0: {1:0.61, 2:0.54, 3:0.49, 4:0.45, 5:0.42, 6:0.39, 7:0.36, 8:0.34, 9:0.31,10:0.30,
+                           11:0.28,12:0.26,13:0.24,14:0.23,15:0.22,16:0.20,17:0.19,18:0.18,19:0.17,20:0.16}},
+    "planter, drill, sprayer": { 0: {1:0.65, 2:0.60, 3:0.56, 4:0.53, 5:0.50, 6:0.48, 7:0.46, 8:0.44, 9:0.42,10:0.40,
+                                     11:0.39,12:0.38,13:0.36,14:0.35,15:0.34,16:0.33,17:0.32,18:0.30,19:0.29,20:0.29}},
+    "mower, chopper": { 0: {1:0.47, 2:0.44, 3:0.41, 4:0.39, 5:0.37, 6:0.35, 7:0.33, 8:0.32, 9:0.31,10:0.30,
+                            11:0.28,12:0.27,13:0.26,14:0.26,15:0.25,16:0.24,17:0.23,18:0.22,19:0.22,20:0.21}},
+    "baler": { 0: {1:0.56, 2:0.50, 3:0.46, 4:0.42, 5:0.39, 6:0.37, 7:0.34, 8:0.32, 9:0.30,10:0.28,
+                   11:0.27,12:0.25,13:0.24,14:0.22,15:0.21,16:0.20,17:0.19,18:0.18,19:0.17,20:0.16}},
+    "swather, rake": { 0: {1:0.49, 2:0.44, 3:0.40, 4:0.37, 5:0.35, 6:0.32, 7:0.30, 8:0.28, 9:0.27,10:0.25,
+                           11:0.24,12:0.23,13:0.21,14:0.20,15:0.19,16:0.18,17:0.17,18:0.16,19:0.16,20:0.15}},
+    "vehicle": { 0: {1:0.42, 2:0.39, 3:0.36, 4:0.34, 5:0.33, 6:0.31, 7:0.30, 8:0.29, 9:0.27,10:0.26,
+                     11:0.25,12:0.24,13:0.24,14:0.23,15:0.22,16:0.21,17:0.20,18:0.20,19:0.19,20:0.19}},
+    "others": { 0: {1:0.69, 2:0.62, 3:0.56, 4:0.52, 5:0.48, 6:0.45, 7:0.42, 8:0.40, 9:0.37,10:0.35,
+                    11:0.33,12:0.31,13:0.29,14:0.28,15:0.26,16:0.25,17:0.24,18:0.22,19:0.21,20:0.20}},
+}
+
+# salvage_table_data.py (at the end)
+# Make a case-insensitive view
+# --- Normalize keys so lookups are case-insensitive and space-insensitive ---
+def _norm_key(s: str) -> str:
+    return "".join(s.lower().split())  # lowercase + remove all whitespace
+
+# Build a normalized alias map (in addition to the original keys)
+_SALV_NORM = {}
+for k, v in list(SALVAGE_TABLE.items()):
+    if isinstance(k, str):
+        _SALV_NORM[_norm_key(k)] = v
+
+# Public accessor dict: original keys + normalized clones
+SALVAGE_TABLE_NORM = dict(_SALV_NORM)
+