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) | |
| # Blackbord helpers | |
| # ---------- Blackboard helpers ---------- | |
| def _fmt_money(x): | |
| return f"${x:,.2f}" | |
| def _fmt_pct(x): | |
| return f"{x*100:.1f}%" | |
| def explain_repair(equip, cost, life, acres, speed, frac, hours, per_ac_yr): | |
| # Iowa method: AccumHours = life * (acres / speed) and Repair$/ac/yr = (Cost × AccumRepairFraction) / (life × acres) | |
| # Sources: Repair method & per-year/per-acre basis in course notes. | |
| src = "Iowa table (Accumulated Repair Fraction) — see class notes." | |
| return ( | |
| "REPAIR — show your work\n" | |
| f"1) Accumulated hours: hours = life × (acres / speed) = {life:g} × ({acres:g} / {speed:g}) = {hours:,.1f} hr.\n" | |
| f"2) Table lookup: fraction = {frac:.4f} ({_fmt_pct(frac)}) ← {src}\n" | |
| f"3) Total lifetime repair $: Cost × fraction = {_fmt_money(cost)} × {frac:.4f} = {_fmt_money(cost*frac)}.\n" | |
| f"4) Per-acre-per-year: lifetime_repair ÷ (life × acres) = {_fmt_money(cost*frac)} ÷ ({life:g} × {acres:g}) = {_fmt_money(per_ac_yr)} per ac/yr." | |
| ) | |
| def explain_fuel(hp, diesel, speed, per_ac): | |
| # Fuel Cost per ac = (0.044 × PTO HP × Diesel $/gal) / speed_acph | |
| # Reference: fuel formula in notes. | |
| return ( | |
| "FUEL — show your work\n" | |
| f"Fuel$/ac = (0.044 × PTO_HP × diesel_price) ÷ speed\n" | |
| f" = (0.044 × {hp:g} × {_fmt_money(diesel)}/gal) ÷ {speed:g}\n" | |
| f" = {_fmt_money(per_ac)} per ac." | |
| ) | |
| def explain_lube(fuel_per_ac, lube_per_ac): | |
| # Lube = 0.15 × Fuel (Iowa) | |
| return ( | |
| "LUBE — show your work\n" | |
| f"Lube$/ac = 0.15 × Fuel$/ac = 0.15 × {_fmt_money(fuel_per_ac)} = {_fmt_money(lube_per_ac)} per ac." | |
| ) | |
| def explain_labor(wage, speed, per_ac): | |
| # Labor$/ac = wage / speed | |
| return ( | |
| "LABOR — show your work\n" | |
| f"Labor$/ac = wage ÷ speed = {_fmt_money(wage)} ÷ {speed:g} = {_fmt_money(per_ac)} per ac." | |
| ) | |
| def explain_depr(cost, salvage_frac, salvage, life, acres, per_ac_yr): | |
| # Dep$/ac/yr = (C − S) / (life × acres) | |
| return ( | |
| "DEPRECIATION — show your work\n" | |
| f"1) Salvage fraction from table = {salvage_frac:.3f} ({_fmt_pct(salvage_frac)}); Salvage S = {_fmt_money(salvage)}.\n" | |
| f"2) Dep$/ac/yr = (C − S) ÷ (life × acres) = ({_fmt_money(cost)} − {_fmt_money(salvage)}) ÷ ({life:g} × {acres:g})\n" | |
| f" = {_fmt_money(per_ac_yr)} per ac/yr." | |
| ) | |
| def explain_occ(cost, salvage, rate, acres, per_ac_yr): | |
| # OCC$/ac/yr = rate × ((C + S)/2) ÷ acres (no division by life) | |
| avg_inv = 0.5*(cost+salvage) | |
| return ( | |
| "OPPORTUNITY COST OF CAPITAL — show your work\n" | |
| f"Avg investment = (C + S)/2 = ({_fmt_money(cost)} + {_fmt_money(salvage)}) / 2 = {_fmt_money(avg_inv)}.\n" | |
| f"OCC$/ac/yr = rate × AvgInvestment ÷ acres = {rate:.3f} × {_fmt_money(avg_inv)} ÷ {acres:g}\n" | |
| f" = {_fmt_money(per_ac_yr)} per ac/yr." | |
| ) | |
| def explain_tax_ins_housing(kind, cost, per_ac): | |
| # Tax=1% of cost; Insurance=0.5%; Housing=0.5% (annual) then ÷ acres for per-acre basis | |
| rates = {"tax":0.01, "insurance":0.005, "housing":0.005} | |
| r = rates[kind] | |
| label = {"tax":"TAX","insurance":"INSURANCE","housing":"HOUSING"}[kind] | |
| return ( | |
| f"{label} — show your work\n" | |
| f"{label}$/ac/yr = ({r:.3f} × Cost) ÷ acres = ({r:.3f} × {_fmt_money(cost)}) ÷ acres = {_fmt_money(per_ac)} per ac/yr." | |
| ) | |
| # ---- 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)") | |
| # NEW: a Blackboard textbox (under your teacher accordion or right below out) | |
| #blackboard = gr.Textbox(label="Blackboard — step-by-step", lines=14) | |
| steps_box = gr.Textbox(label="Blackboard — show the work", lines=16, 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): | |
| """ | |
| Returns SIX values in this order: | |
| 1) student answer (string) | |
| 2) HUD JSON (string) | |
| 3) changed fields (string) | |
| 4) teacher debug JSON (string) | |
| 5) new HUD state (dict) | |
| 6) blackboard/steps text (string) | |
| """ | |
| steps_text = "(none)" # Blackboard default | |
| # ---- 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 | |
| else: | |
| rate = 0.08 | |
| # ---- If no which_cost, early return (SIX outputs) ---- | |
| 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, steps_text | |
| # ---- Check readiness for chosen cost; early return if missing (SIX outputs) ---- | |
| 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, steps_text | |
| # ---- Derived diagnostics for Blackboard (safe) ---- | |
| # salvage parts (works whether salvage_parts exists or not) | |
| def _safe_salvage_parts(equip, cost, hp, acres, speed, life): | |
| try: | |
| # try the convenience helper if present in your file | |
| return salvage_parts(equip, cost, hp, acres, speed, life) # (frac, salvage, class) | |
| except Exception: | |
| # fallback to the earlier direct computation | |
| try: | |
| machine_class = classify_machine_for_salvage(equip, hp) | |
| except Exception: | |
| machine_class = None | |
| try: | |
| annual_hours = float(acres)/max(float(speed), 1e-9) | |
| except Exception: | |
| annual_hours = 0.0 | |
| try: | |
| salv_frac = get_salvage_fraction(machine_class, annual_hours, float(life)) if machine_class else None | |
| except Exception: | |
| salv_frac = None | |
| if salv_frac is None: | |
| salv_frac = 0.20 | |
| return float(salv_frac), float(cost)*float(salv_frac), machine_class or equip | |
| salv_frac, salvage, salvage_class = _safe_salvage_parts(equip, cost, hp, acres, speed, life) | |
| # ---- Compute chosen cost + Blackboard text ---- | |
| 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})" | |
| # Blackboard | |
| try: | |
| steps_text = explain_repair( | |
| equip=equip, cost=cost, life=life, acres=acres, speed=speed, | |
| frac=r["fraction"], hours=r["hours"], per_ac_yr=r["repair_per_acre_year"] | |
| ) | |
| except Exception: | |
| steps_text = "(repair: explanation unavailable)" | |
| elif which == "fuel_per_acre": | |
| f = compute_fuel_per_acre(hp, diesel, speed) | |
| ans = f"Jerry → FUEL per acre=${f:.2f} (mode={mode})" | |
| try: | |
| steps_text = explain_fuel(hp=hp, diesel=diesel, speed=speed, per_ac=f) | |
| except Exception: | |
| steps_text = "(fuel: explanation unavailable)" | |
| 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})" | |
| try: | |
| steps_text = explain_lube(fuel_per_ac=f, lube_per_ac=l) | |
| except Exception: | |
| steps_text = "(lube: explanation unavailable)" | |
| elif which == "labor_per_acre": | |
| l = compute_labor_per_acre(wage, speed) | |
| ans = f"Jerry → LABOR per acre=${l:.2f} (mode={mode})" | |
| try: | |
| steps_text = explain_labor(wage=wage, speed=speed, per_ac=l) | |
| except Exception: | |
| steps_text = "(labor: explanation unavailable)" | |
| 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} (salvage fraction={salv_frac:.2f}, salvage=${salvage:,.0f}; mode={mode})" | |
| try: | |
| steps_text = explain_depr(cost=cost, salvage_frac=salv_frac, salvage=salvage, life=life, acres=acres, per_ac_yr=d) | |
| except Exception: | |
| steps_text = "(depreciation: explanation unavailable)" | |
| 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} (salvage fraction={salv_frac:.2f}, salvage=${salvage:,.0f}; mode={mode})" | |
| try: | |
| steps_text = explain_occ(cost=cost, salvage=salvage, rate=rate, acres=acres, per_ac_yr=o) | |
| except Exception: | |
| steps_text = "(OCC: explanation unavailable)" | |
| elif which == "tax": | |
| t = compute_tax_per_acre(cost, acres) | |
| ans = f"Jerry → TAX per acre-year=${t:.2f} (mode={mode})" | |
| try: | |
| steps_text = explain_tax_ins_housing("tax", cost, t) | |
| except Exception: | |
| steps_text = "(tax: explanation unavailable)" | |
| elif which == "insurance": | |
| ins = compute_insurance_per_acre(cost, acres) | |
| ans = f"Jerry → INSURANCE per acre-year=${ins:.2f} (mode={mode})" | |
| try: | |
| steps_text = explain_tax_ins_housing("insurance", cost, ins) | |
| except Exception: | |
| steps_text = "(insurance: explanation unavailable)" | |
| elif which == "housing": | |
| h = compute_housing_per_acre(cost, acres) | |
| ans = f"Jerry → HOUSING per acre-year=${h:.2f} (mode={mode})" | |
| try: | |
| steps_text = explain_tax_ins_housing("housing", cost, h) | |
| except Exception: | |
| steps_text = "(housing: explanation unavailable)" | |
| else: | |
| ans = f"Jerry → Unknown cost. (mode={mode})" | |
| steps_text = "(none)" | |
| 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, steps_text | |
| # 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]) | |
| ask.click( | |
| _ask_with_hud, | |
| [q, hud_state], # <-- 2 inputs ONLY | |
| [out, hud_box, changed_box, dbg, hud_state, steps_box] # <-- 6 outputs | |
| ) | |
| # add this after `changed_box` definition | |
| # --- Blackboard (always on) --- | |
| if __name__=="__main__": | |
| demo.queue().launch(server_name="0.0.0.0",server_port=int(os.getenv("PORT","7860"))) | |