Spaces:
Sleeping
Sleeping
| # 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"))) | |