Upload salvage_lookup.py

salvage_lookup.py

@@ -0,0 +1,155 @@
+# salvage_lookup.py — robust salvage class & fraction lookup (Iowa PM 710 tables)
+
+from typing import Dict, Optional
+from salvage_table_data import SALVAGE_TABLE
+
+# -------- Linear helpers --------
+def _lin(x1, y1, x2, y2, x):
+    if x1 == x2:
+        return float(y1)
+    return float(y1) + (float(y2) - float(y1)) * ((float(x) - float(x1)) / (float(x2) - float(x1)))
+
+def _interp_on_sorted(xs, ys, x):
+    xs = list(xs); ys = list(ys)
+    if len(xs) == 1:
+        return float(ys[0])
+    if x <= xs[0]:
+        return _lin(xs[0], ys[0], xs[1], ys[1], x)
+    if x >= xs[-1]:
+        return _lin(xs[-2], ys[-2], xs[-1], ys[-1], x)
+    for i in range(len(xs) - 1):
+        if xs[i] <= x <= xs[i+1]:
+            return _lin(xs[i], ys[i], xs[i+1], ys[i+1], x)
+    return float(ys[-1])
+
+# -------- Table access that tolerates case/spacing --------
+def _get_table_for(mclass: str) -> Optional[Dict]:
+    if not mclass:
+        return None
+    # exact
+    t = SALVAGE_TABLE.get(mclass)
+    if t is not None:
+        return t
+    # lower
+    t = SALVAGE_TABLE.get(mclass.lower())
+    if t is not None:
+        return t
+    # strip spaces/commas/hyphens variants
+    mnorm = "".join(ch for ch in mclass.lower() if ch.isalnum())
+    for k in SALVAGE_TABLE.keys():
+        knorm = "".join(ch for ch in k.lower() if ch.isalnum())
+        if knorm == mnorm:
+            return SALVAGE_TABLE[k]
+    return None
+
+# -------- Public: salvage fraction lookup --------
+def get_salvage_fraction(mclass: Optional[str], annual_hours: float, age_years: float) -> Optional[float]:
+    """
+    For tractors/combines (banded by annual hours): interpolate across bands, then across age.
+    For implements (age-only): ignore annual_hours and interpolate across age.
+    Returns fraction of new list price at given age.
+    """
+    if not mclass:
+        return None
+
+    table = _get_table_for(mclass)
+    if table is None:
+        return None
+
+    age = float(int(round(age_years)))  # PM 710 ages are integer 1..20
+
+    # IMPLEMENTS: either {age: frac} or {0:{age:frac}}
+    first_val = next(iter(table.values()))
+    if isinstance(first_val, (int, float)):
+        ages = sorted(table.keys())
+        vals = [table[a] for a in ages]
+        return float(_interp_on_sorted(ages, vals, age))
+    if len(table) == 1 and isinstance(first_val, dict):
+        inner = first_val
+        ages = sorted(inner.keys())
+        vals = [inner[a] for a in ages]
+        return float(_interp_on_sorted(ages, vals, age))
+
+    # TRACTORS / COMBINES: {band_hours: {age: frac}}
+    bands = sorted(table.keys())
+    def frac_at(band):
+        col = table[band]
+        ages = sorted(col.keys())
+        vals = [col[a] for a in ages]
+        return _interp_on_sorted(ages, vals, age)
+
+    if len(bands) == 1:
+        return float(frac_at(bands[0]))
+
+    # Interpolate across hour bands at the given annual_hours
+    if annual_hours <= bands[0]:
+        f1, f2 = frac_at(bands[0]), frac_at(bands[1])
+        return float(_lin(bands[0], f1, bands[1], f2, annual_hours))
+    if annual_hours >= bands[-1]:
+        f1, f2 = frac_at(bands[-2]), frac_at(bands[-1])
+        return float(_lin(bands[-2], f1, bands[-1], f2, annual_hours))
+    for i in range(len(bands) - 1):
+        lo, hi = bands[i], bands[i+1]
+        if lo <= annual_hours <= hi:
+            f_lo, f_hi = frac_at(lo), frac_at(hi)
+            return float(_lin(lo, f_lo, hi, f_hi, annual_hours))
+
+    return None  # should not hit
+
+# -------- Classifier (one definitive version) --------
+OVERRIDE_MAP = {
+    # Your course-specific mapping choice:
+    # Treat disks as "plows" so they use the plow salvage column (as you requested).
+    "heavy-duty disk": "plows",
+    "heavy duty disk": "plows",
+    "disk": "plows",
+    "disc": "plows",
+}
+
+def classify_machine_for_salvage(name: str, hp: Optional[float]) -> Optional[str]:
+    """
+    Map a free-text equipment string (+ optional hp) to the PM 710 class names used in SALVAGE_TABLE.
+    """
+    s = (name or "").lower().strip()
+
+    # 0) explicit overrides first (substring match)
+    for key, cls in OVERRIDE_MAP.items():
+        if key in s:
+            return cls
+
+    # 1) Tractors (three HP bands)
+    if "tractor" in s:
+        try:
+            h = float(hp) if hp is not None else None
+        except Exception:
+            h = None
+        if h is None:
+            return "80-149 hp tractor"
+        if h >= 150:
+            return "150+ hp tractor"
+        if h >= 80:
+            return "80-149 hp tractor"
+        return "30-79 hp tractor"
+
+    # 2) Combines / Forage harvesters
+    if any(k in s for k in ["combine", "forage harvester", "forage-harvester", "silage harvester"]):
+        return "combine/forage harvester"
+
+    # 3) Implements (Table 1b buckets)
+    if any(k in s for k in ["plow", "moldboard"]):
+        return "plows"
+    if any(k in s for k in ["disk", "disc", "harrow", "chisel", "cultivator", "roller", "mulcher", "rotary hoe", "tiller"]):
+        return "other tillage"
+    if any(k in s for k in ["planter", "drill", "sprayer", "boom sprayer"]):
+        return "planter, drill, sprayer"
+    if any(k in s for k in ["mower", "chopper", "windrower"]):
+        return "mower, chopper"
+    if "baler" in s:
+        return "baler"
+    if any(k in s for k in ["swather", "rake"]):
+        return "swather, rake"
+    if any(k in s for k in ["truck", "pickup", "vehicle"]):
+        return "vehicle"
+
+    # 4) Fallback
+    return "others"