engine.py

"""TariffWise engine. Deterministic walk of the Chapter 64 tree.

The walk descends from a heading to a ten digit leaf. At each node the
children are evaluated in schedule order. A child matches, fails, or needs
a fact. A needed fact stops the walk and names the gap. An unparsed
condition stops the walk for review. The path taken is the rationale.
"""
import json
import re

NODES = json.load(open("tree.json"))
BYID = {n["id"]: n for n in NODES}
ROOTS = [n for n in NODES if n["parent"] is None]

# ---------------------------------------------------------------------
# Fact schema. Every key the schedule's splits can turn on.
# ---------------------------------------------------------------------
FACT_KEYS = {
    "sole_material":      "outer sole constituent material, rubber_plastics, leather, composition_leather, or other",
    "upper_material":     "upper constituent material by greatest external surface area, rubber_plastics, leather, composition_leather, textile, or other",
    "upper_textile_kind": "when the upper is textile, vegetable_fibers, wool_felt, or other_textile",
    "waterproof_molded":  "true when soles and uppers are rubber or plastics and the upper is neither fixed to the sole nor assembled by stitching, riveting, nailing, screwing, plugging or similar",
    "protective":         "true when the footwear protects against water, oil, grease, chemicals, cold or inclement weather",
    "metal_toe_cap":      "true when a protective metal toe cap is present",
    "covers_ankle":       "true when the footwear covers the ankle",
    "covers_knee":        "true when the footwear covers the knee",
    "sports_spikes":      "true when designed for a sport with spikes, sprigs, stops, clips, bars or provision for them, or ski, skating, snowboard, wrestling, boxing or cycling boots",
    "ski_boot":           "true for ski boots, cross country ski footwear and snowboard boots",
    "athletic_like":      "true for tennis shoes, basketball shoes, gym shoes, training shoes and the like",
    "leather_esa_over_50":"true when over 50 percent of the upper external surface area is leather including accessories added back",
    "value_per_pair":     "customs value in US dollars per pair",
    "gender_age":         "men, women, youths_boys, misses, children, infants, or unisex",
    "house_slipper":      "true for house slippers",
    "work_footwear":      "true for work footwear",
    "welt":               "true for welt construction footwear",
    "zori":               "true for zoris, one piece molded rubber or plastic thong sandals",
    "upper_esa_rubber_plastics_over_90": "true when over 90 percent of the upper external surface area including accessories is rubber or plastics",
    "foxing_band":        "true when the footwear has a foxing or foxing like band applied or molded at the sole and overlapping the upper",
    "open_toe_or_heel":   "true when the footwear has an open toe or open heel",
    "slip_on":            "true when the footwear is of the slip on type without laces, buckles or fasteners",
    "sole_attach_stitch": "true when the sole is affixed to the upper mainly by stitching",
    "vulcanized_construction": "true for footwear made by vulcanization or similar one piece processes",
    "textile_sole_contact":"true when textile material has the greatest surface area in contact with the ground",
    "leather_strap_instep_big_toe": "true when the upper consists of leather straps across the instep and around the big toe",
    "wood_platform": "true when the footwear is made on a base or platform of wood",
    "inner_sole": "true when the footwear has an inner sole",
    "rp_weight_under_10": "true when the footwear is less than 10 percent by weight of rubber and plastics",
    "turned_construction": "true for turn or turned footwear, sewn wrong side out to a leather sole then turned",
    "golf_shoes": "true for golf shoes",
}

# ---------------------------------------------------------------------
# Condition matchers. Each returns True, False, or a needed fact key.
# UNPARSED marks text no rule recognizes.
# ---------------------------------------------------------------------
UNPARSED = "UNPARSED"

def need(facts, key):
    return facts[key] if key in facts else key

COMPOUND_MARKERS = ("which consist", "straps", "provided", "except as", "in which")

def match_condition(desc, facts):
    ov = facts.get("_overrides", {})
    if desc in ov:
        return bool(ov[desc])
    d = desc.lower().rstrip(":").strip()

    # residual buckets always match once earlier siblings failed
    if d in ("other", "other footwear", "other:"):
        return True

    # leather strap sandal type of 6403.20
    if "leather straps across the instep and around the big toe" in d:
        t = need(facts, "leather_strap_instep_big_toe")
        return t if t == "leather_strap_instep_big_toe" else bool(facts["leather_strap_instep_big_toe"])

    # sole grouping rows under 6403 and 6404
    if d.startswith("footwear with outer soles of rubber or plastics"):
        s = need(facts, "sole_material")
        return s if s == "sole_material" else facts["sole_material"] == "rubber_plastics"
    if d.startswith("footwear with outer soles of leather or composition leather"):
        s = need(facts, "sole_material")
        return s if s == "sole_material" else facts["sole_material"] in ("leather","composition_leather")

    # open toe or heel and slip on lines, honoring the except clauses
    if d.startswith("footwear with open toes or open heels"):
        if "foxing" in d:
            f = need(facts, "foxing_band")
            if f == "foxing_band": return f
            if facts["foxing_band"]: return False
        if "6404.19.20" in d:
            p = need(facts, "protective")
            if p == "protective": return p
            if facts["protective"]: return False
        o = need(facts, "open_toe_or_heel")
        if o == "open_toe_or_heel": return o
        if facts["open_toe_or_heel"]: return True
        if "slip-on" in d or "slip on" in d:
            sl = need(facts, "slip_on")
            return sl if sl == "slip_on" else bool(facts["slip_on"])
        return False

    # weight of rubber or plastics split under 6404.19
    if "less than 10 percent by weight of rubber or plastics" in d:
        w = need(facts, "rp_weight_under_10")
        return w if w == "rp_weight_under_10" else bool(facts["rp_weight_under_10"])
    if "10 percent or more by weight of rubber or plastics" in d:
        w = need(facts, "rp_weight_under_10")
        return w if w == "rp_weight_under_10" else not facts["rp_weight_under_10"]

    # turned construction and golf shoes
    if d.startswith("turn or turned footwear"):
        t = need(facts, "turned_construction")
        return t if t == "turned_construction" else bool(facts["turned_construction"])
    if d == "golf shoes":
        g = need(facts, "golf_shoes")
        return g if g == "golf_shoes" else bool(facts["golf_shoes"])

    # compound conditions no simple rule should decide
    if any(m in d for m in COMPOUND_MARKERS):
        return UNPARSED

    # value bands
    m = re.search(r"valued not over \$?([\d.]+)", d)
    if m:
        v = need(facts, "value_per_pair")
        if v == "value_per_pair": return v
        return float(facts["value_per_pair"]) <= float(m.group(1))
    m = re.search(r"valued over \$?([\d.]+)(?:/pair)? but not over \$?([\d.]+)", d)
    if m:
        v = need(facts, "value_per_pair")
        if v == "value_per_pair": return v
        return float(m.group(1)) < float(facts["value_per_pair"]) <= float(m.group(2))
    m = re.search(r"valued over \$?([\d.]+)", d)
    if m:
        v = need(facts, "value_per_pair")
        if v == "value_per_pair": return v
        return float(facts["value_per_pair"]) > float(m.group(1))

    # gender and age lines
    g = need(facts, "gender_age")
    gmap = {
        "for men": "men", "men's": "men",
        "for women": "women", "women's": "women",
        "for youths and boys": "youths_boys",
        "for misses": "misses", "for children": "children", "for infants": "infants",
        "for men, youths and boys": ("men","youths_boys"),
        "for other persons": None,
        "for children and infants": ("children","infants"),
        "for misses, children and infants": ("misses","children","infants"),
    }
    for text, val in gmap.items():
        if d == text or d.startswith(text + " "):
            if g == "gender_age": return g
            if val is None:
                return facts["gender_age"] not in ("men","youths_boys")
            if isinstance(val, tuple):
                return facts["gender_age"] in val
            return facts["gender_age"] == val

    # ankle and knee
    if "covering the ankle but not covering the knee" in d:
        a = need(facts, "covers_ankle")
        if a == "covers_ankle": return a
        if not facts["covers_ankle"]: return False
        k = need(facts, "covers_knee")
        return k if k == "covers_knee" else not facts["covers_knee"]
    if "not covering the knee" not in d and "covering the knee" in d:
        k = need(facts, "covers_knee")
        return k if k == "covers_knee" else bool(facts["covers_knee"])
    if "not covering the ankle" in d:
        a = need(facts, "covers_ankle")
        return a if a == "covers_ankle" else not facts["covers_ankle"]
    if "covering the ankle" in d:
        a = need(facts, "covers_ankle")
        if a == "covers_ankle": return a
        if not facts["covers_ankle"]: return False
        if "but not covering the knee" in d:
            k = need(facts, "covers_knee")
            return k if k == "covers_knee" else not facts["covers_knee"]
        return True

    # sports and athletic
    if d.startswith("sports footwear"):
        s = need(facts, "sports_spikes")
        if s == "sports_spikes": return s
        if facts["sports_spikes"]: return True
        if "tennis shoes, basketball shoes, gym shoes" in d:
            a = need(facts, "athletic_like")
            return a if a == "athletic_like" else bool(facts["athletic_like"])
        return False
    if "ski-boots" in d or "ski boots" in d or "snowboard" in d:
        s = need(facts, "ski_boot")
        return s if s == "ski_boot" else bool(facts["ski_boot"])
    if "tennis shoes, basketball shoes, gym shoes" in d:
        a = need(facts, "athletic_like")
        return a if a == "athletic_like" else bool(facts["athletic_like"])

    # wood platform line of 6403.59.10
    if "base or platform of wood" in d:
        w = need(facts, "wood_platform")
        if w == "wood_platform": return w
        if not facts["wood_platform"]: return False
        t = need(facts, "metal_toe_cap")
        if t == "metal_toe_cap": return t
        if facts["metal_toe_cap"]: return False
        i = need(facts, "inner_sole")
        return i if i == "inner_sole" else not facts["inner_sole"]

    # toe cap and protection, only when the line is about the toe cap itself
    if ("protective metal toe-cap" in d or "protective metal toe cap" in d) and d.startswith(("incorporating", "other footwear, incorporating", "footwear incorporating", "not incorporating")):
        t = need(facts, "metal_toe_cap")
        if t == "metal_toe_cap": return t
        if "not " in d.split("incorporating")[0]:
            return not facts["metal_toe_cap"]
        return bool(facts["metal_toe_cap"])
    if "protection against water, oil, grease or chemicals or cold or inclement weather" in d:
        p = need(facts, "protective")
        if p == "protective": return p
        if d.startswith("footwear designed to be worn over"):
            return bool(facts["protective"])
        return bool(facts["protective"])
    if d.startswith("other footwear, not designed to be") or "not designed to be worn over" in d:
        p = need(facts, "protective")
        return p if p == "protective" else not facts["protective"]

    # upper leather share
    if "over 50 percent of the external surface area" in d and "leather" in d:
        l = need(facts, "leather_esa_over_50")
        return l if l == "leather_esa_over_50" else bool(facts["leather_esa_over_50"])

    # rubber plastics share over 90
    if "over 90 percent of the external surface area" in d:
        r = need(facts, "upper_esa_rubber_plastics_over_90")
        if r == "upper_esa_rubber_plastics_over_90": return r
        val = bool(facts["upper_esa_rubber_plastics_over_90"])
        if "foxing" in d:
            f = need(facts, "foxing_band")
            if f == "foxing_band": return f
            return val and not facts["foxing_band"]
        return val

    # upper material lines
    if "uppers of vegetable fibers" in d or "of vegetable fibers" in d:
        u = need(facts, "upper_textile_kind")
        return u if u == "upper_textile_kind" else facts["upper_textile_kind"] == "vegetable_fibers"
    if "soles and uppers of wool felt" in d:
        u = need(facts, "upper_textile_kind")
        return u if u == "upper_textile_kind" else facts["upper_textile_kind"] == "wool_felt"
    if "uppers of leather or composition leather" in d:
        u = need(facts, "upper_material")
        return u if u == "upper_material" else facts["upper_material"] in ("leather","composition_leather")
    if "uppers of textile materials" in d or "uppers of textile material" in d:
        u = need(facts, "upper_material")
        return u if u == "upper_material" else facts["upper_material"] == "textile"
    if d.startswith("of leather"):
        u = need(facts, "upper_material")
        return u if u == "upper_material" else facts["upper_material"] == "leather"
    if d.startswith("of textile materials"):
        u = need(facts, "upper_material")
        return u if u == "upper_material" else facts["upper_material"] == "textile"

    # sole lines
    if "outer soles of leather" in d:
        s = need(facts, "sole_material")
        return s if s == "sole_material" else facts["sole_material"] == "leather"
    if "outer soles of rubber, plastics, leather or composition leather" in d:
        return True
    if "outer soles and uppers of rubber or plastics" in d:
        s = need(facts, "sole_material"); u = need(facts, "upper_material")
        if s == "sole_material": return s
        if u == "upper_material": return u
        return facts["sole_material"] == "rubber_plastics" and facts["upper_material"] == "rubber_plastics"

    # construction and type lines
    if "welt footwear" in d:
        w = need(facts, "welt")
        return w if w == "welt" else bool(facts["welt"])
    if "house slippers" in d:
        h = need(facts, "house_slipper")
        return h if h == "house_slipper" else bool(facts["house_slipper"])
    if "work footwear" in d:
        w = need(facts, "work_footwear")
        return w if w == "work_footwear" else bool(facts["work_footwear"])
    if "zoris" in d:
        z = need(facts, "zori")
        return z if z == "zori" else bool(facts["zori"])

    return UNPARSED

# ---------------------------------------------------------------------
# The walk.
# ---------------------------------------------------------------------
def walk(facts, start=None):
    """Walk to a leaf. Returns a dict with status, code or gap, and the path."""
    path = []

    def effective_rate(node):
        cur = node
        while cur is not None:
            if cur["general"].strip():
                return cur["general"].strip()
            cur = BYID[cur["parent"]] if cur["parent"] is not None else None
        return ""

    def descend(node):
        if not node["children"]:
            return {"status": "code", "code": node["htsno"], "general": effective_rate(node), "path": path}
        kids = [BYID[c] for c in node["children"]]
        for kid in kids:
            r = match_condition(kid["desc"], facts)
            if r is True:
                path.append({"htsno": kid["htsno"], "desc": kid["desc"]})
                return descend(kid)
            if r is False:
                continue
            if r == UNPARSED:
                return {"status": "review", "reason": "condition needs judgment",
                        "at": kid["desc"], "path": path}
            return {"status": "need_fact", "fact": r, "question_about": FACT_KEYS[r],
                    "at": kid["desc"], "path": path}
        return {"status": "review", "reason": "no child matched", "at": node["desc"], "path": path}

    if start is None:
        # heading selection from the top
        for root in ROOTS:
            r = heading_match(root, facts)
            if r is True:
                path.append({"htsno": root["htsno"], "desc": root["desc"]})
                return descend(root)
            if r is False:
                continue
            if isinstance(r, str):
                return {"status": "need_fact", "fact": r, "question_about": FACT_KEYS[r],
                        "at": root["desc"], "path": path}
        return {"status": "review", "reason": "no heading matched", "path": path}
    return descend(start)

def heading_match(root, facts):
    h = root["htsno"]
    s = facts.get("sole_material"); u = facts.get("upper_material")
    if h == "6401":
        if s is not None and s != "rubber_plastics": return False
        if u is not None and u != "rubber_plastics": return False
        for k in ("sole_material","upper_material","waterproof_molded"):
            if k not in facts: return k
        return bool(facts["waterproof_molded"])
    if h == "6402":
        if s is not None and s != "rubber_plastics": return False
        if u is not None and u != "rubber_plastics": return False
        for k in ("sole_material","upper_material"):
            if k not in facts: return k
        if "waterproof_molded" not in facts: return "waterproof_molded"
        return not facts["waterproof_molded"]
    if h == "6403":
        for k in ("sole_material","upper_material"):
            if k not in facts: return k
        return (s in ("rubber_plastics","leather","composition_leather")
                and u in ("leather",))
    if h == "6404":
        for k in ("sole_material","upper_material"):
            if k not in facts: return k
        return (s in ("rubber_plastics","leather","composition_leather")
                and u == "textile")
    if h == "6405":
        return True
    return False

def rationale(result, facts):
    lines = []
    for i, step in enumerate(result.get("path", []), 1):
        num = step["htsno"] or "grouping"
        lines.append(f"{i}. {num}  {step['desc']}")
    return lines

if __name__ == "__main__":
    print("engine loaded", len(NODES), "nodes")