Upload folder using huggingface_hub

app.py

@@ -28,6 +28,7 @@ OPENAI_REASONING = {"effort": "high"}
 
 MATCH_OK = 80
 EMBED_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+
 PARSEC_CONTEXT_BEFORE = 900
 PARSEC_CONTEXT_AFTER = 1600
 
@@ -130,7 +131,7 @@ for c in df_eos.columns:
         device_type_col = c
         break
 
-# Maker mapping (expanded — adds Teltonika)
+# Maker mapping (includes Teltonika)
 CANON_MAKER = {
     "CRADLEPOINT": {"cradlepoint", "ericsson", "ericsson enterprise wireless"},
     "SIERRA": {"sierra", "sierra wireless", "semtech", "airlink"},
@@ -140,16 +141,6 @@ CANON_MAKER = {
     "CISCO": {"cisco"},
     "TELTONIKA": {"teltonika"},
 }
-DISPLAY_MAKER = {
-    "CRADLEPOINT": "Cradlepoint",
-    "SIERRA": "Sierra Wireless",
-    "FEENEY": "Feeney Wireless",
-    "DIGI": "Digi",
-    "CISCO_MERAKI": "Cisco Meraki",
-    "CISCO": "Cisco",
-    "TELTONIKA": "Teltonika",
-    "UNKNOWN": "Unknown",
-}
 
 def canon_maker_from_text(s: Any) -> str:
     t = norm_text(s)
@@ -331,8 +322,7 @@ def resolve_device(user_text: str) -> Dict[str, Any]:
 
 
 # ============================
-# Replacements — lifecycle CSV is source of truth
-# Fix: always show 4G alternative if lifecycle suggests it (even if Active)
+# Replacements — lifecycle CSV source of truth
 # ============================
 def _extract_model_token(text: str) -> str:
     s = _safe_str(text)
@@ -342,19 +332,15 @@ def _extract_model_token(text: str) -> str:
     candidates = parts[::-1] if parts else [s]
 
     for cand in candidates:
-        # Teltonika family
         m = re.search(r"\bRUT[A-Z]?\d{2,4}\b", cand.upper())
         if m:
             return m.group(0).upper()
-        # Digi IX-series
         m = re.search(r"\bIX\d{2}\b", cand, flags=re.IGNORECASE)
         if m:
             return m.group(0).upper()
-        # Cradlepoint R/E/S
         m = re.search(r"\b(R\d{3,4}|E\d{3,4}|S\d{3,4})\b", cand, flags=re.IGNORECASE)
         if m:
             return m.group(0).upper()
-        # Generic model token
         m = re.search(r"\b[A-Z]{1,6}\d{2,4}[A-Z]?\b", cand.upper())
         if m:
             return m.group(0).upper()
@@ -366,7 +352,6 @@ def _device_is_4g(life_row: pd.Series) -> bool:
     return (("lte" in t or "4g" in t) and ("5g" not in t and "nr" not in t))
 
 def _candidate_5g_models_from_lifecycle(manufacturer: str) -> List[str]:
-    # Pool within same manufacturer text (not just canon) to support Teltonika etc
     mfr = norm_text(manufacturer)
     pool = df_eos[df_eos["manufacturer"].astype(str).str.lower().eq(mfr)].copy() if "manufacturer" in df_eos.columns else df_eos.copy()
     vals = pool["advanced_5g_option"].tolist() if "advanced_5g_option" in pool.columns else []
@@ -410,33 +395,29 @@ def _fallback_5g_from_dec(canon_make: str) -> str:
     pool5 = df_dec[(df_dec["_canon_make"] == canon_make) & (df_dec["_is5g"] == True)]
     return str(pool5.iloc[0]["Model"]).strip() if not pool5.empty else ""
 
-def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, Any]:
+def pick_replacements_lifecycle(life_row: pd.Series, status: str, use_gpt: bool = True) -> Dict[str, Any]:
     canon = str(life_row.get("_canon_make","UNKNOWN"))
     manufacturer = str(life_row.get("manufacturer","") or "")
 
     is_4g_device = _device_is_4g(life_row)
-    needs_4g_repl = is_4g_device and (status in {"End of Sale","End of Life"})
     want_5g = is_4g_device or (status in {"End of Sale","End of Life"})
 
-    # 4G alternative: ALWAYS if suggested_replacement exists for 4G devices
     repl_4g = "Not applicable"
     if is_4g_device:
         repl_4g = _extract_model_token(_safe_str(life_row.get("suggested_replacement","")))
         if not repl_4g:
             cand4 = _candidate_4g_models_from_lifecycle(manufacturer)
-            repl_4g = _gpt_pick_from_candidates(life_row, cand4, "4G alternative") or (cand4[0] if cand4 else "")
+            repl_4g = (_gpt_pick_from_candidates(life_row, cand4, "4G alternative") if (use_gpt and client) else "") or (cand4[0] if cand4 else "")
         if not repl_4g:
             repl_4g = "Not applicable"
 
-    # 5G replacement: ALWAYS when want_5g is true
     repl_5g = "Not applicable"
     if want_5g:
         repl_5g = _extract_model_token(_safe_str(life_row.get("advanced_5g_option","")))
         if not repl_5g:
             cand5 = _candidate_5g_models_from_lifecycle(manufacturer)
-            repl_5g = _gpt_pick_from_candidates(life_row, cand5, "5G replacement/upgrade") or (cand5[0] if cand5 else "")
+            repl_5g = (_gpt_pick_from_candidates(life_row, cand5, "5G replacement/upgrade") if (use_gpt and client) else "") or (cand5[0] if cand5 else "")
         if not repl_5g:
-            # last resort: dec catalog fallback
             repl_5g = _fallback_5g_from_dec(canon)
 
     if repl_5g.lower() == "nan":
@@ -444,14 +425,14 @@ def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, A
 
     return {
         "repl_4g": repl_4g,
-        "repl_5g": repl_5g,
+        "repl_5g": repl_5g if repl_5g else "Not listed",
         "why": "Lifecycle replacements (GPT fallback when missing).",
-        "sources": ["lifecycle_csv"] + (["gpt"] if client else []) + (["dec_fallback"] if (want_5g and not repl_5g) else []),
+        "sources": ["lifecycle_csv"] + (["gpt"] if (use_gpt and client) else []) + (["dec_fallback"] if (want_5g and (repl_5g == "Not listed" or repl_5g == "")) else []),
     }
 
 
 # ============================
-# Antennas (Parsec-only; family name extraction)
+# Antennas (Parsec-only; family + connectors hint)
 # ============================
 PARSEC_FAMILY_WORDS = {
     "chinook","labrador","boxer","bloodhound","husky","beagle","mastiff","collie",
@@ -484,6 +465,13 @@ def _family_from_line(line: str) -> str:
             return fam.capitalize()
     return ""
 
+def _parsec_connectors_from_card(t: str) -> str:
+    m = re.search(r"Standard\s+Connectors:\s*(.+)", t, flags=re.IGNORECASE)
+    if m:
+        val = re.sub(r"\s+", " ", m.group(1).strip())
+        return val[:80]
+    return ""
+
 def _parsec_name_from_card(card_text: str) -> str:
     lines = [_clean_line(ln) for ln in str(card_text or "").splitlines()]
     lines = [ln for ln in lines if ln]
@@ -495,7 +483,6 @@ def _parsec_name_from_card(card_text: str) -> str:
         if fam:
             return fam
 
-    # fallback near SKU line
     sku_i = None
     for i, ln in enumerate(lines):
         if "standard sku" in ln.lower():
@@ -532,25 +519,40 @@ def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:
                 "name": _parsec_name_from_card(card),
                 "part_number": _parsec_part_from_card(card),
                 "description": _parsec_desc_from_card(card),
+                "connectors": _parsec_connectors_from_card(card),
             })
     return out
 
+def infer_mimo_for_replacement(model: str, canon_make: str) -> str:
+    if not model or model in {"Not applicable","Not listed"}:
+        return "2x2"
+    pool = df_dec[df_dec["_canon_make"] == canon_make].copy()
+    if pool.empty:
+        return "4x4" if ("5g" in model.lower()) else "2x2"
+    hit = process.extractOne(norm_text(model), pool["_norm_model"].tolist(), scorer=fuzz.WRatio)
+    if hit and hit[1] >= MATCH_OK:
+        row = pool.iloc[int(hit[2])]
+        txt = (str(row.get("Antennas (internal/external/both)","")) + " " + str(row.get("Modem Type",""))).lower()
+        if "4x4" in txt or "4 x 4" in txt:
+            return "4x4"
+    return "4x4" if ("5g" in model.lower()) else "2x2"
+
 def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, Any]:
     q_stationary = f"{router_model} {tech} {mimo} omni stationary outdoor Parsec"
     q_vehicle = f"{router_model} {tech} {mimo} omni vehicle mobile Parsec"
+
     cand_stationary = parsec_retrieve(q_stationary, top_k=10)
     cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)
 
-    # deterministic fallback if no GPT
-    s = cand_stationary[0] if cand_stationary else {"name":"Parsec antenna","part_number":"","description":""}
-    v = cand_vehicle[0] if cand_vehicle else {"name":"Parsec antenna","part_number":"","description":""}
+    s = cand_stationary[0] if cand_stationary else {"name":"Parsec antenna","part_number":"","description":"","connectors":""}
+    v = cand_vehicle[0] if cand_vehicle else {"name":"Parsec antenna","part_number":"","description":"","connectors":""}
     s.update({"mimo": mimo, "why": "Stationary omni best match."})
     v.update({"mimo": mimo, "why": "Vehicle omni best match."})
     return {"stationary_omni": s, "vehicle_omni": v, "sources":["parsec_rag"]}
 
 
 # ============================
-# Feature table + GPT fill for missing fields
+# Feature table + GPT fill for missing fields (not lazy: fill missing)
 # ============================
 FEATURE_COLS = ["Name","Modem technology","WiFi","Ports","Antennas","Ruggedness","Use case"]
 
@@ -628,7 +630,7 @@ def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str
 
 
 # ============================
-# Output + Gradio
+# Output + install-ready checklist (Feature #9)
 # ============================
 def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:
     canon_make = str(life_row.get("_canon_make","UNKNOWN"))
@@ -640,8 +642,6 @@ def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl:
     cur_feats = current_features_guess(life_row)
     r4_feats = dec_features_by_model(repl.get("repl_4g",""), canon_make)
     r5_feats = dec_features_by_model(repl.get("repl_5g",""), canon_make)
-
-    # If dec doesn't know the model, ask GPT to fill missing cells (best guess)
     if client is not None:
         r4_feats = gpt_fill_features("4G alternative", r4_feats, f"Model: {repl.get('repl_4g','')}\nMake: {canon_make}")
         r5_feats = gpt_fill_features("5G replacement", r5_feats, f"Model: {repl.get('repl_5g','')}\nMake: {canon_make}")
@@ -656,10 +656,13 @@ def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl:
     lines.append(f"5. 4G alternative (lifecycle): **{repl.get('repl_4g','Not applicable')}**")
     lines.append(f"6. 5G replacement (lifecycle): **{repl.get('repl_5g','Not listed')}**")
     lines.append("7. Antenna options (Parsec-only):")
-    lines.append(f"   - Stationary (Omni): **{st.get('name','')}** (Part #: {st.get('part_number','')}) — {st.get('description','')} — MIMO: {st.get('mimo','')} — {st.get('why','')}")
-    lines.append(f"   - Vehicle (Omni): **{vh.get('name','')}** (Part #: {vh.get('part_number','')}) — {vh.get('description','')} — MIMO: {vh.get('mimo','')} — {vh.get('why','')}")
+    conn_s = f" | Conn: {st.get('connectors','')}" if st.get("connectors") else ""
+    conn_v = f" | Conn: {vh.get('connectors','')}" if vh.get("connectors") else ""
+    lines.append(f"   - Stationary (Omni): **{st.get('name','')}** (Part #: {st.get('part_number','')}) — {st.get('description','')} — MIMO: {st.get('mimo','')}{conn_s} — {st.get('why','')}")
+    lines.append(f"   - Vehicle (Omni): **{vh.get('name','')}** (Part #: {vh.get('part_number','')}) — {vh.get('description','')} — MIMO: {vh.get('mimo','')}{conn_v} — {vh.get('why','')}")
     lines.append("8. Recommended features table:")
     lines.append(table_md)
+
     lines.append("\nSources (debug):")
     for s in repl.get("sources", []) if isinstance(repl.get("sources"), list) else []:
         lines.append(f"- {s}")
@@ -668,37 +671,177 @@ def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl:
     lines.append("- dec2025routers.csv (features)")
     return "\n".join(lines)
 
+def install_ready_checklist(life_row: pd.Series, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:
+    current_sku = str(life_row.get("sku","") or "").strip()
+    repl4 = str(repl.get("repl_4g","") or "")
+    repl5 = str(repl.get("repl_5g","") or "")
+    st = ant.get("stationary_omni", {})
+    vh = ant.get("vehicle_omni", {})
+
+    if client is not None:
+        sys = "Create a short, install-ready checklist for a Verizon rep. Keep it scannable. Return markdown only."
+        payload = {
+            "current_device": current_sku,
+            "replacements": {"4g_alternative": repl4, "5g_replacement": repl5},
+            "antennas": {"stationary": st, "vehicle": vh},
+            "rules": [
+                "Include: router(s), antennas, connector/cable notes, mounting notes, power notes, and 'next steps'.",
+                "Keep it concise and practical."
+            ]
+        }
+        resp = client.responses.create(
+            model=OPENAI_MODEL,
+            reasoning=OPENAI_REASONING,
+            input=[{"role":"system","content":sys},{"role":"user","content":json.dumps(payload)}],
+            max_output_tokens=550,
+        )
+        return (getattr(resp, "output_text", "") or "").strip()
+
+    lines = []
+    lines.append("### Install-ready checklist")
+    lines.append(f"- Current device: {current_sku}")
+    lines.append(f"- 5G replacement: {repl5}")
+    lines.append(f"- 4G alternative: {repl4 if repl4 else 'Not applicable'}")
+    lines.append(f"- Stationary omni antenna: {st.get('name','')} (PN {st.get('part_number','')})")
+    lines.append(f"- Vehicle omni antenna: {vh.get('name','')} (PN {vh.get('part_number','')})")
+    if st.get("connectors"):
+        lines.append(f"- Stationary connectors: {st.get('connectors')}")
+    if vh.get("connectors"):
+        lines.append(f"- Vehicle connectors: {vh.get('connectors')}")
+    lines.append("- Next steps: confirm mounting + cable lengths + power method; place order; schedule install.")
+    return "\n".join(lines)
+
+
+# ============================
+# Batch mode (Feature #4)
+# ============================
+def parse_batch_inputs(text_blob: str, file_obj: Optional[Any]) -> List[str]:
+    items = []
+    if file_obj is not None:
+        try:
+            path = file_obj.name if hasattr(file_obj, "name") else str(file_obj)
+            df = pd.read_csv(path)
+            col = df.columns[0]
+            items.extend([str(x).strip() for x in df[col].tolist() if str(x).strip()])
+        except Exception:
+            pass
+    if text_blob:
+        for ln in str(text_blob).splitlines():
+            ln = ln.strip()
+            if ln:
+                items.append(ln)
+    seen=set()
+    out=[]
+    for x in items:
+        k=norm_text(x)
+        if k and k not in seen:
+            seen.add(k); out.append(x)
+    return out
+
+def run_batch(text_blob: str, file_obj: Optional[Any], include_antennas: bool):
+    inputs = parse_batch_inputs(text_blob, file_obj)
+    if not inputs:
+        return "", pd.DataFrame(), None, ""
+
+    rows=[]
+    for item in inputs:
+        res = resolve_device(item)
+        if res.get("mode") != "ok":
+            rows.append({
+                "Input": item,
+                "Matched": "",
+                "Status": "Needs review",
+                "EOS": "",
+                "EOL": "",
+                "4G alternative": "",
+                "5G replacement": "",
+                "Stationary antenna": "",
+                "Vehicle antenna": "",
+                "Notes": "Not found / ambiguous"
+            })
+            continue
+
+        life_row = df_eos.iloc[int(res["row_idx"])]
+        eos, eol, status = row_to_dates_and_status(life_row)
+        repl = pick_replacements_lifecycle(life_row, status, use_gpt=False)  # fast: no GPT in batch
+
+        if include_antennas:
+            canon_make = str(life_row.get("_canon_make","UNKNOWN"))
+            mimo = infer_mimo_for_replacement(repl.get("repl_5g",""), canon_make)
+            tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") not in {"Not applicable","Not listed"} else ("4G" if _device_is_4g(life_row) else "Unknown")
+            ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo)
+            stA = ant.get("stationary_omni", {})
+            vhA = ant.get("vehicle_omni", {})
+            ant_s = f"{stA.get('name','')} {stA.get('part_number','')}"
+            ant_v = f"{vhA.get('name','')} {vhA.get('part_number','')}"
+        else:
+            ant_s = ""
+            ant_v = ""
+
+        rows.append({
+            "Input": item,
+            "Matched": str(life_row.get("sku","")),
+            "Status": status,
+            "EOS": eos,
+            "EOL": eol,
+            "4G alternative": repl.get("repl_4g",""),
+            "5G replacement": repl.get("repl_5g",""),
+            "Stationary antenna": ant_s,
+            "Vehicle antenna": ant_v,
+            "Notes": "",
+        })
+
+    out_df = pd.DataFrame(rows)
+
+    # Summary counts + rollup
+    counts = out_df["Status"].value_counts(dropna=False).to_dict()
+    top_5g = out_df["5G replacement"].value_counts(dropna=False).head(5).to_dict()
+    summary = f"Rows: {len(out_df)} | " + " | ".join([f"{k}: {v}" for k,v in counts.items()])
+    rollup = "Top 5G recommendations:\n" + "\n".join([f"- {k}: {v}" for k,v in top_5g.items() if str(k).strip()])
+
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv")
+    out_df.to_csv(tmp.name, index=False)
+
+    return summary, out_df, tmp.name, rollup
+
+
+# ============================
+# Gradio app (Single + Batch + Install-ready)
+# ============================
 def run_lookup(user_text: str, st: Dict[str,Any]):
     user_text = str(user_text or "").strip()
     if not user_text:
-        return "Enter a router SKU/model.", gr.update(visible=False), gr.update(visible=False), {}
+        return "Enter a router SKU/model.", gr.update(visible=False), gr.update(visible=False), {}, gr.update(value="")
 
     res = resolve_device(user_text)
     if res.get("mode") == "pick":
         opts = res.get("options", [])
         choices = [o["label"] for o in opts]
         st2 = {"mode":"pick","options": opts}
-        return "Did you mean A or B? Pick one, then click Use selection.", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2
+        return "Did you mean A or B? Pick one, then click Use selection.", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2, gr.update(value="")
 
     if res.get("mode") != "ok":
-        return "Not found.", gr.update(visible=False), gr.update(visible=False), {}
+        return "Not found.", gr.update(visible=False), gr.update(visible=False), {}, gr.update(value="")
 
     life_row = df_eos.iloc[int(res["row_idx"])]
     eos, eol, status = row_to_dates_and_status(life_row)
 
-    repl = pick_replacements_lifecycle(life_row, status)
+    repl = pick_replacements_lifecycle(life_row, status, use_gpt=True)
 
+    canon_make = str(life_row.get("_canon_make","UNKNOWN"))
+    mimo = infer_mimo_for_replacement(repl.get("repl_5g",""), canon_make)
     tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") not in {"Not applicable","Not listed"} else ("4G" if _device_is_4g(life_row) else "Unknown")
-    mimo_guess = "4x4" if tech == "5G" else "2x2"
-    ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo_guess)
+    ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo)
 
-    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}
+    output = assemble_output(life_row, status, eos, eol, repl, ant)
+    st_out = {"row_idx": int(res["row_idx"]), "repl": repl, "ant": ant}
+    return output, gr.update(visible=False), gr.update(visible=False), st_out, gr.update(value="")
 
 def use_selection(selected_label: str, st: Dict[str,Any]):
     if not st or st.get("mode") != "pick":
-        return "Run a search first.", gr.update(visible=False), gr.update(visible=False), {}
+        return "Run a search first.", gr.update(visible=False), gr.update(visible=False), {}, gr.update(value="")
     if not selected_label:
-        return "Pick A or B first.", gr.update(visible=True), gr.update(visible=True), st
+        return "Pick A or B first.", gr.update(visible=True), gr.update(visible=True), st, gr.update(value="")
 
     chosen_row = None
     for o in st.get("options", []):
@@ -706,29 +849,62 @@ def use_selection(selected_label: str, st: Dict[str,Any]):
             chosen_row = int(o["row_idx"])
             break
     if chosen_row is None:
-        return "Pick a valid option.", gr.update(visible=True), gr.update(visible=True), st
+        return "Pick a valid option.", gr.update(visible=True), gr.update(visible=True), st, gr.update(value="")
 
     life_row = df_eos.iloc[int(chosen_row)]
     eos, eol, status = row_to_dates_and_status(life_row)
-    repl = pick_replacements_lifecycle(life_row, status)
+    repl = pick_replacements_lifecycle(life_row, status, use_gpt=True)
+
+    canon_make = str(life_row.get("_canon_make","UNKNOWN"))
+    mimo = infer_mimo_for_replacement(repl.get("repl_5g",""), canon_make)
     tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") not in {"Not applicable","Not listed"} else ("4G" if _device_is_4g(life_row) else "Unknown")
-    mimo_guess = "4x4" if tech == "5G" else "2x2"
-    ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo_guess)
+    ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo)
+
+    output = assemble_output(life_row, status, eos, eol, repl, ant)
+    st_out = {"row_idx": int(chosen_row), "repl": repl, "ant": ant}
+    return output, gr.update(visible=False), gr.update(visible=False), st_out, gr.update(value="")
 
-    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}
+def make_install_ready(st_state: Dict[str,Any]):
+    if not st_state or "row_idx" not in st_state:
+        return "Run a lookup first."
+    life_row = df_eos.iloc[int(st_state["row_idx"])]
+    repl = st_state.get("repl", {}) or {}
+    ant = st_state.get("ant", {}) or {}
+    return install_ready_checklist(life_row, repl, ant)
 
 with gr.Blocks(title="Only-Routers") as demo:
-    gr.Markdown("## Only-Routers\nEnter a router SKU/model. If ambiguous, you’ll get A/B choices.")
-    user_text = gr.Textbox(label="Router SKU or model", placeholder="Examples: IBR650B, AER1600, ES450, WR21, RUT240", lines=1)
-    st = gr.State({})
+    gr.Markdown("## Only-Routers\nSingle lookup + Batch upload for Verizon reps.")
+
+    with gr.Tabs():
+        with gr.Tab("Single"):
+            user_text = gr.Textbox(label="Router SKU or model", placeholder="Examples: IBR650B, AER1600, ES450, WR21, RUT240", lines=1)
+            st = gr.State({})
+
+            check_btn = gr.Button("Check", variant="primary")
+            pick_dd = gr.Dropdown(label="Pick A or B", choices=[], visible=False)
+            use_btn = gr.Button("Use selection", visible=False)
+
+            output_md = gr.Markdown()
+
+            install_btn = gr.Button("Make install-ready checklist")
+            install_md = gr.Markdown()
+
+            check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st, install_md])
+            use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st, install_md])
+            install_btn.click(fn=make_install_ready, inputs=[st], outputs=[install_md])
 
-    check_btn = gr.Button("Check", variant="primary")
-    pick_dd = gr.Dropdown(label="Pick A or B", choices=[], visible=False)
-    use_btn = gr.Button("Use selection", visible=False)
+        with gr.Tab("Batch"):
+            gr.Markdown("Paste one per line or upload a CSV (first column). Batch runs fast (no GPT), and can optionally include antenna picks.")
+            batch_text = gr.Textbox(label="Paste devices (one per line)", lines=8, placeholder="WR21\nRUT240\nIBR650B")
+            batch_file = gr.File(label="Upload CSV", file_types=[".csv"])
+            include_ant = gr.Checkbox(label="Include antenna picks (slower)", value=False)
+            run_btn = gr.Button("Run batch", variant="primary")
 
-    output_md = gr.Markdown()
+            summary_md = gr.Markdown()
+            rollup_md = gr.Markdown()
+            table = gr.Dataframe(interactive=False, wrap=True)
+            dl = gr.File(label="Download results CSV")
 
-    check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st])
-    use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st])
+            run_btn.click(fn=run_batch, inputs=[batch_text, batch_file, include_ant], outputs=[summary_md, table, dl, rollup_md])
 
 demo.launch()

app_old.py

@@ -0,0 +1,734 @@
+import os
+import re
+import json
+import math
+import hashlib
+from dataclasses import dataclass
+from datetime import datetime, date
+from typing import Dict, List, Optional, Tuple, Any
+
+import numpy as np
+import pandas as pd
+
+import fitz  # PyMuPDF
+import faiss
+from sentence_transformers import SentenceTransformer
+from rapidfuzz import fuzz, process
+
+import gradio as gr
+from openai import OpenAI
+
+
+# ============================
+# Settings
+# ============================
+TODAY = date(2026, 1, 18)
+OPENAI_MODEL = "gpt-5.2"
+OPENAI_REASONING = {"effort": "high"}
+
+MATCH_OK = 80
+EMBED_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+PARSEC_CONTEXT_BEFORE = 900
+PARSEC_CONTEXT_AFTER = 1600
+
+CACHE_DIR = os.path.join(os.getcwd(), ".onlyrouters_cache")
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+
+# ============================
+# OpenAI client (HF Space secret: OPENAI_API_KEY)
+# ============================
+API_KEY = os.getenv("OPENAI_API_KEY", "").strip()
+client = OpenAI(api_key=API_KEY) if API_KEY else None
+
+
+# ============================
+# Utilities
+# ============================
+def norm_text(s: Any) -> str:
+    try:
+        if s is None or (isinstance(s, float) and math.isnan(s)) or pd.isna(s):
+            return ""
+    except Exception:
+        pass
+    s = str(s).strip().lower()
+    s = re.sub(r"[^a-z0-9\s\-\/]", " ", s)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+def _safe_str(v: Any) -> str:
+    if v is None or (isinstance(v, float) and pd.isna(v)) or pd.isna(v):
+        return ""
+    return str(v).strip()
+
+def _is_5g(modem_type: Any) -> bool:
+    s = norm_text(modem_type)
+    return ("5g" in s) or ("nr" in s)
+
+def _json_load_safe(s: str) -> Dict[str, Any]:
+    try:
+        return json.loads(s)
+    except Exception:
+        return {}
+
+def gpt_json(system: str, payload: Dict[str, Any], max_tokens: int = 700) -> Dict[str, Any]:
+    if client is None:
+        return {}
+    resp = client.responses.create(
+        model=OPENAI_MODEL,
+        reasoning=OPENAI_REASONING,
+        input=[
+            {"role": "system", "content": system},
+            {"role": "user", "content": json.dumps(payload)},
+        ],
+        max_output_tokens=max_tokens,
+    )
+    return _json_load_safe(getattr(resp, "output_text", "") or "")
+
+
+# ============================
+# Load data files (must exist in repo)
+# ============================
+EOS_PATH = "routers_eos_eol_by_sku.csv"
+DEC_PATH = "dec2025routers.csv"
+PARSEC_PDF = "ParsecCatalog.pdf"
+
+if not os.path.exists(EOS_PATH):
+    raise FileNotFoundError(f"Missing {EOS_PATH} in repo.")
+if not os.path.exists(DEC_PATH):
+    raise FileNotFoundError(f"Missing {DEC_PATH} in repo.")
+if not os.path.exists(PARSEC_PDF):
+    raise FileNotFoundError(f"Missing {PARSEC_PDF} in repo.")
+
+df_eos = pd.read_csv(EOS_PATH).copy()
+df_dec = pd.read_csv(DEC_PATH).copy()
+
+# Region filter: keep USA / North America / blank / not specified
+def _region_ok(x: Any) -> bool:
+    s = str(x or "").strip().lower()
+    if not s:
+        return True
+    if "not specified" in s:
+        return True
+    if "north america" in s:
+        return True
+    if re.search(r"\busa\b", s):
+        return True
+    if re.search(r"\bunited\s+states\b", s):
+        return True
+    if re.search(r"\bu\.?s\.?\b", s):
+        return True
+    return False
+
+if "region" in df_eos.columns:
+    df_eos = df_eos[df_eos["region"].apply(_region_ok)].reset_index(drop=True)
+
+# Optional "Device Type"
+device_type_col = None
+for c in df_eos.columns:
+    if norm_text(c) == "device type":
+        device_type_col = c
+        break
+
+# Maker mapping (expanded — adds Teltonika)
+CANON_MAKER = {
+    "CRADLEPOINT": {"cradlepoint", "ericsson", "ericsson enterprise wireless"},
+    "SIERRA": {"sierra", "sierra wireless", "semtech", "airlink"},
+    "FEENEY": {"feeney", "feeney wireless", "inseego"},
+    "DIGI": {"digi", "accelerated", "accelerated concepts"},
+    "CISCO_MERAKI": {"meraki", "cisco meraki"},
+    "CISCO": {"cisco"},
+    "TELTONIKA": {"teltonika"},
+}
+DISPLAY_MAKER = {
+    "CRADLEPOINT": "Cradlepoint",
+    "SIERRA": "Sierra Wireless",
+    "FEENEY": "Feeney Wireless",
+    "DIGI": "Digi",
+    "CISCO_MERAKI": "Cisco Meraki",
+    "CISCO": "Cisco",
+    "TELTONIKA": "Teltonika",
+    "UNKNOWN": "Unknown",
+}
+
+def canon_maker_from_text(s: Any) -> str:
+    t = norm_text(s)
+    for canon, terms in CANON_MAKER.items():
+        for term in terms:
+            if term in t:
+                return canon
+    return "UNKNOWN"
+
+df_eos["_canon_make"] = df_eos["manufacturer"].apply(canon_maker_from_text) if "manufacturer" in df_eos.columns else "UNKNOWN"
+df_eos["_norm_sku"] = df_eos["sku"].apply(norm_text) if "sku" in df_eos.columns else ""
+df_eos["_norm_desc"] = df_eos["description"].apply(norm_text) if "description" in df_eos.columns else ""
+df_eos["_norm_notes"] = df_eos["notes"].apply(norm_text) if "notes" in df_eos.columns else ""
+
+df_dec["_canon_make"] = df_dec["Make"].apply(canon_maker_from_text) if "Make" in df_dec.columns else "UNKNOWN"
+df_dec["_norm_model"] = df_dec["Model"].apply(norm_text) if "Model" in df_dec.columns else ""
+df_dec["_is5g"] = df_dec["Modem Type"].apply(_is_5g) if "Modem Type" in df_dec.columns else False
+
+
+# ============================
+# Date helpers
+# ============================
+@dataclass
+class ParsedDate:
+    raw: str
+    kind: str
+    value: Optional[date]
+
+def parse_date_field(x: Any) -> ParsedDate:
+    raw = str(x or "").strip()
+    if not raw:
+        return ParsedDate(raw="", kind="missing", value=None)
+
+    if re.fullmatch(r"\d{4}", raw):
+        y = int(raw)
+        if y == TODAY.year:
+            return ParsedDate(raw=raw, kind="year", value=date(y, 1, 1))
+        if y < TODAY.year:
+            return ParsedDate(raw=raw, kind="year", value=date(y, 1, 1))
+        return ParsedDate(raw=raw, kind="year", value=date(y, 12, 31))
+
+    if re.fullmatch(r"\d{4}-\d{2}", raw):
+        try:
+            y, m = raw.split("-")
+            return ParsedDate(raw=raw, kind="year_month", value=date(int(y), int(m), 1))
+        except Exception:
+            return ParsedDate(raw=raw, kind="bad", value=None)
+
+    if re.fullmatch(r"\d{4}-\d{2}-\d{2}", raw):
+        try:
+            dt = datetime.strptime(raw, "%Y-%m-%d").date()
+            return ParsedDate(raw=raw, kind="full", value=dt)
+        except Exception:
+            return ParsedDate(raw=raw, kind="bad", value=None)
+
+    return ParsedDate(raw=raw, kind="bad", value=None)
+
+def display_date(parsed: ParsedDate) -> str:
+    if parsed.kind == "missing":
+        return "Not listed"
+    if parsed.kind == "bad":
+        return parsed.raw or "Not listed"
+    return parsed.raw
+
+def status_from_eos_eol(eos: ParsedDate, eol: ParsedDate) -> str:
+    if eos.value is None and eol.value is None:
+        return "Unknown"
+    if eol.value is not None and eol.value <= TODAY:
+        return "End of Life"
+    if eos.value is not None and eos.value <= TODAY:
+        return "End of Sale"
+    return "Active"
+
+def row_to_dates_and_status(life_row: pd.Series) -> Tuple[str, str, str]:
+    eos = parse_date_field(life_row.get("end_of_sale"))
+    eol = parse_date_field(life_row.get("end_of_life"))
+    return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)
+
+
+# ============================
+# Embeddings + Parsec index
+# ============================
+embedder = SentenceTransformer(EMBED_MODEL_NAME)
+
+def extract_pdf_text_pages(path: str) -> List[str]:
+    doc = fitz.open(path)
+    return [doc[i].get_text("text") for i in range(len(doc))]
+
+def build_parsec_cards(pages: List[str]) -> List[str]:
+    cards = []
+    for p in pages:
+        for m in re.finditer(r"Standard\s+SKU:", p):
+            start = max(0, m.start() - PARSEC_CONTEXT_BEFORE)
+            end = min(len(p), m.start() + PARSEC_CONTEXT_AFTER)
+            c = p[start:end].strip()
+            if len(c) >= 200:
+                cards.append(c)
+    out, seen = [], set()
+    for c in cards:
+        h = hashlib.sha1(c.encode("utf-8")).hexdigest()
+        if h not in seen:
+            seen.add(h); out.append(c)
+    return out
+
+parsec_cards = build_parsec_cards(extract_pdf_text_pages(PARSEC_PDF))
+parsec_emb = embedder.encode(parsec_cards, batch_size=64, show_progress_bar=False, normalize_embeddings=True)
+parsec_emb = np.asarray(parsec_emb, dtype=np.float32)
+parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])
+parsec_index.add(parsec_emb)
+
+
+# ============================
+# Device resolution (exact SKU -> GPT A/B)
+# ============================
+def _label_for_row(i: int) -> str:
+    r = df_eos.iloc[i]
+    return f"{r.get('sku','')} — {r.get('manufacturer','')} — {r.get('description','')}"[:220]
+
+EOS_LABELS = [_label_for_row(i) for i in range(len(df_eos))]
+EOS_CORPUS = []
+for _, r in df_eos.iterrows():
+    EOS_CORPUS.append(" ".join([
+        r.get("_norm_sku",""),
+        r.get("_canon_make",""),
+        r.get("_norm_desc",""),
+        r.get("_norm_notes",""),
+    ]))
+
+def local_candidates(query: str, top_k: int = 6) -> List[Tuple[int,int,str]]:
+    q = norm_text(query)
+    hits = process.extract(q, EOS_CORPUS, scorer=fuzz.WRatio, limit=top_k)
+    return [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]
+
+def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> Dict[str, Any]:
+    if client is None:
+        return {}
+    sys = "Pick which router the user meant. Never invent. Return strict JSON only."
+    payload = {
+        "user_input": user_text,
+        "candidates": [{"row_idx": i, "score": s, "label": lbl} for (i,s,lbl) in candidates],
+        "rules": [
+            "If one candidate is clearly correct, return mode='ok' with row_idx.",
+            "If two are plausible, return mode='pick' with top 2 options."
+        ],
+        "output_schema": {"mode":"ok|pick","row_idx":"int","options":[{"row_idx":"int","label":"string"}]}
+    }
+    return gpt_json(sys, payload, max_tokens=300)
+
+def resolve_device(user_text: str) -> Dict[str, Any]:
+    q = norm_text(user_text)
+    exact_idxs = df_eos.index[df_eos["_norm_sku"] == q].tolist()
+    if len(exact_idxs) == 1:
+        return {"mode":"ok","row_idx": int(exact_idxs[0])}
+    if len(exact_idxs) > 1:
+        opts = [{"row_idx": int(i), "label": EOS_LABELS[int(i)]} for i in exact_idxs[:2]]
+        return {"mode":"pick","options": opts}
+
+    cands = local_candidates(user_text, top_k=6)
+    if not cands:
+        return {"mode":"not_found"}
+
+    if cands[0][1] >= 95 and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= 8):
+        return {"mode":"ok","row_idx": cands[0][0]}
+
+    g = gpt_choose_device(user_text, cands)
+    if g.get("mode") == "ok" and isinstance(g.get("row_idx"), int):
+        return {"mode":"ok","row_idx": int(g["row_idx"])}
+
+    if g.get("mode") == "pick":
+        opts = g.get("options", []) or []
+        opts2 = [{"row_idx": int(o["row_idx"]), "label": str(o["label"])} for o in opts[:2] if "row_idx" in o]
+        if opts2:
+            return {"mode":"pick","options": opts2}
+
+    # fallback
+    if len(cands) > 1:
+        return {"mode":"pick","options":[{"row_idx":cands[0][0],"label":cands[0][2]},{"row_idx":cands[1][0],"label":cands[1][2]}]}
+    return {"mode":"pick","options":[{"row_idx":cands[0][0],"label":cands[0][2]}]}
+
+
+# ============================
+# Replacements — lifecycle CSV is source of truth
+# Fix: always show 4G alternative if lifecycle suggests it (even if Active)
+# ============================
+def _extract_model_token(text: str) -> str:
+    s = _safe_str(text)
+    if not s:
+        return ""
+    parts = [p.strip() for p in s.split("|") if p.strip()]
+    candidates = parts[::-1] if parts else [s]
+
+    for cand in candidates:
+        # Teltonika family
+        m = re.search(r"\bRUT[A-Z]?\d{2,4}\b", cand.upper())
+        if m:
+            return m.group(0).upper()
+        # Digi IX-series
+        m = re.search(r"\bIX\d{2}\b", cand, flags=re.IGNORECASE)
+        if m:
+            return m.group(0).upper()
+        # Cradlepoint R/E/S
+        m = re.search(r"\b(R\d{3,4}|E\d{3,4}|S\d{3,4})\b", cand, flags=re.IGNORECASE)
+        if m:
+            return m.group(0).upper()
+        # Generic model token
+        m = re.search(r"\b[A-Z]{1,6}\d{2,4}[A-Z]?\b", cand.upper())
+        if m:
+            return m.group(0).upper()
+
+    return candidates[0][:60]
+
+def _device_is_4g(life_row: pd.Series) -> bool:
+    t = norm_text(life_row.get("description","")) + " " + norm_text(life_row.get("notes",""))
+    return (("lte" in t or "4g" in t) and ("5g" not in t and "nr" not in t))
+
+def _candidate_5g_models_from_lifecycle(manufacturer: str) -> List[str]:
+    # Pool within same manufacturer text (not just canon) to support Teltonika etc
+    mfr = norm_text(manufacturer)
+    pool = df_eos[df_eos["manufacturer"].astype(str).str.lower().eq(mfr)].copy() if "manufacturer" in df_eos.columns else df_eos.copy()
+    vals = pool["advanced_5g_option"].tolist() if "advanced_5g_option" in pool.columns else []
+    out, seen = [], set()
+    for v in vals:
+        tok = _extract_model_token(v)
+        if tok and tok.lower() != "nan" and tok not in seen:
+            seen.add(tok); out.append(tok)
+    return out
+
+def _candidate_4g_models_from_lifecycle(manufacturer: str) -> List[str]:
+    mfr = norm_text(manufacturer)
+    pool = df_eos[df_eos["manufacturer"].astype(str).str.lower().eq(mfr)].copy() if "manufacturer" in df_eos.columns else df_eos.copy()
+    vals = pool["suggested_replacement"].tolist() if "suggested_replacement" in pool.columns else []
+    out, seen = [], set()
+    for v in vals:
+        tok = _extract_model_token(v)
+        if tok and tok.lower() != "nan" and tok not in seen:
+            seen.add(tok); out.append(tok)
+    return out
+
+def _gpt_pick_from_candidates(old_row: pd.Series, candidates: List[str], need: str) -> str:
+    if client is None or not candidates:
+        return ""
+    sys = "Pick the best replacement model. Choose only from candidates. Return strict JSON only."
+    payload = {
+        "old_device": {
+            "sku": str(old_row.get("sku","")),
+            "manufacturer": str(old_row.get("manufacturer","")),
+            "description": str(old_row.get("description","")),
+            "need": need,
+        },
+        "candidates": candidates[:40],
+        "output_schema": {"choice":"string"}
+    }
+    out = gpt_json(sys, payload, max_tokens=240) or {}
+    choice = str(out.get("choice","") or "").strip()
+    return choice if choice in candidates else ""
+
+def _fallback_5g_from_dec(canon_make: str) -> str:
+    pool5 = df_dec[(df_dec["_canon_make"] == canon_make) & (df_dec["_is5g"] == True)]
+    return str(pool5.iloc[0]["Model"]).strip() if not pool5.empty else ""
+
+def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, Any]:
+    canon = str(life_row.get("_canon_make","UNKNOWN"))
+    manufacturer = str(life_row.get("manufacturer","") or "")
+
+    is_4g_device = _device_is_4g(life_row)
+    needs_4g_repl = is_4g_device and (status in {"End of Sale","End of Life"})
+    want_5g = is_4g_device or (status in {"End of Sale","End of Life"})
+
+    # 4G alternative: ALWAYS if suggested_replacement exists for 4G devices
+    repl_4g = "Not applicable"
+    if is_4g_device:
+        repl_4g = _extract_model_token(_safe_str(life_row.get("suggested_replacement","")))
+        if not repl_4g:
+            cand4 = _candidate_4g_models_from_lifecycle(manufacturer)
+            repl_4g = _gpt_pick_from_candidates(life_row, cand4, "4G alternative") or (cand4[0] if cand4 else "")
+        if not repl_4g:
+            repl_4g = "Not applicable"
+
+    # 5G replacement: ALWAYS when want_5g is true
+    repl_5g = "Not applicable"
+    if want_5g:
+        repl_5g = _extract_model_token(_safe_str(life_row.get("advanced_5g_option","")))
+        if not repl_5g:
+            cand5 = _candidate_5g_models_from_lifecycle(manufacturer)
+            repl_5g = _gpt_pick_from_candidates(life_row, cand5, "5G replacement/upgrade") or (cand5[0] if cand5 else "")
+        if not repl_5g:
+            # last resort: dec catalog fallback
+            repl_5g = _fallback_5g_from_dec(canon)
+
+    if repl_5g.lower() == "nan":
+        repl_5g = ""
+
+    return {
+        "repl_4g": repl_4g,
+        "repl_5g": repl_5g,
+        "why": "Lifecycle replacements (GPT fallback when missing).",
+        "sources": ["lifecycle_csv"] + (["gpt"] if client else []) + (["dec_fallback"] if (want_5g and not repl_5g) else []),
+    }
+
+
+# ============================
+# Antennas (Parsec-only; family name extraction)
+# ============================
+PARSEC_FAMILY_WORDS = {
+    "chinook","labrador","boxer","bloodhound","husky","beagle","mastiff","collie",
+    "shepherd","belgian","australian","terrier","pyrenees"
+}
+BAD_NAME_MARKERS = {
+    "customization", "standard connectors", "connectors", "features", "benefits",
+    "specifications", "mechanical", "electrical", "mounting", "accessories",
+    "description:", "standard sku"
+}
+
+def _clean_line(s: str) -> str:
+    s = re.sub(r"\s+", " ", str(s or "").strip())
+    if re.fullmatch(r"-[a-z0-9]+", s.lower()):
+        return ""
+    return s
+
+def _is_bad_name_line(line: str) -> bool:
+    low = line.lower()
+    if any(m in low for m in BAD_NAME_MARKERS):
+        return True
+    if re.search(r"\b-[a-z0-9]{1,4}\b", low) and len(low) <= 25:
+        return True
+    return False
+
+def _family_from_line(line: str) -> str:
+    low = line.lower()
+    for fam in PARSEC_FAMILY_WORDS:
+        if fam in low:
+            return fam.capitalize()
+    return ""
+
+def _parsec_name_from_card(card_text: str) -> str:
+    lines = [_clean_line(ln) for ln in str(card_text or "").splitlines()]
+    lines = [ln for ln in lines if ln]
+
+    for ln in lines:
+        if _is_bad_name_line(ln):
+            continue
+        fam = _family_from_line(ln)
+        if fam:
+            return fam
+
+    # fallback near SKU line
+    sku_i = None
+    for i, ln in enumerate(lines):
+        if "standard sku" in ln.lower():
+            sku_i = i
+            break
+    if sku_i is not None:
+        window = lines[max(0, sku_i - 12):sku_i]
+        for ln in reversed(window):
+            if _is_bad_name_line(ln):
+                continue
+            if 3 <= len(ln) <= 40 and re.search(r"[A-Za-z]", ln):
+                return ln.split()[0].capitalize()
+
+    return "Parsec antenna"
+
+def _parsec_part_from_card(t: str) -> str:
+    m = re.search(r"Standard\s+SKU:\s*([A-Z0-9]+)", t)
+    return m.group(1).strip() if m else ""
+
+def _parsec_desc_from_card(t: str) -> str:
+    m = re.search(r"Description:\s*(.+?)(?:\n|$)", t, flags=re.IGNORECASE)
+    return re.sub(r"\s+"," ",m.group(1).strip())[:220] if m else ""
+
+def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:
+    qv = embedder.encode([query], normalize_embeddings=True)
+    qv = np.asarray(qv, dtype=np.float32)
+    scores, ids = parsec_index.search(qv, top_k)
+    out = []
+    for sc, i in zip(scores[0].tolist(), ids[0].tolist()):
+        if 0 <= int(i) < len(parsec_cards):
+            card = parsec_cards[int(i)]
+            out.append({
+                "score": float(sc),
+                "name": _parsec_name_from_card(card),
+                "part_number": _parsec_part_from_card(card),
+                "description": _parsec_desc_from_card(card),
+            })
+    return out
+
+def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, Any]:
+    q_stationary = f"{router_model} {tech} {mimo} omni stationary outdoor Parsec"
+    q_vehicle = f"{router_model} {tech} {mimo} omni vehicle mobile Parsec"
+    cand_stationary = parsec_retrieve(q_stationary, top_k=10)
+    cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)
+
+    # deterministic fallback if no GPT
+    s = cand_stationary[0] if cand_stationary else {"name":"Parsec antenna","part_number":"","description":""}
+    v = cand_vehicle[0] if cand_vehicle else {"name":"Parsec antenna","part_number":"","description":""}
+    s.update({"mimo": mimo, "why": "Stationary omni best match."})
+    v.update({"mimo": mimo, "why": "Vehicle omni best match."})
+    return {"stationary_omni": s, "vehicle_omni": v, "sources":["parsec_rag"]}
+
+
+# ============================
+# Feature table + GPT fill for missing fields
+# ============================
+FEATURE_COLS = ["Name","Modem technology","WiFi","Ports","Antennas","Ruggedness","Use case"]
+
+def dec_features_by_model(model: str, canon_make: str) -> Dict[str, str]:
+    if not model or model in {"Not applicable","Not listed"}:
+        return {k:"Not listed" for k in FEATURE_COLS}
+    pool = df_dec[df_dec["_canon_make"] == canon_make].copy()
+    if pool.empty:
+        return {k:"Not listed" for k in FEATURE_COLS}
+    hit = process.extractOne(norm_text(model), pool["_norm_model"].tolist(), scorer=fuzz.WRatio)
+    if not hit or hit[1] < MATCH_OK:
+        return {k:"Not listed" for k in FEATURE_COLS}
+    r = pool.iloc[int(hit[2])]
+    ports = f"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}"
+    return {
+        "Name": str(r.get("Model","")),
+        "Modem technology": str(r.get("Modem Type","")),
+        "WiFi": str(r.get("WiFi type","")),
+        "Ports": ports,
+        "Antennas": str(r.get("Antennas (internal/external/both)","")),
+        "Ruggedness": str(r.get("Ruggedization","")),
+        "Use case": str(r.get("Primary use case","")),
+    }
+
+def gpt_fill_features(device_label: str, feats: Dict[str,str], context: str) -> Dict[str,str]:
+    missing = [k for k,v in feats.items() if (not v) or v.strip().lower() in {"not listed","nan"}]
+    if client is None or not missing:
+        return feats
+    sys = "Fill missing router feature fields. Return strict JSON only."
+    payload = {
+        "device": device_label,
+        "known": feats,
+        "context": context[:2000],
+        "fill_only": missing,
+        "rules": ["Fill only requested fields. Best guess if needed. Return JSON only."],
+        "output_schema": {k:"string" for k in missing}
+    }
+    out = gpt_json(sys, payload, max_tokens=350) or {}
+    for k in missing:
+        v = str(out.get(k,"") or "").strip()
+        if v:
+            feats[k] = v
+    return feats
+
+def current_features_guess(life_row: pd.Series) -> Dict[str,str]:
+    sku = str(life_row.get("sku","") or "").strip()
+    desc = str(life_row.get("description","") or "").strip()
+    notes = str(life_row.get("notes","") or "").strip()
+    base = {
+        "Name": sku,
+        "Modem technology": "4G" if _device_is_4g(life_row) else ("5G" if ("5g" in (desc+notes).lower() or "nr" in (desc+notes).lower()) else "Not listed"),
+        "WiFi": "Not listed",
+        "Ports": "Not listed",
+        "Antennas": "Not listed",
+        "Ruggedness": "Not listed",
+        "Use case": "Not listed",
+    }
+    return gpt_fill_features("Current device", base, f"{desc}\n{notes}")
+
+def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str]) -> str:
+    cols = ["Device", "Modem technology", "WiFi", "Ports", "Antennas", "Ruggedness", "Use case"]
+    header = "| " + " | ".join(cols) + " |"
+    sep = "| " + " | ".join(["---"]*len(cols)) + " |"
+    def row(name: str, feats: Dict[str,str]) -> str:
+        return "| " + " | ".join([
+            name,
+            feats.get("Modem technology","Not listed"),
+            feats.get("WiFi","Not listed"),
+            feats.get("Ports","Not listed"),
+            feats.get("Antennas","Not listed"),
+            feats.get("Ruggedness","Not listed"),
+            feats.get("Use case","Not listed"),
+        ]) + " |"
+    return "\n".join([header, sep, row("Current", cur), row("4G alternative", r4), row("5G replacement", r5)])
+
+
+# ============================
+# Output + Gradio
+# ============================
+def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:
+    canon_make = str(life_row.get("_canon_make","UNKNOWN"))
+    current_name = f"{life_row.get('sku','')} — {life_row.get('description','')}".strip(" —")
+
+    st = ant.get("stationary_omni", {})
+    vh = ant.get("vehicle_omni", {})
+
+    cur_feats = current_features_guess(life_row)
+    r4_feats = dec_features_by_model(repl.get("repl_4g",""), canon_make)
+    r5_feats = dec_features_by_model(repl.get("repl_5g",""), canon_make)
+
+    # If dec doesn't know the model, ask GPT to fill missing cells (best guess)
+    if client is not None:
+        r4_feats = gpt_fill_features("4G alternative", r4_feats, f"Model: {repl.get('repl_4g','')}\nMake: {canon_make}")
+        r5_feats = gpt_fill_features("5G replacement", r5_feats, f"Model: {repl.get('repl_5g','')}\nMake: {canon_make}")
+
+    table_md = build_features_table(cur_feats, r4_feats, r5_feats)
+
+    lines = []
+    lines.append(f"1. Current device: **{current_name}**")
+    lines.append(f"2. Status: **{status}**")
+    lines.append(f"3. End of Sale date: **{eos}**")
+    lines.append(f"4. End of Life date: **{eol}**")
+    lines.append(f"5. 4G alternative (lifecycle): **{repl.get('repl_4g','Not applicable')}**")
+    lines.append(f"6. 5G replacement (lifecycle): **{repl.get('repl_5g','Not listed')}**")
+    lines.append("7. Antenna options (Parsec-only):")
+    lines.append(f"   - Stationary (Omni): **{st.get('name','')}** (Part #: {st.get('part_number','')}) — {st.get('description','')} — MIMO: {st.get('mimo','')} — {st.get('why','')}")
+    lines.append(f"   - Vehicle (Omni): **{vh.get('name','')}** (Part #: {vh.get('part_number','')}) — {vh.get('description','')} — MIMO: {vh.get('mimo','')} — {vh.get('why','')}")
+    lines.append("8. Recommended features table:")
+    lines.append(table_md)
+    lines.append("\nSources (debug):")
+    for s in repl.get("sources", []) if isinstance(repl.get("sources"), list) else []:
+        lines.append(f"- {s}")
+    lines.append("- ParsecCatalog.pdf (local RAG)")
+    lines.append("- routers_eos_eol_by_sku.csv (replacements)")
+    lines.append("- dec2025routers.csv (features)")
+    return "\n".join(lines)
+
+def run_lookup(user_text: str, st: Dict[str,Any]):
+    user_text = str(user_text or "").strip()
+    if not user_text:
+        return "Enter a router SKU/model.", gr.update(visible=False), gr.update(visible=False), {}
+
+    res = resolve_device(user_text)
+    if res.get("mode") == "pick":
+        opts = res.get("options", [])
+        choices = [o["label"] for o in opts]
+        st2 = {"mode":"pick","options": opts}
+        return "Did you mean A or B? Pick one, then click Use selection.", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2
+
+    if res.get("mode") != "ok":
+        return "Not found.", gr.update(visible=False), gr.update(visible=False), {}
+
+    life_row = df_eos.iloc[int(res["row_idx"])]
+    eos, eol, status = row_to_dates_and_status(life_row)
+
+    repl = pick_replacements_lifecycle(life_row, status)
+
+    tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") not in {"Not applicable","Not listed"} else ("4G" if _device_is_4g(life_row) else "Unknown")
+    mimo_guess = "4x4" if tech == "5G" else "2x2"
+    ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo_guess)
+
+    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}
+
+def use_selection(selected_label: str, st: Dict[str,Any]):
+    if not st or st.get("mode") != "pick":
+        return "Run a search first.", gr.update(visible=False), gr.update(visible=False), {}
+    if not selected_label:
+        return "Pick A or B first.", gr.update(visible=True), gr.update(visible=True), st
+
+    chosen_row = None
+    for o in st.get("options", []):
+        if o.get("label") == selected_label:
+            chosen_row = int(o["row_idx"])
+            break
+    if chosen_row is None:
+        return "Pick a valid option.", gr.update(visible=True), gr.update(visible=True), st
+
+    life_row = df_eos.iloc[int(chosen_row)]
+    eos, eol, status = row_to_dates_and_status(life_row)
+    repl = pick_replacements_lifecycle(life_row, status)
+    tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") not in {"Not applicable","Not listed"} else ("4G" if _device_is_4g(life_row) else "Unknown")
+    mimo_guess = "4x4" if tech == "5G" else "2x2"
+    ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo_guess)
+
+    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}
+
+with gr.Blocks(title="Only-Routers") as demo:
+    gr.Markdown("## Only-Routers\nEnter a router SKU/model. If ambiguous, you’ll get A/B choices.")
+    user_text = gr.Textbox(label="Router SKU or model", placeholder="Examples: IBR650B, AER1600, ES450, WR21, RUT240", lines=1)
+    st = gr.State({})
+
+    check_btn = gr.Button("Check", variant="primary")
+    pick_dd = gr.Dropdown(label="Pick A or B", choices=[], visible=False)
+    use_btn = gr.Button("Use selection", visible=False)
+
+    output_md = gr.Markdown()
+
+    check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st])
+    use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st])
+
+demo.launch()

only-routers_ai_poc_v4_7_commented.ipynb

@@ -0,0 +1,1346 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0300079d",
+   "metadata": {},
+   "source": [
+    "**Cell summary:** Section header / instructions.\n",
+    "\n",
+    "# Only-Routers (v4.6)\n",
+    "\n",
+    "This notebook mirrors the Hugging Face Spaces `app.py` logic.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39660795",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cell summary: This cell is part of the Only-Routers notebook; see inline comments for each line.\n",
+    "# import os\n",
+    "import os\n",
+    "# import re\n",
+    "import re\n",
+    "# import json\n",
+    "import json\n",
+    "# import math\n",
+    "import math\n",
+    "# import hashlib\n",
+    "import hashlib\n",
+    "# from dataclasses import dataclass\n",
+    "from dataclasses import dataclass\n",
+    "# from datetime import datetime, date\n",
+    "from datetime import datetime, date\n",
+    "# from typing import Dict, List, Optional, Tuple, Any\n",
+    "from typing import Dict, List, Optional, Tuple, Any\n",
+    "\n",
+    "# import numpy as np\n",
+    "import numpy as np\n",
+    "# import pandas as pd\n",
+    "import pandas as pd\n",
+    "\n",
+    "# import fitz  # PyMuPDF\n",
+    "import fitz  # PyMuPDF\n",
+    "# import faiss\n",
+    "import faiss\n",
+    "# from sentence_transformers import SentenceTransformer\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "# from rapidfuzz import fuzz, process\n",
+    "from rapidfuzz import fuzz, process\n",
+    "\n",
+    "# import gradio as gr\n",
+    "import gradio as gr\n",
+    "# from openai import OpenAI\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Settings\n",
+    "# ============================\n",
+    "# TODAY = date(2026, 1, 18)\n",
+    "TODAY = date(2026, 1, 18)\n",
+    "# OPENAI_MODEL = \"gpt-5.2\"\n",
+    "OPENAI_MODEL = \"gpt-5.2\"\n",
+    "# OPENAI_REASONING = {\"effort\": \"high\"}\n",
+    "OPENAI_REASONING = {\"effort\": \"high\"}\n",
+    "\n",
+    "# MATCH_OK = 80\n",
+    "MATCH_OK = 80\n",
+    "# EMBED_MODEL_NAME = \"sentence-transformers/all-MiniLM-L6-v2\"\n",
+    "EMBED_MODEL_NAME = \"sentence-transformers/all-MiniLM-L6-v2\"\n",
+    "# PARSEC_CONTEXT_BEFORE = 900\n",
+    "PARSEC_CONTEXT_BEFORE = 900\n",
+    "# PARSEC_CONTEXT_AFTER = 1600\n",
+    "PARSEC_CONTEXT_AFTER = 1600\n",
+    "\n",
+    "# CACHE_DIR = os.path.join(os.getcwd(), \".onlyrouters_cache\")\n",
+    "CACHE_DIR = os.path.join(os.getcwd(), \".onlyrouters_cache\")\n",
+    "# os.makedirs(CACHE_DIR, exist_ok=True)\n",
+    "os.makedirs(CACHE_DIR, exist_ok=True)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# OpenAI client (HF Space secret: OPENAI_API_KEY)\n",
+    "# ============================\n",
+    "# API_KEY = os.getenv(\"OPENAI_API_KEY\", \"\").strip()\n",
+    "API_KEY = os.getenv(\"OPENAI_API_KEY\", \"\").strip()\n",
+    "# client = OpenAI(api_key=API_KEY) if API_KEY else None\n",
+    "client = OpenAI(api_key=API_KEY) if API_KEY else None\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Utilities\n",
+    "# ============================\n",
+    "# def norm_text(s: Any) -> str:\n",
+    "def norm_text(s: Any) -> str:\n",
+    "# try:\n",
+    "    try:\n",
+    "# if s is None or (isinstance(s, float) and math.isnan(s)) or pd.isna(s):\n",
+    "        if s is None or (isinstance(s, float) and math.isnan(s)) or pd.isna(s):\n",
+    "# return \"\"\n",
+    "            return \"\"\n",
+    "# except Exception:\n",
+    "    except Exception:\n",
+    "# pass\n",
+    "        pass\n",
+    "# s = str(s).strip().lower()\n",
+    "    s = str(s).strip().lower()\n",
+    "# s = re.sub(r\"[^a-z0-9\\s\\-\\/]\", \" \", s)\n",
+    "    s = re.sub(r\"[^a-z0-9\\s\\-\\/]\", \" \", s)\n",
+    "# s = re.sub(r\"\\s+\", \" \", s).strip()\n",
+    "    s = re.sub(r\"\\s+\", \" \", s).strip()\n",
+    "# return s\n",
+    "    return s\n",
+    "\n",
+    "# def _safe_str(v: Any) -> str:\n",
+    "def _safe_str(v: Any) -> str:\n",
+    "# if v is None or (isinstance(v, float) and pd.isna(v)) or pd.isna(v):\n",
+    "    if v is None or (isinstance(v, float) and pd.isna(v)) or pd.isna(v):\n",
+    "# return \"\"\n",
+    "        return \"\"\n",
+    "# return str(v).strip()\n",
+    "    return str(v).strip()\n",
+    "\n",
+    "# def _is_5g(modem_type: Any) -> bool:\n",
+    "def _is_5g(modem_type: Any) -> bool:\n",
+    "# s = norm_text(modem_type)\n",
+    "    s = norm_text(modem_type)\n",
+    "# return (\"5g\" in s) or (\"nr\" in s)\n",
+    "    return (\"5g\" in s) or (\"nr\" in s)\n",
+    "\n",
+    "# def _json_load_safe(s: str) -> Dict[str, Any]:\n",
+    "def _json_load_safe(s: str) -> Dict[str, Any]:\n",
+    "# try:\n",
+    "    try:\n",
+    "# return json.loads(s)\n",
+    "        return json.loads(s)\n",
+    "# except Exception:\n",
+    "    except Exception:\n",
+    "# return {}\n",
+    "        return {}\n",
+    "\n",
+    "# def gpt_json(system: str, payload: Dict[str, Any], max_tokens: int = 700) -> Dict[str, Any]:\n",
+    "def gpt_json(system: str, payload: Dict[str, Any], max_tokens: int = 700) -> Dict[str, Any]:\n",
+    "# if client is None:\n",
+    "    if client is None:\n",
+    "# return {}\n",
+    "        return {}\n",
+    "# resp = client.responses.create(\n",
+    "    resp = client.responses.create(\n",
+    "# model=OPENAI_MODEL,\n",
+    "        model=OPENAI_MODEL,\n",
+    "# reasoning=OPENAI_REASONING,\n",
+    "        reasoning=OPENAI_REASONING,\n",
+    "# input=[\n",
+    "        input=[\n",
+    "# {\"role\": \"system\", \"content\": system},\n",
+    "            {\"role\": \"system\", \"content\": system},\n",
+    "# {\"role\": \"user\", \"content\": json.dumps(payload)},\n",
+    "            {\"role\": \"user\", \"content\": json.dumps(payload)},\n",
+    "# ],\n",
+    "        ],\n",
+    "# max_output_tokens=max_tokens,\n",
+    "        max_output_tokens=max_tokens,\n",
+    "# )\n",
+    "    )\n",
+    "# return _json_load_safe(getattr(resp, \"output_text\", \"\") or \"\")\n",
+    "    return _json_load_safe(getattr(resp, \"output_text\", \"\") or \"\")\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Load data files (must exist in repo)\n",
+    "# ============================\n",
+    "# EOS_PATH = \"routers_eos_eol_by_sku.csv\"\n",
+    "EOS_PATH = \"routers_eos_eol_by_sku.csv\"\n",
+    "# DEC_PATH = \"dec2025routers.csv\"\n",
+    "DEC_PATH = \"dec2025routers.csv\"\n",
+    "# PARSEC_PDF = \"ParsecCatalog.pdf\"\n",
+    "PARSEC_PDF = \"ParsecCatalog.pdf\"\n",
+    "\n",
+    "# if not os.path.exists(EOS_PATH):\n",
+    "if not os.path.exists(EOS_PATH):\n",
+    "# raise FileNotFoundError(f\"Missing {EOS_PATH} in repo.\")\n",
+    "    raise FileNotFoundError(f\"Missing {EOS_PATH} in repo.\")\n",
+    "# if not os.path.exists(DEC_PATH):\n",
+    "if not os.path.exists(DEC_PATH):\n",
+    "# raise FileNotFoundError(f\"Missing {DEC_PATH} in repo.\")\n",
+    "    raise FileNotFoundError(f\"Missing {DEC_PATH} in repo.\")\n",
+    "# if not os.path.exists(PARSEC_PDF):\n",
+    "if not os.path.exists(PARSEC_PDF):\n",
+    "# raise FileNotFoundError(f\"Missing {PARSEC_PDF} in repo.\")\n",
+    "    raise FileNotFoundError(f\"Missing {PARSEC_PDF} in repo.\")\n",
+    "\n",
+    "# df_eos = pd.read_csv(EOS_PATH).copy()\n",
+    "df_eos = pd.read_csv(EOS_PATH).copy()\n",
+    "# df_dec = pd.read_csv(DEC_PATH).copy()\n",
+    "df_dec = pd.read_csv(DEC_PATH).copy()\n",
+    "\n",
+    "# Region filter: keep USA / North America / blank / not specified\n",
+    "# def _region_ok(x: Any) -> bool:\n",
+    "def _region_ok(x: Any) -> bool:\n",
+    "# s = str(x or \"\").strip().lower()\n",
+    "    s = str(x or \"\").strip().lower()\n",
+    "# if not s:\n",
+    "    if not s:\n",
+    "# return True\n",
+    "        return True\n",
+    "# if \"not specified\" in s:\n",
+    "    if \"not specified\" in s:\n",
+    "# return True\n",
+    "        return True\n",
+    "# if \"north america\" in s:\n",
+    "    if \"north america\" in s:\n",
+    "# return True\n",
+    "        return True\n",
+    "# if re.search(r\"\\busa\\b\", s):\n",
+    "    if re.search(r\"\\busa\\b\", s):\n",
+    "# return True\n",
+    "        return True\n",
+    "# if re.search(r\"\\bunited\\s+states\\b\", s):\n",
+    "    if re.search(r\"\\bunited\\s+states\\b\", s):\n",
+    "# return True\n",
+    "        return True\n",
+    "# if re.search(r\"\\bu\\.?s\\.?\\b\", s):\n",
+    "    if re.search(r\"\\bu\\.?s\\.?\\b\", s):\n",
+    "# return True\n",
+    "        return True\n",
+    "# return False\n",
+    "    return False\n",
+    "\n",
+    "# if \"region\" in df_eos.columns:\n",
+    "if \"region\" in df_eos.columns:\n",
+    "# df_eos = df_eos[df_eos[\"region\"].apply(_region_ok)].reset_index(drop=True)\n",
+    "    df_eos = df_eos[df_eos[\"region\"].apply(_region_ok)].reset_index(drop=True)\n",
+    "\n",
+    "# Optional \"Device Type\"\n",
+    "# device_type_col = None\n",
+    "device_type_col = None\n",
+    "# for c in df_eos.columns:\n",
+    "for c in df_eos.columns:\n",
+    "# if norm_text(c) == \"device type\":\n",
+    "    if norm_text(c) == \"device type\":\n",
+    "# device_type_col = c\n",
+    "        device_type_col = c\n",
+    "# break\n",
+    "        break\n",
+    "\n",
+    "# Maker mapping (expanded — adds Teltonika)\n",
+    "# CANON_MAKER = {\n",
+    "CANON_MAKER = {\n",
+    "# \"CRADLEPOINT\": {\"cradlepoint\", \"ericsson\", \"ericsson enterprise wireless\"},\n",
+    "    \"CRADLEPOINT\": {\"cradlepoint\", \"ericsson\", \"ericsson enterprise wireless\"},\n",
+    "# \"SIERRA\": {\"sierra\", \"sierra wireless\", \"semtech\", \"airlink\"},\n",
+    "    \"SIERRA\": {\"sierra\", \"sierra wireless\", \"semtech\", \"airlink\"},\n",
+    "# \"FEENEY\": {\"feeney\", \"feeney wireless\", \"inseego\"},\n",
+    "    \"FEENEY\": {\"feeney\", \"feeney wireless\", \"inseego\"},\n",
+    "# \"DIGI\": {\"digi\", \"accelerated\", \"accelerated concepts\"},\n",
+    "    \"DIGI\": {\"digi\", \"accelerated\", \"accelerated concepts\"},\n",
+    "# \"CISCO_MERAKI\": {\"meraki\", \"cisco meraki\"},\n",
+    "    \"CISCO_MERAKI\": {\"meraki\", \"cisco meraki\"},\n",
+    "# \"CISCO\": {\"cisco\"},\n",
+    "    \"CISCO\": {\"cisco\"},\n",
+    "# \"TELTONIKA\": {\"teltonika\"},\n",
+    "    \"TELTONIKA\": {\"teltonika\"},\n",
+    "# }\n",
+    "}\n",
+    "# DISPLAY_MAKER = {\n",
+    "DISPLAY_MAKER = {\n",
+    "# \"CRADLEPOINT\": \"Cradlepoint\",\n",
+    "    \"CRADLEPOINT\": \"Cradlepoint\",\n",
+    "# \"SIERRA\": \"Sierra Wireless\",\n",
+    "    \"SIERRA\": \"Sierra Wireless\",\n",
+    "# \"FEENEY\": \"Feeney Wireless\",\n",
+    "    \"FEENEY\": \"Feeney Wireless\",\n",
+    "# \"DIGI\": \"Digi\",\n",
+    "    \"DIGI\": \"Digi\",\n",
+    "# \"CISCO_MERAKI\": \"Cisco Meraki\",\n",
+    "    \"CISCO_MERAKI\": \"Cisco Meraki\",\n",
+    "# \"CISCO\": \"Cisco\",\n",
+    "    \"CISCO\": \"Cisco\",\n",
+    "# \"TELTONIKA\": \"Teltonika\",\n",
+    "    \"TELTONIKA\": \"Teltonika\",\n",
+    "# \"UNKNOWN\": \"Unknown\",\n",
+    "    \"UNKNOWN\": \"Unknown\",\n",
+    "# }\n",
+    "}\n",
+    "\n",
+    "# def canon_maker_from_text(s: Any) -> str:\n",
+    "def canon_maker_from_text(s: Any) -> str:\n",
+    "# t = norm_text(s)\n",
+    "    t = norm_text(s)\n",
+    "# for canon, terms in CANON_MAKER.items():\n",
+    "    for canon, terms in CANON_MAKER.items():\n",
+    "# for term in terms:\n",
+    "        for term in terms:\n",
+    "# if term in t:\n",
+    "            if term in t:\n",
+    "# return canon\n",
+    "                return canon\n",
+    "# return \"UNKNOWN\"\n",
+    "    return \"UNKNOWN\"\n",
+    "\n",
+    "# df_eos[\"_canon_make\"] = df_eos[\"manufacturer\"].apply(canon_maker_from_text) if \"manufacturer\" in df_eos.columns else \"UNKNOWN\"\n",
+    "df_eos[\"_canon_make\"] = df_eos[\"manufacturer\"].apply(canon_maker_from_text) if \"manufacturer\" in df_eos.columns else \"UNKNOWN\"\n",
+    "# df_eos[\"_norm_sku\"] = df_eos[\"sku\"].apply(norm_text) if \"sku\" in df_eos.columns else \"\"\n",
+    "df_eos[\"_norm_sku\"] = df_eos[\"sku\"].apply(norm_text) if \"sku\" in df_eos.columns else \"\"\n",
+    "# df_eos[\"_norm_desc\"] = df_eos[\"description\"].apply(norm_text) if \"description\" in df_eos.columns else \"\"\n",
+    "df_eos[\"_norm_desc\"] = df_eos[\"description\"].apply(norm_text) if \"description\" in df_eos.columns else \"\"\n",
+    "# df_eos[\"_norm_notes\"] = df_eos[\"notes\"].apply(norm_text) if \"notes\" in df_eos.columns else \"\"\n",
+    "df_eos[\"_norm_notes\"] = df_eos[\"notes\"].apply(norm_text) if \"notes\" in df_eos.columns else \"\"\n",
+    "\n",
+    "# df_dec[\"_canon_make\"] = df_dec[\"Make\"].apply(canon_maker_from_text) if \"Make\" in df_dec.columns else \"UNKNOWN\"\n",
+    "df_dec[\"_canon_make\"] = df_dec[\"Make\"].apply(canon_maker_from_text) if \"Make\" in df_dec.columns else \"UNKNOWN\"\n",
+    "# df_dec[\"_norm_model\"] = df_dec[\"Model\"].apply(norm_text) if \"Model\" in df_dec.columns else \"\"\n",
+    "df_dec[\"_norm_model\"] = df_dec[\"Model\"].apply(norm_text) if \"Model\" in df_dec.columns else \"\"\n",
+    "# df_dec[\"_is5g\"] = df_dec[\"Modem Type\"].apply(_is_5g) if \"Modem Type\" in df_dec.columns else False\n",
+    "df_dec[\"_is5g\"] = df_dec[\"Modem Type\"].apply(_is_5g) if \"Modem Type\" in df_dec.columns else False\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Date helpers\n",
+    "# ============================\n",
+    "# @dataclass\n",
+    "@dataclass\n",
+    "# class ParsedDate:\n",
+    "class ParsedDate:\n",
+    "# raw: str\n",
+    "    raw: str\n",
+    "# kind: str\n",
+    "    kind: str\n",
+    "# value: Optional[date]\n",
+    "    value: Optional[date]\n",
+    "\n",
+    "# def parse_date_field(x: Any) -> ParsedDate:\n",
+    "def parse_date_field(x: Any) -> ParsedDate:\n",
+    "# raw = str(x or \"\").strip()\n",
+    "    raw = str(x or \"\").strip()\n",
+    "# if not raw:\n",
+    "    if not raw:\n",
+    "# return ParsedDate(raw=\"\", kind=\"missing\", value=None)\n",
+    "        return ParsedDate(raw=\"\", kind=\"missing\", value=None)\n",
+    "\n",
+    "# if re.fullmatch(r\"\\d{4}\", raw):\n",
+    "    if re.fullmatch(r\"\\d{4}\", raw):\n",
+    "# y = int(raw)\n",
+    "        y = int(raw)\n",
+    "# if y == TODAY.year:\n",
+    "        if y == TODAY.year:\n",
+    "# return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "            return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "# if y < TODAY.year:\n",
+    "        if y < TODAY.year:\n",
+    "# return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "            return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "# return ParsedDate(raw=raw, kind=\"year\", value=date(y, 12, 31))\n",
+    "        return ParsedDate(raw=raw, kind=\"year\", value=date(y, 12, 31))\n",
+    "\n",
+    "# if re.fullmatch(r\"\\d{4}-\\d{2}\", raw):\n",
+    "    if re.fullmatch(r\"\\d{4}-\\d{2}\", raw):\n",
+    "# try:\n",
+    "        try:\n",
+    "# y, m = raw.split(\"-\")\n",
+    "            y, m = raw.split(\"-\")\n",
+    "# return ParsedDate(raw=raw, kind=\"year_month\", value=date(int(y), int(m), 1))\n",
+    "            return ParsedDate(raw=raw, kind=\"year_month\", value=date(int(y), int(m), 1))\n",
+    "# except Exception:\n",
+    "        except Exception:\n",
+    "# return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "# if re.fullmatch(r\"\\d{4}-\\d{2}-\\d{2}\", raw):\n",
+    "    if re.fullmatch(r\"\\d{4}-\\d{2}-\\d{2}\", raw):\n",
+    "# try:\n",
+    "        try:\n",
+    "# dt = datetime.strptime(raw, \"%Y-%m-%d\").date()\n",
+    "            dt = datetime.strptime(raw, \"%Y-%m-%d\").date()\n",
+    "# return ParsedDate(raw=raw, kind=\"full\", value=dt)\n",
+    "            return ParsedDate(raw=raw, kind=\"full\", value=dt)\n",
+    "# except Exception:\n",
+    "        except Exception:\n",
+    "# return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "# return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "    return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "# def display_date(parsed: ParsedDate) -> str:\n",
+    "def display_date(parsed: ParsedDate) -> str:\n",
+    "# if parsed.kind == \"missing\":\n",
+    "    if parsed.kind == \"missing\":\n",
+    "# return \"Not listed\"\n",
+    "        return \"Not listed\"\n",
+    "# if parsed.kind == \"bad\":\n",
+    "    if parsed.kind == \"bad\":\n",
+    "# return parsed.raw or \"Not listed\"\n",
+    "        return parsed.raw or \"Not listed\"\n",
+    "# return parsed.raw\n",
+    "    return parsed.raw\n",
+    "\n",
+    "# def status_from_eos_eol(eos: ParsedDate, eol: ParsedDate) -> str:\n",
+    "def status_from_eos_eol(eos: ParsedDate, eol: ParsedDate) -> str:\n",
+    "# if eos.value is None and eol.value is None:\n",
+    "    if eos.value is None and eol.value is None:\n",
+    "# return \"Unknown\"\n",
+    "        return \"Unknown\"\n",
+    "# if eol.value is not None and eol.value <= TODAY:\n",
+    "    if eol.value is not None and eol.value <= TODAY:\n",
+    "# return \"End of Life\"\n",
+    "        return \"End of Life\"\n",
+    "# if eos.value is not None and eos.value <= TODAY:\n",
+    "    if eos.value is not None and eos.value <= TODAY:\n",
+    "# return \"End of Sale\"\n",
+    "        return \"End of Sale\"\n",
+    "# return \"Active\"\n",
+    "    return \"Active\"\n",
+    "\n",
+    "# def row_to_dates_and_status(life_row: pd.Series) -> Tuple[str, str, str]:\n",
+    "def row_to_dates_and_status(life_row: pd.Series) -> Tuple[str, str, str]:\n",
+    "# eos = parse_date_field(life_row.get(\"end_of_sale\"))\n",
+    "    eos = parse_date_field(life_row.get(\"end_of_sale\"))\n",
+    "# eol = parse_date_field(life_row.get(\"end_of_life\"))\n",
+    "    eol = parse_date_field(life_row.get(\"end_of_life\"))\n",
+    "# return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)\n",
+    "    return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Embeddings + Parsec index\n",
+    "# ============================\n",
+    "# embedder = SentenceTransformer(EMBED_MODEL_NAME)\n",
+    "embedder = SentenceTransformer(EMBED_MODEL_NAME)\n",
+    "\n",
+    "# def extract_pdf_text_pages(path: str) -> List[str]:\n",
+    "def extract_pdf_text_pages(path: str) -> List[str]:\n",
+    "# doc = fitz.open(path)\n",
+    "    doc = fitz.open(path)\n",
+    "# return [doc[i].get_text(\"text\") for i in range(len(doc))]\n",
+    "    return [doc[i].get_text(\"text\") for i in range(len(doc))]\n",
+    "\n",
+    "# def build_parsec_cards(pages: List[str]) -> List[str]:\n",
+    "def build_parsec_cards(pages: List[str]) -> List[str]:\n",
+    "# cards = []\n",
+    "    cards = []\n",
+    "# for p in pages:\n",
+    "    for p in pages:\n",
+    "# for m in re.finditer(r\"Standard\\s+SKU:\", p):\n",
+    "        for m in re.finditer(r\"Standard\\s+SKU:\", p):\n",
+    "# start = max(0, m.start() - PARSEC_CONTEXT_BEFORE)\n",
+    "            start = max(0, m.start() - PARSEC_CONTEXT_BEFORE)\n",
+    "# end = min(len(p), m.start() + PARSEC_CONTEXT_AFTER)\n",
+    "            end = min(len(p), m.start() + PARSEC_CONTEXT_AFTER)\n",
+    "# c = p[start:end].strip()\n",
+    "            c = p[start:end].strip()\n",
+    "# if len(c) >= 200:\n",
+    "            if len(c) >= 200:\n",
+    "# cards.append(c)\n",
+    "                cards.append(c)\n",
+    "# out, seen = [], set()\n",
+    "    out, seen = [], set()\n",
+    "# for c in cards:\n",
+    "    for c in cards:\n",
+    "# h = hashlib.sha1(c.encode(\"utf-8\")).hexdigest()\n",
+    "        h = hashlib.sha1(c.encode(\"utf-8\")).hexdigest()\n",
+    "# if h not in seen:\n",
+    "        if h not in seen:\n",
+    "# seen.add(h); out.append(c)\n",
+    "            seen.add(h); out.append(c)\n",
+    "# return out\n",
+    "    return out\n",
+    "\n",
+    "# parsec_cards = build_parsec_cards(extract_pdf_text_pages(PARSEC_PDF))\n",
+    "parsec_cards = build_parsec_cards(extract_pdf_text_pages(PARSEC_PDF))\n",
+    "# parsec_emb = embedder.encode(parsec_cards, batch_size=64, show_progress_bar=False, normalize_embeddings=True)\n",
+    "parsec_emb = embedder.encode(parsec_cards, batch_size=64, show_progress_bar=False, normalize_embeddings=True)\n",
+    "# parsec_emb = np.asarray(parsec_emb, dtype=np.float32)\n",
+    "parsec_emb = np.asarray(parsec_emb, dtype=np.float32)\n",
+    "# parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])\n",
+    "parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])\n",
+    "# parsec_index.add(parsec_emb)\n",
+    "parsec_index.add(parsec_emb)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Device resolution (exact SKU -> GPT A/B)\n",
+    "# ============================\n",
+    "# def _label_for_row(i: int) -> str:\n",
+    "def _label_for_row(i: int) -> str:\n",
+    "# r = df_eos.iloc[i]\n",
+    "    r = df_eos.iloc[i]\n",
+    "# return f\"{r.get('sku','')} — {r.get('manufacturer','')} — {r.get('description','')}\"[:220]\n",
+    "    return f\"{r.get('sku','')} — {r.get('manufacturer','')} — {r.get('description','')}\"[:220]\n",
+    "\n",
+    "# EOS_LABELS = [_label_for_row(i) for i in range(len(df_eos))]\n",
+    "EOS_LABELS = [_label_for_row(i) for i in range(len(df_eos))]\n",
+    "# EOS_CORPUS = []\n",
+    "EOS_CORPUS = []\n",
+    "# for _, r in df_eos.iterrows():\n",
+    "for _, r in df_eos.iterrows():\n",
+    "# EOS_CORPUS.append(\" \".join([\n",
+    "    EOS_CORPUS.append(\" \".join([\n",
+    "# r.get(\"_norm_sku\",\"\"),\n",
+    "        r.get(\"_norm_sku\",\"\"),\n",
+    "# r.get(\"_canon_make\",\"\"),\n",
+    "        r.get(\"_canon_make\",\"\"),\n",
+    "# r.get(\"_norm_desc\",\"\"),\n",
+    "        r.get(\"_norm_desc\",\"\"),\n",
+    "# r.get(\"_norm_notes\",\"\"),\n",
+    "        r.get(\"_norm_notes\",\"\"),\n",
+    "# ]))\n",
+    "    ]))\n",
+    "\n",
+    "# def local_candidates(query: str, top_k: int = 6) -> List[Tuple[int,int,str]]:\n",
+    "def local_candidates(query: str, top_k: int = 6) -> List[Tuple[int,int,str]]:\n",
+    "# q = norm_text(query)\n",
+    "    q = norm_text(query)\n",
+    "# hits = process.extract(q, EOS_CORPUS, scorer=fuzz.WRatio, limit=top_k)\n",
+    "    hits = process.extract(q, EOS_CORPUS, scorer=fuzz.WRatio, limit=top_k)\n",
+    "# return [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]\n",
+    "    return [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]\n",
+    "\n",
+    "# def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> Dict[str, Any]:\n",
+    "def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> Dict[str, Any]:\n",
+    "# if client is None:\n",
+    "    if client is None:\n",
+    "# return {}\n",
+    "        return {}\n",
+    "# sys = \"Pick which router the user meant. Never invent. Return strict JSON only.\"\n",
+    "    sys = \"Pick which router the user meant. Never invent. Return strict JSON only.\"\n",
+    "# payload = {\n",
+    "    payload = {\n",
+    "# \"user_input\": user_text,\n",
+    "        \"user_input\": user_text,\n",
+    "# \"candidates\": [{\"row_idx\": i, \"score\": s, \"label\": lbl} for (i,s,lbl) in candidates],\n",
+    "        \"candidates\": [{\"row_idx\": i, \"score\": s, \"label\": lbl} for (i,s,lbl) in candidates],\n",
+    "# \"rules\": [\n",
+    "        \"rules\": [\n",
+    "# \"If one candidate is clearly correct, return mode='ok' with row_idx.\",\n",
+    "            \"If one candidate is clearly correct, return mode='ok' with row_idx.\",\n",
+    "# \"If two are plausible, return mode='pick' with top 2 options.\"\n",
+    "            \"If two are plausible, return mode='pick' with top 2 options.\"\n",
+    "# ],\n",
+    "        ],\n",
+    "# \"output_schema\": {\"mode\":\"ok|pick\",\"row_idx\":\"int\",\"options\":[{\"row_idx\":\"int\",\"label\":\"string\"}]}\n",
+    "        \"output_schema\": {\"mode\":\"ok|pick\",\"row_idx\":\"int\",\"options\":[{\"row_idx\":\"int\",\"label\":\"string\"}]}\n",
+    "# }\n",
+    "    }\n",
+    "# return gpt_json(sys, payload, max_tokens=300)\n",
+    "    return gpt_json(sys, payload, max_tokens=300)\n",
+    "\n",
+    "# def resolve_device(user_text: str) -> Dict[str, Any]:\n",
+    "def resolve_device(user_text: str) -> Dict[str, Any]:\n",
+    "# q = norm_text(user_text)\n",
+    "    q = norm_text(user_text)\n",
+    "# exact_idxs = df_eos.index[df_eos[\"_norm_sku\"] == q].tolist()\n",
+    "    exact_idxs = df_eos.index[df_eos[\"_norm_sku\"] == q].tolist()\n",
+    "# if len(exact_idxs) == 1:\n",
+    "    if len(exact_idxs) == 1:\n",
+    "# return {\"mode\":\"ok\",\"row_idx\": int(exact_idxs[0])}\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": int(exact_idxs[0])}\n",
+    "# if len(exact_idxs) > 1:\n",
+    "    if len(exact_idxs) > 1:\n",
+    "# opts = [{\"row_idx\": int(i), \"label\": EOS_LABELS[int(i)]} for i in exact_idxs[:2]]\n",
+    "        opts = [{\"row_idx\": int(i), \"label\": EOS_LABELS[int(i)]} for i in exact_idxs[:2]]\n",
+    "# return {\"mode\":\"pick\",\"options\": opts}\n",
+    "        return {\"mode\":\"pick\",\"options\": opts}\n",
+    "\n",
+    "# cands = local_candidates(user_text, top_k=6)\n",
+    "    cands = local_candidates(user_text, top_k=6)\n",
+    "# if not cands:\n",
+    "    if not cands:\n",
+    "# return {\"mode\":\"not_found\"}\n",
+    "        return {\"mode\":\"not_found\"}\n",
+    "\n",
+    "# if cands[0][1] >= 95 and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= 8):\n",
+    "    if cands[0][1] >= 95 and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= 8):\n",
+    "# return {\"mode\":\"ok\",\"row_idx\": cands[0][0]}\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": cands[0][0]}\n",
+    "\n",
+    "# g = gpt_choose_device(user_text, cands)\n",
+    "    g = gpt_choose_device(user_text, cands)\n",
+    "# if g.get(\"mode\") == \"ok\" and isinstance(g.get(\"row_idx\"), int):\n",
+    "    if g.get(\"mode\") == \"ok\" and isinstance(g.get(\"row_idx\"), int):\n",
+    "# return {\"mode\":\"ok\",\"row_idx\": int(g[\"row_idx\"])}\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": int(g[\"row_idx\"])}\n",
+    "\n",
+    "# if g.get(\"mode\") == \"pick\":\n",
+    "    if g.get(\"mode\") == \"pick\":\n",
+    "# opts = g.get(\"options\", []) or []\n",
+    "        opts = g.get(\"options\", []) or []\n",
+    "# opts2 = [{\"row_idx\": int(o[\"row_idx\"]), \"label\": str(o[\"label\"])} for o in opts[:2] if \"row_idx\" in o]\n",
+    "        opts2 = [{\"row_idx\": int(o[\"row_idx\"]), \"label\": str(o[\"label\"])} for o in opts[:2] if \"row_idx\" in o]\n",
+    "# if opts2:\n",
+    "        if opts2:\n",
+    "# return {\"mode\":\"pick\",\"options\": opts2}\n",
+    "            return {\"mode\":\"pick\",\"options\": opts2}\n",
+    "\n",
+    "    # fallback\n",
+    "# if len(cands) > 1:\n",
+    "    if len(cands) > 1:\n",
+    "# return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]},{\"row_idx\":cands[1][0],\"label\":cands[1][2]}]}\n",
+    "        return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]},{\"row_idx\":cands[1][0],\"label\":cands[1][2]}]}\n",
+    "# return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]}]}\n",
+    "    return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]}]}\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Replacements — lifecycle CSV is source of truth\n",
+    "# Fix: always show 4G alternative if lifecycle suggests it (even if Active)\n",
+    "# ============================\n",
+    "# def _extract_model_token(text: str) -> str:\n",
+    "def _extract_model_token(text: str) -> str:\n",
+    "# s = _safe_str(text)\n",
+    "    s = _safe_str(text)\n",
+    "# if not s:\n",
+    "    if not s:\n",
+    "# return \"\"\n",
+    "        return \"\"\n",
+    "# parts = [p.strip() for p in s.split(\"|\") if p.strip()]\n",
+    "    parts = [p.strip() for p in s.split(\"|\") if p.strip()]\n",
+    "# candidates = parts[::-1] if parts else [s]\n",
+    "    candidates = parts[::-1] if parts else [s]\n",
+    "\n",
+    "# for cand in candidates:\n",
+    "    for cand in candidates:\n",
+    "        # Teltonika family\n",
+    "# m = re.search(r\"\\bRUT[A-Z]?\\d{2,4}\\b\", cand.upper())\n",
+    "        m = re.search(r\"\\bRUT[A-Z]?\\d{2,4}\\b\", cand.upper())\n",
+    "# if m:\n",
+    "        if m:\n",
+    "# return m.group(0).upper()\n",
+    "            return m.group(0).upper()\n",
+    "        # Digi IX-series\n",
+    "# m = re.search(r\"\\bIX\\d{2}\\b\", cand, flags=re.IGNORECASE)\n",
+    "        m = re.search(r\"\\bIX\\d{2}\\b\", cand, flags=re.IGNORECASE)\n",
+    "# if m:\n",
+    "        if m:\n",
+    "# return m.group(0).upper()\n",
+    "            return m.group(0).upper()\n",
+    "        # Cradlepoint R/E/S\n",
+    "# m = re.search(r\"\\b(R\\d{3,4}|E\\d{3,4}|S\\d{3,4})\\b\", cand, flags=re.IGNORECASE)\n",
+    "        m = re.search(r\"\\b(R\\d{3,4}|E\\d{3,4}|S\\d{3,4})\\b\", cand, flags=re.IGNORECASE)\n",
+    "# if m:\n",
+    "        if m:\n",
+    "# return m.group(0).upper()\n",
+    "            return m.group(0).upper()\n",
+    "        # Generic model token\n",
+    "# m = re.search(r\"\\b[A-Z]{1,6}\\d{2,4}[A-Z]?\\b\", cand.upper())\n",
+    "        m = re.search(r\"\\b[A-Z]{1,6}\\d{2,4}[A-Z]?\\b\", cand.upper())\n",
+    "# if m:\n",
+    "        if m:\n",
+    "# return m.group(0).upper()\n",
+    "            return m.group(0).upper()\n",
+    "\n",
+    "# return candidates[0][:60]\n",
+    "    return candidates[0][:60]\n",
+    "\n",
+    "# def _device_is_4g(life_row: pd.Series) -> bool:\n",
+    "def _device_is_4g(life_row: pd.Series) -> bool:\n",
+    "# t = norm_text(life_row.get(\"description\",\"\")) + \" \" + norm_text(life_row.get(\"notes\",\"\"))\n",
+    "    t = norm_text(life_row.get(\"description\",\"\")) + \" \" + norm_text(life_row.get(\"notes\",\"\"))\n",
+    "# return ((\"lte\" in t or \"4g\" in t) and (\"5g\" not in t and \"nr\" not in t))\n",
+    "    return ((\"lte\" in t or \"4g\" in t) and (\"5g\" not in t and \"nr\" not in t))\n",
+    "\n",
+    "# def _candidate_5g_models_from_lifecycle(manufacturer: str) -> List[str]:\n",
+    "def _candidate_5g_models_from_lifecycle(manufacturer: str) -> List[str]:\n",
+    "    # Pool within same manufacturer text (not just canon) to support Teltonika etc\n",
+    "# mfr = norm_text(manufacturer)\n",
+    "    mfr = norm_text(manufacturer)\n",
+    "# pool = df_eos[df_eos[\"manufacturer\"].astype(str).str.lower().eq(mfr)].copy() if \"manufacturer\" in df_eos.columns else df_eos.copy()\n",
+    "    pool = df_eos[df_eos[\"manufacturer\"].astype(str).str.lower().eq(mfr)].copy() if \"manufacturer\" in df_eos.columns else df_eos.copy()\n",
+    "# vals = pool[\"advanced_5g_option\"].tolist() if \"advanced_5g_option\" in pool.columns else []\n",
+    "    vals = pool[\"advanced_5g_option\"].tolist() if \"advanced_5g_option\" in pool.columns else []\n",
+    "# out, seen = [], set()\n",
+    "    out, seen = [], set()\n",
+    "# for v in vals:\n",
+    "    for v in vals:\n",
+    "# tok = _extract_model_token(v)\n",
+    "        tok = _extract_model_token(v)\n",
+    "# if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "        if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "# seen.add(tok); out.append(tok)\n",
+    "            seen.add(tok); out.append(tok)\n",
+    "# return out\n",
+    "    return out\n",
+    "\n",
+    "# def _candidate_4g_models_from_lifecycle(manufacturer: str) -> List[str]:\n",
+    "def _candidate_4g_models_from_lifecycle(manufacturer: str) -> List[str]:\n",
+    "# mfr = norm_text(manufacturer)\n",
+    "    mfr = norm_text(manufacturer)\n",
+    "# pool = df_eos[df_eos[\"manufacturer\"].astype(str).str.lower().eq(mfr)].copy() if \"manufacturer\" in df_eos.columns else df_eos.copy()\n",
+    "    pool = df_eos[df_eos[\"manufacturer\"].astype(str).str.lower().eq(mfr)].copy() if \"manufacturer\" in df_eos.columns else df_eos.copy()\n",
+    "# vals = pool[\"suggested_replacement\"].tolist() if \"suggested_replacement\" in pool.columns else []\n",
+    "    vals = pool[\"suggested_replacement\"].tolist() if \"suggested_replacement\" in pool.columns else []\n",
+    "# out, seen = [], set()\n",
+    "    out, seen = [], set()\n",
+    "# for v in vals:\n",
+    "    for v in vals:\n",
+    "# tok = _extract_model_token(v)\n",
+    "        tok = _extract_model_token(v)\n",
+    "# if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "        if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "# seen.add(tok); out.append(tok)\n",
+    "            seen.add(tok); out.append(tok)\n",
+    "# return out\n",
+    "    return out\n",
+    "\n",
+    "# def _gpt_pick_from_candidates(old_row: pd.Series, candidates: List[str], need: str) -> str:\n",
+    "def _gpt_pick_from_candidates(old_row: pd.Series, candidates: List[str], need: str) -> str:\n",
+    "# if client is None or not candidates:\n",
+    "    if client is None or not candidates:\n",
+    "# return \"\"\n",
+    "        return \"\"\n",
+    "# sys = \"Pick the best replacement model. Choose only from candidates. Return strict JSON only.\"\n",
+    "    sys = \"Pick the best replacement model. Choose only from candidates. Return strict JSON only.\"\n",
+    "# payload = {\n",
+    "    payload = {\n",
+    "# \"old_device\": {\n",
+    "        \"old_device\": {\n",
+    "# \"sku\": str(old_row.get(\"sku\",\"\")),\n",
+    "            \"sku\": str(old_row.get(\"sku\",\"\")),\n",
+    "# \"manufacturer\": str(old_row.get(\"manufacturer\",\"\")),\n",
+    "            \"manufacturer\": str(old_row.get(\"manufacturer\",\"\")),\n",
+    "# \"description\": str(old_row.get(\"description\",\"\")),\n",
+    "            \"description\": str(old_row.get(\"description\",\"\")),\n",
+    "# \"need\": need,\n",
+    "            \"need\": need,\n",
+    "# },\n",
+    "        },\n",
+    "# \"candidates\": candidates[:40],\n",
+    "        \"candidates\": candidates[:40],\n",
+    "# \"output_schema\": {\"choice\":\"string\"}\n",
+    "        \"output_schema\": {\"choice\":\"string\"}\n",
+    "# }\n",
+    "    }\n",
+    "# out = gpt_json(sys, payload, max_tokens=240) or {}\n",
+    "    out = gpt_json(sys, payload, max_tokens=240) or {}\n",
+    "# choice = str(out.get(\"choice\",\"\") or \"\").strip()\n",
+    "    choice = str(out.get(\"choice\",\"\") or \"\").strip()\n",
+    "# return choice if choice in candidates else \"\"\n",
+    "    return choice if choice in candidates else \"\"\n",
+    "\n",
+    "# def _fallback_5g_from_dec(canon_make: str) -> str:\n",
+    "def _fallback_5g_from_dec(canon_make: str) -> str:\n",
+    "# pool5 = df_dec[(df_dec[\"_canon_make\"] == canon_make) & (df_dec[\"_is5g\"] == True)]\n",
+    "    pool5 = df_dec[(df_dec[\"_canon_make\"] == canon_make) & (df_dec[\"_is5g\"] == True)]\n",
+    "# return str(pool5.iloc[0][\"Model\"]).strip() if not pool5.empty else \"\"\n",
+    "    return str(pool5.iloc[0][\"Model\"]).strip() if not pool5.empty else \"\"\n",
+    "\n",
+    "# def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, Any]:\n",
+    "def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, Any]:\n",
+    "# canon = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    canon = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "# manufacturer = str(life_row.get(\"manufacturer\",\"\") or \"\")\n",
+    "    manufacturer = str(life_row.get(\"manufacturer\",\"\") or \"\")\n",
+    "\n",
+    "# is_4g_device = _device_is_4g(life_row)\n",
+    "    is_4g_device = _device_is_4g(life_row)\n",
+    "# needs_4g_repl = is_4g_device and (status in {\"End of Sale\",\"End of Life\"})\n",
+    "    needs_4g_repl = is_4g_device and (status in {\"End of Sale\",\"End of Life\"})\n",
+    "# want_5g = is_4g_device or (status in {\"End of Sale\",\"End of Life\"})\n",
+    "    want_5g = is_4g_device or (status in {\"End of Sale\",\"End of Life\"})\n",
+    "\n",
+    "    # 4G alternative: ALWAYS if suggested_replacement exists for 4G devices\n",
+    "# repl_4g = \"Not applicable\"\n",
+    "    repl_4g = \"Not applicable\"\n",
+    "# if is_4g_device:\n",
+    "    if is_4g_device:\n",
+    "# repl_4g = _extract_model_token(_safe_str(life_row.get(\"suggested_replacement\",\"\")))\n",
+    "        repl_4g = _extract_model_token(_safe_str(life_row.get(\"suggested_replacement\",\"\")))\n",
+    "# if not repl_4g:\n",
+    "        if not repl_4g:\n",
+    "# cand4 = _candidate_4g_models_from_lifecycle(manufacturer)\n",
+    "            cand4 = _candidate_4g_models_from_lifecycle(manufacturer)\n",
+    "# repl_4g = _gpt_pick_from_candidates(life_row, cand4, \"4G alternative\") or (cand4[0] if cand4 else \"\")\n",
+    "            repl_4g = _gpt_pick_from_candidates(life_row, cand4, \"4G alternative\") or (cand4[0] if cand4 else \"\")\n",
+    "# if not repl_4g:\n",
+    "        if not repl_4g:\n",
+    "# repl_4g = \"Not applicable\"\n",
+    "            repl_4g = \"Not applicable\"\n",
+    "\n",
+    "    # 5G replacement: ALWAYS when want_5g is true\n",
+    "# repl_5g = \"Not applicable\"\n",
+    "    repl_5g = \"Not applicable\"\n",
+    "# if want_5g:\n",
+    "    if want_5g:\n",
+    "# repl_5g = _extract_model_token(_safe_str(life_row.get(\"advanced_5g_option\",\"\")))\n",
+    "        repl_5g = _extract_model_token(_safe_str(life_row.get(\"advanced_5g_option\",\"\")))\n",
+    "# if not repl_5g:\n",
+    "        if not repl_5g:\n",
+    "# cand5 = _candidate_5g_models_from_lifecycle(manufacturer)\n",
+    "            cand5 = _candidate_5g_models_from_lifecycle(manufacturer)\n",
+    "# repl_5g = _gpt_pick_from_candidates(life_row, cand5, \"5G replacement/upgrade\") or (cand5[0] if cand5 else \"\")\n",
+    "            repl_5g = _gpt_pick_from_candidates(life_row, cand5, \"5G replacement/upgrade\") or (cand5[0] if cand5 else \"\")\n",
+    "# if not repl_5g:\n",
+    "        if not repl_5g:\n",
+    "            # last resort: dec catalog fallback\n",
+    "# repl_5g = _fallback_5g_from_dec(canon)\n",
+    "            repl_5g = _fallback_5g_from_dec(canon)\n",
+    "\n",
+    "# if repl_5g.lower() == \"nan\":\n",
+    "    if repl_5g.lower() == \"nan\":\n",
+    "# repl_5g = \"\"\n",
+    "        repl_5g = \"\"\n",
+    "\n",
+    "# return {\n",
+    "    return {\n",
+    "# \"repl_4g\": repl_4g,\n",
+    "        \"repl_4g\": repl_4g,\n",
+    "# \"repl_5g\": repl_5g,\n",
+    "        \"repl_5g\": repl_5g,\n",
+    "# \"why\": \"Lifecycle replacements (GPT fallback when missing).\",\n",
+    "        \"why\": \"Lifecycle replacements (GPT fallback when missing).\",\n",
+    "# \"sources\": [\"lifecycle_csv\"] + ([\"gpt\"] if client else []) + ([\"dec_fallback\"] if (want_5g and not repl_5g) else []),\n",
+    "        \"sources\": [\"lifecycle_csv\"] + ([\"gpt\"] if client else []) + ([\"dec_fallback\"] if (want_5g and not repl_5g) else []),\n",
+    "# }\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Antennas (Parsec-only; family name extraction)\n",
+    "# ============================\n",
+    "# PARSEC_FAMILY_WORDS = {\n",
+    "PARSEC_FAMILY_WORDS = {\n",
+    "# \"chinook\",\"labrador\",\"boxer\",\"bloodhound\",\"husky\",\"beagle\",\"mastiff\",\"collie\",\n",
+    "    \"chinook\",\"labrador\",\"boxer\",\"bloodhound\",\"husky\",\"beagle\",\"mastiff\",\"collie\",\n",
+    "# \"shepherd\",\"belgian\",\"australian\",\"terrier\",\"pyrenees\"\n",
+    "    \"shepherd\",\"belgian\",\"australian\",\"terrier\",\"pyrenees\"\n",
+    "# }\n",
+    "}\n",
+    "# BAD_NAME_MARKERS = {\n",
+    "BAD_NAME_MARKERS = {\n",
+    "# \"customization\", \"standard connectors\", \"connectors\", \"features\", \"benefits\",\n",
+    "    \"customization\", \"standard connectors\", \"connectors\", \"features\", \"benefits\",\n",
+    "# \"specifications\", \"mechanical\", \"electrical\", \"mounting\", \"accessories\",\n",
+    "    \"specifications\", \"mechanical\", \"electrical\", \"mounting\", \"accessories\",\n",
+    "# \"description:\", \"standard sku\"\n",
+    "    \"description:\", \"standard sku\"\n",
+    "# }\n",
+    "}\n",
+    "\n",
+    "# def _clean_line(s: str) -> str:\n",
+    "def _clean_line(s: str) -> str:\n",
+    "# s = re.sub(r\"\\s+\", \" \", str(s or \"\").strip())\n",
+    "    s = re.sub(r\"\\s+\", \" \", str(s or \"\").strip())\n",
+    "# if re.fullmatch(r\"-[a-z0-9]+\", s.lower()):\n",
+    "    if re.fullmatch(r\"-[a-z0-9]+\", s.lower()):\n",
+    "# return \"\"\n",
+    "        return \"\"\n",
+    "# return s\n",
+    "    return s\n",
+    "\n",
+    "# def _is_bad_name_line(line: str) -> bool:\n",
+    "def _is_bad_name_line(line: str) -> bool:\n",
+    "# low = line.lower()\n",
+    "    low = line.lower()\n",
+    "# if any(m in low for m in BAD_NAME_MARKERS):\n",
+    "    if any(m in low for m in BAD_NAME_MARKERS):\n",
+    "# return True\n",
+    "        return True\n",
+    "# if re.search(r\"\\b-[a-z0-9]{1,4}\\b\", low) and len(low) <= 25:\n",
+    "    if re.search(r\"\\b-[a-z0-9]{1,4}\\b\", low) and len(low) <= 25:\n",
+    "# return True\n",
+    "        return True\n",
+    "# return False\n",
+    "    return False\n",
+    "\n",
+    "# def _family_from_line(line: str) -> str:\n",
+    "def _family_from_line(line: str) -> str:\n",
+    "# low = line.lower()\n",
+    "    low = line.lower()\n",
+    "# for fam in PARSEC_FAMILY_WORDS:\n",
+    "    for fam in PARSEC_FAMILY_WORDS:\n",
+    "# if fam in low:\n",
+    "        if fam in low:\n",
+    "# return fam.capitalize()\n",
+    "            return fam.capitalize()\n",
+    "# return \"\"\n",
+    "    return \"\"\n",
+    "\n",
+    "# def _parsec_name_from_card(card_text: str) -> str:\n",
+    "def _parsec_name_from_card(card_text: str) -> str:\n",
+    "# lines = [_clean_line(ln) for ln in str(card_text or \"\").splitlines()]\n",
+    "    lines = [_clean_line(ln) for ln in str(card_text or \"\").splitlines()]\n",
+    "# lines = [ln for ln in lines if ln]\n",
+    "    lines = [ln for ln in lines if ln]\n",
+    "\n",
+    "# for ln in lines:\n",
+    "    for ln in lines:\n",
+    "# if _is_bad_name_line(ln):\n",
+    "        if _is_bad_name_line(ln):\n",
+    "# continue\n",
+    "            continue\n",
+    "# fam = _family_from_line(ln)\n",
+    "        fam = _family_from_line(ln)\n",
+    "# if fam:\n",
+    "        if fam:\n",
+    "# return fam\n",
+    "            return fam\n",
+    "\n",
+    "    # fallback near SKU line\n",
+    "# sku_i = None\n",
+    "    sku_i = None\n",
+    "# for i, ln in enumerate(lines):\n",
+    "    for i, ln in enumerate(lines):\n",
+    "# if \"standard sku\" in ln.lower():\n",
+    "        if \"standard sku\" in ln.lower():\n",
+    "# sku_i = i\n",
+    "            sku_i = i\n",
+    "# break\n",
+    "            break\n",
+    "# if sku_i is not None:\n",
+    "    if sku_i is not None:\n",
+    "# window = lines[max(0, sku_i - 12):sku_i]\n",
+    "        window = lines[max(0, sku_i - 12):sku_i]\n",
+    "# for ln in reversed(window):\n",
+    "        for ln in reversed(window):\n",
+    "# if _is_bad_name_line(ln):\n",
+    "            if _is_bad_name_line(ln):\n",
+    "# continue\n",
+    "                continue\n",
+    "# if 3 <= len(ln) <= 40 and re.search(r\"[A-Za-z]\", ln):\n",
+    "            if 3 <= len(ln) <= 40 and re.search(r\"[A-Za-z]\", ln):\n",
+    "# return ln.split()[0].capitalize()\n",
+    "                return ln.split()[0].capitalize()\n",
+    "\n",
+    "# return \"Parsec antenna\"\n",
+    "    return \"Parsec antenna\"\n",
+    "\n",
+    "# def _parsec_part_from_card(t: str) -> str:\n",
+    "def _parsec_part_from_card(t: str) -> str:\n",
+    "# m = re.search(r\"Standard\\s+SKU:\\s*([A-Z0-9]+)\", t)\n",
+    "    m = re.search(r\"Standard\\s+SKU:\\s*([A-Z0-9]+)\", t)\n",
+    "# return m.group(1).strip() if m else \"\"\n",
+    "    return m.group(1).strip() if m else \"\"\n",
+    "\n",
+    "# def _parsec_desc_from_card(t: str) -> str:\n",
+    "def _parsec_desc_from_card(t: str) -> str:\n",
+    "# m = re.search(r\"Description:\\s*(.+?)(?:\\n|$)\", t, flags=re.IGNORECASE)\n",
+    "    m = re.search(r\"Description:\\s*(.+?)(?:\\n|$)\", t, flags=re.IGNORECASE)\n",
+    "# return re.sub(r\"\\s+\",\" \",m.group(1).strip())[:220] if m else \"\"\n",
+    "    return re.sub(r\"\\s+\",\" \",m.group(1).strip())[:220] if m else \"\"\n",
+    "\n",
+    "# def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:\n",
+    "def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:\n",
+    "# qv = embedder.encode([query], normalize_embeddings=True)\n",
+    "    qv = embedder.encode([query], normalize_embeddings=True)\n",
+    "# qv = np.asarray(qv, dtype=np.float32)\n",
+    "    qv = np.asarray(qv, dtype=np.float32)\n",
+    "# scores, ids = parsec_index.search(qv, top_k)\n",
+    "    scores, ids = parsec_index.search(qv, top_k)\n",
+    "# out = []\n",
+    "    out = []\n",
+    "# for sc, i in zip(scores[0].tolist(), ids[0].tolist()):\n",
+    "    for sc, i in zip(scores[0].tolist(), ids[0].tolist()):\n",
+    "# if 0 <= int(i) < len(parsec_cards):\n",
+    "        if 0 <= int(i) < len(parsec_cards):\n",
+    "# card = parsec_cards[int(i)]\n",
+    "            card = parsec_cards[int(i)]\n",
+    "# out.append({\n",
+    "            out.append({\n",
+    "# \"score\": float(sc),\n",
+    "                \"score\": float(sc),\n",
+    "# \"name\": _parsec_name_from_card(card),\n",
+    "                \"name\": _parsec_name_from_card(card),\n",
+    "# \"part_number\": _parsec_part_from_card(card),\n",
+    "                \"part_number\": _parsec_part_from_card(card),\n",
+    "# \"description\": _parsec_desc_from_card(card),\n",
+    "                \"description\": _parsec_desc_from_card(card),\n",
+    "# })\n",
+    "            })\n",
+    "# return out\n",
+    "    return out\n",
+    "\n",
+    "# def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, Any]:\n",
+    "def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, Any]:\n",
+    "# q_stationary = f\"{router_model} {tech} {mimo} omni stationary outdoor Parsec\"\n",
+    "    q_stationary = f\"{router_model} {tech} {mimo} omni stationary outdoor Parsec\"\n",
+    "# q_vehicle = f\"{router_model} {tech} {mimo} omni vehicle mobile Parsec\"\n",
+    "    q_vehicle = f\"{router_model} {tech} {mimo} omni vehicle mobile Parsec\"\n",
+    "# cand_stationary = parsec_retrieve(q_stationary, top_k=10)\n",
+    "    cand_stationary = parsec_retrieve(q_stationary, top_k=10)\n",
+    "# cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)\n",
+    "    cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)\n",
+    "\n",
+    "    # deterministic fallback if no GPT\n",
+    "# s = cand_stationary[0] if cand_stationary else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\"}\n",
+    "    s = cand_stationary[0] if cand_stationary else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\"}\n",
+    "# v = cand_vehicle[0] if cand_vehicle else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\"}\n",
+    "    v = cand_vehicle[0] if cand_vehicle else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\"}\n",
+    "# s.update({\"mimo\": mimo, \"why\": \"Stationary omni best match.\"})\n",
+    "    s.update({\"mimo\": mimo, \"why\": \"Stationary omni best match.\"})\n",
+    "# v.update({\"mimo\": mimo, \"why\": \"Vehicle omni best match.\"})\n",
+    "    v.update({\"mimo\": mimo, \"why\": \"Vehicle omni best match.\"})\n",
+    "# return {\"stationary_omni\": s, \"vehicle_omni\": v, \"sources\":[\"parsec_rag\"]}\n",
+    "    return {\"stationary_omni\": s, \"vehicle_omni\": v, \"sources\":[\"parsec_rag\"]}\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Feature table + GPT fill for missing fields\n",
+    "# ============================\n",
+    "# FEATURE_COLS = [\"Name\",\"Modem technology\",\"WiFi\",\"Ports\",\"Antennas\",\"Ruggedness\",\"Use case\"]\n",
+    "FEATURE_COLS = [\"Name\",\"Modem technology\",\"WiFi\",\"Ports\",\"Antennas\",\"Ruggedness\",\"Use case\"]\n",
+    "\n",
+    "# def dec_features_by_model(model: str, canon_make: str) -> Dict[str, str]:\n",
+    "def dec_features_by_model(model: str, canon_make: str) -> Dict[str, str]:\n",
+    "# if not model or model in {\"Not applicable\",\"Not listed\"}:\n",
+    "    if not model or model in {\"Not applicable\",\"Not listed\"}:\n",
+    "# return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "        return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "# pool = df_dec[df_dec[\"_canon_make\"] == canon_make].copy()\n",
+    "    pool = df_dec[df_dec[\"_canon_make\"] == canon_make].copy()\n",
+    "# if pool.empty:\n",
+    "    if pool.empty:\n",
+    "# return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "        return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "# hit = process.extractOne(norm_text(model), pool[\"_norm_model\"].tolist(), scorer=fuzz.WRatio)\n",
+    "    hit = process.extractOne(norm_text(model), pool[\"_norm_model\"].tolist(), scorer=fuzz.WRatio)\n",
+    "# if not hit or hit[1] < MATCH_OK:\n",
+    "    if not hit or hit[1] < MATCH_OK:\n",
+    "# return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "        return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "# r = pool.iloc[int(hit[2])]\n",
+    "    r = pool.iloc[int(hit[2])]\n",
+    "# ports = f\"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}\"\n",
+    "    ports = f\"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}\"\n",
+    "# return {\n",
+    "    return {\n",
+    "# \"Name\": str(r.get(\"Model\",\"\")),\n",
+    "        \"Name\": str(r.get(\"Model\",\"\")),\n",
+    "# \"Modem technology\": str(r.get(\"Modem Type\",\"\")),\n",
+    "        \"Modem technology\": str(r.get(\"Modem Type\",\"\")),\n",
+    "# \"WiFi\": str(r.get(\"WiFi type\",\"\")),\n",
+    "        \"WiFi\": str(r.get(\"WiFi type\",\"\")),\n",
+    "# \"Ports\": ports,\n",
+    "        \"Ports\": ports,\n",
+    "# \"Antennas\": str(r.get(\"Antennas (internal/external/both)\",\"\")),\n",
+    "        \"Antennas\": str(r.get(\"Antennas (internal/external/both)\",\"\")),\n",
+    "# \"Ruggedness\": str(r.get(\"Ruggedization\",\"\")),\n",
+    "        \"Ruggedness\": str(r.get(\"Ruggedization\",\"\")),\n",
+    "# \"Use case\": str(r.get(\"Primary use case\",\"\")),\n",
+    "        \"Use case\": str(r.get(\"Primary use case\",\"\")),\n",
+    "# }\n",
+    "    }\n",
+    "\n",
+    "# def gpt_fill_features(device_label: str, feats: Dict[str,str], context: str) -> Dict[str,str]:\n",
+    "def gpt_fill_features(device_label: str, feats: Dict[str,str], context: str) -> Dict[str,str]:\n",
+    "# missing = [k for k,v in feats.items() if (not v) or v.strip().lower() in {\"not listed\",\"nan\"}]\n",
+    "    missing = [k for k,v in feats.items() if (not v) or v.strip().lower() in {\"not listed\",\"nan\"}]\n",
+    "# if client is None or not missing:\n",
+    "    if client is None or not missing:\n",
+    "# return feats\n",
+    "        return feats\n",
+    "# sys = \"Fill missing router feature fields. Return strict JSON only.\"\n",
+    "    sys = \"Fill missing router feature fields. Return strict JSON only.\"\n",
+    "# payload = {\n",
+    "    payload = {\n",
+    "# \"device\": device_label,\n",
+    "        \"device\": device_label,\n",
+    "# \"known\": feats,\n",
+    "        \"known\": feats,\n",
+    "# \"context\": context[:2000],\n",
+    "        \"context\": context[:2000],\n",
+    "# \"fill_only\": missing,\n",
+    "        \"fill_only\": missing,\n",
+    "# \"rules\": [\"Fill only requested fields. Best guess if needed. Return JSON only.\"],\n",
+    "        \"rules\": [\"Fill only requested fields. Best guess if needed. Return JSON only.\"],\n",
+    "# \"output_schema\": {k:\"string\" for k in missing}\n",
+    "        \"output_schema\": {k:\"string\" for k in missing}\n",
+    "# }\n",
+    "    }\n",
+    "# out = gpt_json(sys, payload, max_tokens=350) or {}\n",
+    "    out = gpt_json(sys, payload, max_tokens=350) or {}\n",
+    "# for k in missing:\n",
+    "    for k in missing:\n",
+    "# v = str(out.get(k,\"\") or \"\").strip()\n",
+    "        v = str(out.get(k,\"\") or \"\").strip()\n",
+    "# if v:\n",
+    "        if v:\n",
+    "# feats[k] = v\n",
+    "            feats[k] = v\n",
+    "# return feats\n",
+    "    return feats\n",
+    "\n",
+    "# def current_features_guess(life_row: pd.Series) -> Dict[str,str]:\n",
+    "def current_features_guess(life_row: pd.Series) -> Dict[str,str]:\n",
+    "# sku = str(life_row.get(\"sku\",\"\") or \"\").strip()\n",
+    "    sku = str(life_row.get(\"sku\",\"\") or \"\").strip()\n",
+    "# desc = str(life_row.get(\"description\",\"\") or \"\").strip()\n",
+    "    desc = str(life_row.get(\"description\",\"\") or \"\").strip()\n",
+    "# notes = str(life_row.get(\"notes\",\"\") or \"\").strip()\n",
+    "    notes = str(life_row.get(\"notes\",\"\") or \"\").strip()\n",
+    "# base = {\n",
+    "    base = {\n",
+    "# \"Name\": sku,\n",
+    "        \"Name\": sku,\n",
+    "# \"Modem technology\": \"4G\" if _device_is_4g(life_row) else (\"5G\" if (\"5g\" in (desc+notes).lower() or \"nr\" in (desc+notes).lower()) else \"Not listed\"),\n",
+    "        \"Modem technology\": \"4G\" if _device_is_4g(life_row) else (\"5G\" if (\"5g\" in (desc+notes).lower() or \"nr\" in (desc+notes).lower()) else \"Not listed\"),\n",
+    "# \"WiFi\": \"Not listed\",\n",
+    "        \"WiFi\": \"Not listed\",\n",
+    "# \"Ports\": \"Not listed\",\n",
+    "        \"Ports\": \"Not listed\",\n",
+    "# \"Antennas\": \"Not listed\",\n",
+    "        \"Antennas\": \"Not listed\",\n",
+    "# \"Ruggedness\": \"Not listed\",\n",
+    "        \"Ruggedness\": \"Not listed\",\n",
+    "# \"Use case\": \"Not listed\",\n",
+    "        \"Use case\": \"Not listed\",\n",
+    "# }\n",
+    "    }\n",
+    "# return gpt_fill_features(\"Current device\", base, f\"{desc}\\n{notes}\")\n",
+    "    return gpt_fill_features(\"Current device\", base, f\"{desc}\\n{notes}\")\n",
+    "\n",
+    "# def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str]) -> str:\n",
+    "def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str]) -> str:\n",
+    "# cols = [\"Device\", \"Modem technology\", \"WiFi\", \"Ports\", \"Antennas\", \"Ruggedness\", \"Use case\"]\n",
+    "    cols = [\"Device\", \"Modem technology\", \"WiFi\", \"Ports\", \"Antennas\", \"Ruggedness\", \"Use case\"]\n",
+    "# header = \"| \" + \" | \".join(cols) + \" |\"\n",
+    "    header = \"| \" + \" | \".join(cols) + \" |\"\n",
+    "# sep = \"| \" + \" | \".join([\"---\"]*len(cols)) + \" |\"\n",
+    "    sep = \"| \" + \" | \".join([\"---\"]*len(cols)) + \" |\"\n",
+    "# def row(name: str, feats: Dict[str,str]) -> str:\n",
+    "    def row(name: str, feats: Dict[str,str]) -> str:\n",
+    "# return \"| \" + \" | \".join([\n",
+    "        return \"| \" + \" | \".join([\n",
+    "# name,\n",
+    "            name,\n",
+    "# feats.get(\"Modem technology\",\"Not listed\"),\n",
+    "            feats.get(\"Modem technology\",\"Not listed\"),\n",
+    "# feats.get(\"WiFi\",\"Not listed\"),\n",
+    "            feats.get(\"WiFi\",\"Not listed\"),\n",
+    "# feats.get(\"Ports\",\"Not listed\"),\n",
+    "            feats.get(\"Ports\",\"Not listed\"),\n",
+    "# feats.get(\"Antennas\",\"Not listed\"),\n",
+    "            feats.get(\"Antennas\",\"Not listed\"),\n",
+    "# feats.get(\"Ruggedness\",\"Not listed\"),\n",
+    "            feats.get(\"Ruggedness\",\"Not listed\"),\n",
+    "# feats.get(\"Use case\",\"Not listed\"),\n",
+    "            feats.get(\"Use case\",\"Not listed\"),\n",
+    "# ]) + \" |\"\n",
+    "        ]) + \" |\"\n",
+    "# return \"\\n\".join([header, sep, row(\"Current\", cur), row(\"4G alternative\", r4), row(\"5G replacement\", r5)])\n",
+    "    return \"\\n\".join([header, sep, row(\"Current\", cur), row(\"4G alternative\", r4), row(\"5G replacement\", r5)])\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Output + Gradio\n",
+    "# ============================\n",
+    "# def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:\n",
+    "def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:\n",
+    "# canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "# current_name = f\"{life_row.get('sku','')} — {life_row.get('description','')}\".strip(\" —\")\n",
+    "    current_name = f\"{life_row.get('sku','')} — {life_row.get('description','')}\".strip(\" —\")\n",
+    "\n",
+    "# st = ant.get(\"stationary_omni\", {})\n",
+    "    st = ant.get(\"stationary_omni\", {})\n",
+    "# vh = ant.get(\"vehicle_omni\", {})\n",
+    "    vh = ant.get(\"vehicle_omni\", {})\n",
+    "\n",
+    "# cur_feats = current_features_guess(life_row)\n",
+    "    cur_feats = current_features_guess(life_row)\n",
+    "# r4_feats = dec_features_by_model(repl.get(\"repl_4g\",\"\"), canon_make)\n",
+    "    r4_feats = dec_features_by_model(repl.get(\"repl_4g\",\"\"), canon_make)\n",
+    "# r5_feats = dec_features_by_model(repl.get(\"repl_5g\",\"\"), canon_make)\n",
+    "    r5_feats = dec_features_by_model(repl.get(\"repl_5g\",\"\"), canon_make)\n",
+    "\n",
+    "    # If dec doesn't know the model, ask GPT to fill missing cells (best guess)\n",
+    "# if client is not None:\n",
+    "    if client is not None:\n",
+    "# r4_feats = gpt_fill_features(\"4G alternative\", r4_feats, f\"Model: {repl.get('repl_4g','')}\\nMake: {canon_make}\")\n",
+    "        r4_feats = gpt_fill_features(\"4G alternative\", r4_feats, f\"Model: {repl.get('repl_4g','')}\\nMake: {canon_make}\")\n",
+    "# r5_feats = gpt_fill_features(\"5G replacement\", r5_feats, f\"Model: {repl.get('repl_5g','')}\\nMake: {canon_make}\")\n",
+    "        r5_feats = gpt_fill_features(\"5G replacement\", r5_feats, f\"Model: {repl.get('repl_5g','')}\\nMake: {canon_make}\")\n",
+    "\n",
+    "# table_md = build_features_table(cur_feats, r4_feats, r5_feats)\n",
+    "    table_md = build_features_table(cur_feats, r4_feats, r5_feats)\n",
+    "\n",
+    "# lines = []\n",
+    "    lines = []\n",
+    "# lines.append(f\"1. Current device: **{current_name}**\")\n",
+    "    lines.append(f\"1. Current device: **{current_name}**\")\n",
+    "# lines.append(f\"2. Status: **{status}**\")\n",
+    "    lines.append(f\"2. Status: **{status}**\")\n",
+    "# lines.append(f\"3. End of Sale date: **{eos}**\")\n",
+    "    lines.append(f\"3. End of Sale date: **{eos}**\")\n",
+    "# lines.append(f\"4. End of Life date: **{eol}**\")\n",
+    "    lines.append(f\"4. End of Life date: **{eol}**\")\n",
+    "# lines.append(f\"5. 4G alternative (lifecycle): **{repl.get('repl_4g','Not applicable')}**\")\n",
+    "    lines.append(f\"5. 4G alternative (lifecycle): **{repl.get('repl_4g','Not applicable')}**\")\n",
+    "# lines.append(f\"6. 5G replacement (lifecycle): **{repl.get('repl_5g','Not listed')}**\")\n",
+    "    lines.append(f\"6. 5G replacement (lifecycle): **{repl.get('repl_5g','Not listed')}**\")\n",
+    "# lines.append(\"7. Antenna options (Parsec-only):\")\n",
+    "    lines.append(\"7. Antenna options (Parsec-only):\")\n",
+    "# lines.append(f\"   - Stationary (Omni): **{st.get('name','')}** (Part #: {st.get('part_number','')}) — {st.get('description','')} — MIMO: {st.get('mimo','')} — {\n",
+    "    lines.append(f\"   - Stationary (Omni): **{st.get('name','')}** (Part #: {st.get('part_number','')}) — {st.get('description','')} — MIMO: {st.get('mimo','')} — {st.get('why','')}\")\n",
+    "# lines.append(f\"   - Vehicle (Omni): **{vh.get('name','')}** (Part #: {vh.get('part_number','')}) — {vh.get('description','')} — MIMO: {vh.get('mimo','')} — {vh.\n",
+    "    lines.append(f\"   - Vehicle (Omni): **{vh.get('name','')}** (Part #: {vh.get('part_number','')}) — {vh.get('description','')} — MIMO: {vh.get('mimo','')} — {vh.get('why','')}\")\n",
+    "# lines.append(\"8. Recommended features table:\")\n",
+    "    lines.append(\"8. Recommended features table:\")\n",
+    "# lines.append(table_md)\n",
+    "    lines.append(table_md)\n",
+    "# lines.append(\"\\nSources (debug):\")\n",
+    "    lines.append(\"\\nSources (debug):\")\n",
+    "# for s in repl.get(\"sources\", []) if isinstance(repl.get(\"sources\"), list) else []:\n",
+    "    for s in repl.get(\"sources\", []) if isinstance(repl.get(\"sources\"), list) else []:\n",
+    "# lines.append(f\"- {s}\")\n",
+    "        lines.append(f\"- {s}\")\n",
+    "# lines.append(\"- ParsecCatalog.pdf (local RAG)\")\n",
+    "    lines.append(\"- ParsecCatalog.pdf (local RAG)\")\n",
+    "# lines.append(\"- routers_eos_eol_by_sku.csv (replacements)\")\n",
+    "    lines.append(\"- routers_eos_eol_by_sku.csv (replacements)\")\n",
+    "# lines.append(\"- dec2025routers.csv (features)\")\n",
+    "    lines.append(\"- dec2025routers.csv (features)\")\n",
+    "# return \"\\n\".join(lines)\n",
+    "    return \"\\n\".join(lines)\n",
+    "\n",
+    "# def run_lookup(user_text: str, st: Dict[str,Any]):\n",
+    "def run_lookup(user_text: str, st: Dict[str,Any]):\n",
+    "# user_text = str(user_text or \"\").strip()\n",
+    "    user_text = str(user_text or \"\").strip()\n",
+    "# if not user_text:\n",
+    "    if not user_text:\n",
+    "# return \"Enter a router SKU/model.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "        return \"Enter a router SKU/model.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "# res = resolve_device(user_text)\n",
+    "    res = resolve_device(user_text)\n",
+    "# if res.get(\"mode\") == \"pick\":\n",
+    "    if res.get(\"mode\") == \"pick\":\n",
+    "# opts = res.get(\"options\", [])\n",
+    "        opts = res.get(\"options\", [])\n",
+    "# choices = [o[\"label\"] for o in opts]\n",
+    "        choices = [o[\"label\"] for o in opts]\n",
+    "# st2 = {\"mode\":\"pick\",\"options\": opts}\n",
+    "        st2 = {\"mode\":\"pick\",\"options\": opts}\n",
+    "# return \"Did you mean A or B? Pick one, then click Use selection.\", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2\n",
+    "        return \"Did you mean A or B? Pick one, then click Use selection.\", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2\n",
+    "\n",
+    "# if res.get(\"mode\") != \"ok\":\n",
+    "    if res.get(\"mode\") != \"ok\":\n",
+    "# return \"Not found.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "        return \"Not found.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "# life_row = df_eos.iloc[int(res[\"row_idx\"])]\n",
+    "    life_row = df_eos.iloc[int(res[\"row_idx\"])]\n",
+    "# eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "    eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "\n",
+    "# repl = pick_replacements_lifecycle(life_row, status)\n",
+    "    repl = pick_replacements_lifecycle(life_row, status)\n",
+    "\n",
+    "# tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") not in {\"Not applicable\",\"Not listed\"} else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "    tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") not in {\"Not applicable\",\"Not listed\"} else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "# mimo_guess = \"4x4\" if tech == \"5G\" else \"2x2\"\n",
+    "    mimo_guess = \"4x4\" if tech == \"5G\" else \"2x2\"\n",
+    "# ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo_guess)\n",
+    "    ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo_guess)\n",
+    "\n",
+    "# return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}\n",
+    "    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "# def use_selection(selected_label: str, st: Dict[str,Any]):\n",
+    "def use_selection(selected_label: str, st: Dict[str,Any]):\n",
+    "# if not st or st.get(\"mode\") != \"pick\":\n",
+    "    if not st or st.get(\"mode\") != \"pick\":\n",
+    "# return \"Run a search first.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "        return \"Run a search first.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "# if not selected_label:\n",
+    "    if not selected_label:\n",
+    "# return \"Pick A or B first.\", gr.update(visible=True), gr.update(visible=True), st\n",
+    "        return \"Pick A or B first.\", gr.update(visible=True), gr.update(visible=True), st\n",
+    "\n",
+    "# chosen_row = None\n",
+    "    chosen_row = None\n",
+    "# for o in st.get(\"options\", []):\n",
+    "    for o in st.get(\"options\", []):\n",
+    "# if o.get(\"label\") == selected_label:\n",
+    "        if o.get(\"label\") == selected_label:\n",
+    "# chosen_row = int(o[\"row_idx\"])\n",
+    "            chosen_row = int(o[\"row_idx\"])\n",
+    "# break\n",
+    "            break\n",
+    "# if chosen_row is None:\n",
+    "    if chosen_row is None:\n",
+    "# return \"Pick a valid option.\", gr.update(visible=True), gr.update(visible=True), st\n",
+    "        return \"Pick a valid option.\", gr.update(visible=True), gr.update(visible=True), st\n",
+    "\n",
+    "# life_row = df_eos.iloc[int(chosen_row)]\n",
+    "    life_row = df_eos.iloc[int(chosen_row)]\n",
+    "# eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "    eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "# repl = pick_replacements_lifecycle(life_row, status)\n",
+    "    repl = pick_replacements_lifecycle(life_row, status)\n",
+    "# tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") not in {\"Not applicable\",\"Not listed\"} else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "    tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") not in {\"Not applicable\",\"Not listed\"} else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "# mimo_guess = \"4x4\" if tech == \"5G\" else \"2x2\"\n",
+    "    mimo_guess = \"4x4\" if tech == \"5G\" else \"2x2\"\n",
+    "# ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo_guess)\n",
+    "    ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo_guess)\n",
+    "\n",
+    "# return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}\n",
+    "    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "# with gr.Blocks(title=\"Only-Routers\") as demo:\n",
+    "with gr.Blocks(title=\"Only-Routers\") as demo:\n",
+    "# gr.Markdown(\"## Only-Routers\\nEnter a router SKU/model. If ambiguous, you’ll get A/B choices.\")\n",
+    "    gr.Markdown(\"## Only-Routers\\nEnter a router SKU/model. If ambiguous, you’ll get A/B choices.\")\n",
+    "# user_text = gr.Textbox(label=\"Router SKU or model\", placeholder=\"Examples: IBR650B, AER1600, ES450, WR21, RUT240\", lines=1)\n",
+    "    user_text = gr.Textbox(label=\"Router SKU or model\", placeholder=\"Examples: IBR650B, AER1600, ES450, WR21, RUT240\", lines=1)\n",
+    "# st = gr.State({})\n",
+    "    st = gr.State({})\n",
+    "\n",
+    "# check_btn = gr.Button(\"Check\", variant=\"primary\")\n",
+    "    check_btn = gr.Button(\"Check\", variant=\"primary\")\n",
+    "# pick_dd = gr.Dropdown(label=\"Pick A or B\", choices=[], visible=False)\n",
+    "    pick_dd = gr.Dropdown(label=\"Pick A or B\", choices=[], visible=False)\n",
+    "# use_btn = gr.Button(\"Use selection\", visible=False)\n",
+    "    use_btn = gr.Button(\"Use selection\", visible=False)\n",
+    "\n",
+    "# output_md = gr.Markdown()\n",
+    "    output_md = gr.Markdown()\n",
+    "\n",
+    "# check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st])\n",
+    "    check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st])\n",
+    "# use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st])\n",
+    "    use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st])\n",
+    "\n",
+    "# demo.launch()\n",
+    "demo.launch()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

only-routers_ai_poc_v4_8.ipynb

@@ -0,0 +1,944 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "01ada72b",
+   "metadata": {},
+   "source": [
+    "# Only-Routers (v4.8)\n",
+    "\n",
+    "Notebook mirror of the Space `app.py`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9dbcb826",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "import json\n",
+    "import math\n",
+    "import hashlib\n",
+    "from dataclasses import dataclass\n",
+    "from datetime import datetime, date\n",
+    "from typing import Dict, List, Optional, Tuple, Any\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "import fitz  # PyMuPDF\n",
+    "import faiss\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "from rapidfuzz import fuzz, process\n",
+    "\n",
+    "import gradio as gr\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Settings\n",
+    "# ============================\n",
+    "TODAY = date(2026, 1, 18)\n",
+    "OPENAI_MODEL = \"gpt-5.2\"\n",
+    "OPENAI_REASONING = {\"effort\": \"high\"}\n",
+    "\n",
+    "MATCH_OK = 80\n",
+    "EMBED_MODEL_NAME = \"sentence-transformers/all-MiniLM-L6-v2\"\n",
+    "\n",
+    "PARSEC_CONTEXT_BEFORE = 900\n",
+    "PARSEC_CONTEXT_AFTER = 1600\n",
+    "\n",
+    "CACHE_DIR = os.path.join(os.getcwd(), \".onlyrouters_cache\")\n",
+    "os.makedirs(CACHE_DIR, exist_ok=True)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# OpenAI client (HF Space secret: OPENAI_API_KEY)\n",
+    "# ============================\n",
+    "API_KEY = os.getenv(\"OPENAI_API_KEY\", \"\").strip()\n",
+    "client = OpenAI(api_key=API_KEY) if API_KEY else None\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Utilities\n",
+    "# ============================\n",
+    "def norm_text(s: Any) -> str:\n",
+    "    try:\n",
+    "        if s is None or (isinstance(s, float) and math.isnan(s)) or pd.isna(s):\n",
+    "            return \"\"\n",
+    "    except Exception:\n",
+    "        pass\n",
+    "    s = str(s).strip().lower()\n",
+    "    s = re.sub(r\"[^a-z0-9\\s\\-\\/]\", \" \", s)\n",
+    "    s = re.sub(r\"\\s+\", \" \", s).strip()\n",
+    "    return s\n",
+    "\n",
+    "def _safe_str(v: Any) -> str:\n",
+    "    if v is None or (isinstance(v, float) and pd.isna(v)) or pd.isna(v):\n",
+    "        return \"\"\n",
+    "    return str(v).strip()\n",
+    "\n",
+    "def _is_5g(modem_type: Any) -> bool:\n",
+    "    s = norm_text(modem_type)\n",
+    "    return (\"5g\" in s) or (\"nr\" in s)\n",
+    "\n",
+    "def _json_load_safe(s: str) -> Dict[str, Any]:\n",
+    "    try:\n",
+    "        return json.loads(s)\n",
+    "    except Exception:\n",
+    "        return {}\n",
+    "\n",
+    "def gpt_json(system: str, payload: Dict[str, Any], max_tokens: int = 700) -> Dict[str, Any]:\n",
+    "    if client is None:\n",
+    "        return {}\n",
+    "    resp = client.responses.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        reasoning=OPENAI_REASONING,\n",
+    "        input=[\n",
+    "            {\"role\": \"system\", \"content\": system},\n",
+    "            {\"role\": \"user\", \"content\": json.dumps(payload)},\n",
+    "        ],\n",
+    "        max_output_tokens=max_tokens,\n",
+    "    )\n",
+    "    return _json_load_safe(getattr(resp, \"output_text\", \"\") or \"\")\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Load data files (must exist in repo)\n",
+    "# ============================\n",
+    "EOS_PATH = \"routers_eos_eol_by_sku.csv\"\n",
+    "DEC_PATH = \"dec2025routers.csv\"\n",
+    "PARSEC_PDF = \"ParsecCatalog.pdf\"\n",
+    "\n",
+    "if not os.path.exists(EOS_PATH):\n",
+    "    raise FileNotFoundError(f\"Missing {EOS_PATH} in repo.\")\n",
+    "if not os.path.exists(DEC_PATH):\n",
+    "    raise FileNotFoundError(f\"Missing {DEC_PATH} in repo.\")\n",
+    "if not os.path.exists(PARSEC_PDF):\n",
+    "    raise FileNotFoundError(f\"Missing {PARSEC_PDF} in repo.\")\n",
+    "\n",
+    "df_eos = pd.read_csv(EOS_PATH).copy()\n",
+    "df_dec = pd.read_csv(DEC_PATH).copy()\n",
+    "\n",
+    "# Region filter: keep USA / North America / blank / not specified\n",
+    "def _region_ok(x: Any) -> bool:\n",
+    "    s = str(x or \"\").strip().lower()\n",
+    "    if not s:\n",
+    "        return True\n",
+    "    if \"not specified\" in s:\n",
+    "        return True\n",
+    "    if \"north america\" in s:\n",
+    "        return True\n",
+    "    if re.search(r\"\\busa\\b\", s):\n",
+    "        return True\n",
+    "    if re.search(r\"\\bunited\\s+states\\b\", s):\n",
+    "        return True\n",
+    "    if re.search(r\"\\bu\\.?s\\.?\\b\", s):\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "if \"region\" in df_eos.columns:\n",
+    "    df_eos = df_eos[df_eos[\"region\"].apply(_region_ok)].reset_index(drop=True)\n",
+    "\n",
+    "# Optional \"Device Type\"\n",
+    "device_type_col = None\n",
+    "for c in df_eos.columns:\n",
+    "    if norm_text(c) == \"device type\":\n",
+    "        device_type_col = c\n",
+    "        break\n",
+    "\n",
+    "# Maker mapping (includes Teltonika)\n",
+    "CANON_MAKER = {\n",
+    "    \"CRADLEPOINT\": {\"cradlepoint\", \"ericsson\", \"ericsson enterprise wireless\"},\n",
+    "    \"SIERRA\": {\"sierra\", \"sierra wireless\", \"semtech\", \"airlink\"},\n",
+    "    \"FEENEY\": {\"feeney\", \"feeney wireless\", \"inseego\"},\n",
+    "    \"DIGI\": {\"digi\", \"accelerated\", \"accelerated concepts\"},\n",
+    "    \"CISCO_MERAKI\": {\"meraki\", \"cisco meraki\"},\n",
+    "    \"CISCO\": {\"cisco\"},\n",
+    "    \"TELTONIKA\": {\"teltonika\"},\n",
+    "}\n",
+    "\n",
+    "def canon_maker_from_text(s: Any) -> str:\n",
+    "    t = norm_text(s)\n",
+    "    for canon, terms in CANON_MAKER.items():\n",
+    "        for term in terms:\n",
+    "            if term in t:\n",
+    "                return canon\n",
+    "    return \"UNKNOWN\"\n",
+    "\n",
+    "df_eos[\"_canon_make\"] = df_eos[\"manufacturer\"].apply(canon_maker_from_text) if \"manufacturer\" in df_eos.columns else \"UNKNOWN\"\n",
+    "df_eos[\"_norm_sku\"] = df_eos[\"sku\"].apply(norm_text) if \"sku\" in df_eos.columns else \"\"\n",
+    "df_eos[\"_norm_desc\"] = df_eos[\"description\"].apply(norm_text) if \"description\" in df_eos.columns else \"\"\n",
+    "df_eos[\"_norm_notes\"] = df_eos[\"notes\"].apply(norm_text) if \"notes\" in df_eos.columns else \"\"\n",
+    "\n",
+    "df_dec[\"_canon_make\"] = df_dec[\"Make\"].apply(canon_maker_from_text) if \"Make\" in df_dec.columns else \"UNKNOWN\"\n",
+    "df_dec[\"_norm_model\"] = df_dec[\"Model\"].apply(norm_text) if \"Model\" in df_dec.columns else \"\"\n",
+    "df_dec[\"_is5g\"] = df_dec[\"Modem Type\"].apply(_is_5g) if \"Modem Type\" in df_dec.columns else False\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Date helpers\n",
+    "# ============================\n",
+    "@dataclass\n",
+    "class ParsedDate:\n",
+    "    raw: str\n",
+    "    kind: str\n",
+    "    value: Optional[date]\n",
+    "\n",
+    "def parse_date_field(x: Any) -> ParsedDate:\n",
+    "    raw = str(x or \"\").strip()\n",
+    "    if not raw:\n",
+    "        return ParsedDate(raw=\"\", kind=\"missing\", value=None)\n",
+    "\n",
+    "    if re.fullmatch(r\"\\d{4}\", raw):\n",
+    "        y = int(raw)\n",
+    "        if y == TODAY.year:\n",
+    "            return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "        if y < TODAY.year:\n",
+    "            return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "        return ParsedDate(raw=raw, kind=\"year\", value=date(y, 12, 31))\n",
+    "\n",
+    "    if re.fullmatch(r\"\\d{4}-\\d{2}\", raw):\n",
+    "        try:\n",
+    "            y, m = raw.split(\"-\")\n",
+    "            return ParsedDate(raw=raw, kind=\"year_month\", value=date(int(y), int(m), 1))\n",
+    "        except Exception:\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "    if re.fullmatch(r\"\\d{4}-\\d{2}-\\d{2}\", raw):\n",
+    "        try:\n",
+    "            dt = datetime.strptime(raw, \"%Y-%m-%d\").date()\n",
+    "            return ParsedDate(raw=raw, kind=\"full\", value=dt)\n",
+    "        except Exception:\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "    return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "def display_date(parsed: ParsedDate) -> str:\n",
+    "    if parsed.kind == \"missing\":\n",
+    "        return \"Not listed\"\n",
+    "    if parsed.kind == \"bad\":\n",
+    "        return parsed.raw or \"Not listed\"\n",
+    "    return parsed.raw\n",
+    "\n",
+    "def status_from_eos_eol(eos: ParsedDate, eol: ParsedDate) -> str:\n",
+    "    if eos.value is None and eol.value is None:\n",
+    "        return \"Unknown\"\n",
+    "    if eol.value is not None and eol.value <= TODAY:\n",
+    "        return \"End of Life\"\n",
+    "    if eos.value is not None and eos.value <= TODAY:\n",
+    "        return \"End of Sale\"\n",
+    "    return \"Active\"\n",
+    "\n",
+    "def row_to_dates_and_status(life_row: pd.Series) -> Tuple[str, str, str]:\n",
+    "    eos = parse_date_field(life_row.get(\"end_of_sale\"))\n",
+    "    eol = parse_date_field(life_row.get(\"end_of_life\"))\n",
+    "    return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Embeddings + Parsec index\n",
+    "# ============================\n",
+    "embedder = SentenceTransformer(EMBED_MODEL_NAME)\n",
+    "\n",
+    "def extract_pdf_text_pages(path: str) -> List[str]:\n",
+    "    doc = fitz.open(path)\n",
+    "    return [doc[i].get_text(\"text\") for i in range(len(doc))]\n",
+    "\n",
+    "def build_parsec_cards(pages: List[str]) -> List[str]:\n",
+    "    cards = []\n",
+    "    for p in pages:\n",
+    "        for m in re.finditer(r\"Standard\\s+SKU:\", p):\n",
+    "            start = max(0, m.start() - PARSEC_CONTEXT_BEFORE)\n",
+    "            end = min(len(p), m.start() + PARSEC_CONTEXT_AFTER)\n",
+    "            c = p[start:end].strip()\n",
+    "            if len(c) >= 200:\n",
+    "                cards.append(c)\n",
+    "    out, seen = [], set()\n",
+    "    for c in cards:\n",
+    "        h = hashlib.sha1(c.encode(\"utf-8\")).hexdigest()\n",
+    "        if h not in seen:\n",
+    "            seen.add(h); out.append(c)\n",
+    "    return out\n",
+    "\n",
+    "parsec_cards = build_parsec_cards(extract_pdf_text_pages(PARSEC_PDF))\n",
+    "parsec_emb = embedder.encode(parsec_cards, batch_size=64, show_progress_bar=False, normalize_embeddings=True)\n",
+    "parsec_emb = np.asarray(parsec_emb, dtype=np.float32)\n",
+    "parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])\n",
+    "parsec_index.add(parsec_emb)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Device resolution (exact SKU -> GPT A/B)\n",
+    "# ============================\n",
+    "def _label_for_row(i: int) -> str:\n",
+    "    r = df_eos.iloc[i]\n",
+    "    return f\"{r.get('sku','')} — {r.get('manufacturer','')} — {r.get('description','')}\"[:220]\n",
+    "\n",
+    "EOS_LABELS = [_label_for_row(i) for i in range(len(df_eos))]\n",
+    "EOS_CORPUS = []\n",
+    "for _, r in df_eos.iterrows():\n",
+    "    EOS_CORPUS.append(\" \".join([\n",
+    "        r.get(\"_norm_sku\",\"\"),\n",
+    "        r.get(\"_canon_make\",\"\"),\n",
+    "        r.get(\"_norm_desc\",\"\"),\n",
+    "        r.get(\"_norm_notes\",\"\"),\n",
+    "    ]))\n",
+    "\n",
+    "def local_candidates(query: str, top_k: int = 6) -> List[Tuple[int,int,str]]:\n",
+    "    q = norm_text(query)\n",
+    "    hits = process.extract(q, EOS_CORPUS, scorer=fuzz.WRatio, limit=top_k)\n",
+    "    return [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]\n",
+    "\n",
+    "def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> Dict[str, Any]:\n",
+    "    if client is None:\n",
+    "        return {}\n",
+    "    sys = \"Pick which router the user meant. Never invent. Return strict JSON only.\"\n",
+    "    payload = {\n",
+    "        \"user_input\": user_text,\n",
+    "        \"candidates\": [{\"row_idx\": i, \"score\": s, \"label\": lbl} for (i,s,lbl) in candidates],\n",
+    "        \"rules\": [\n",
+    "            \"If one candidate is clearly correct, return mode='ok' with row_idx.\",\n",
+    "            \"If two are plausible, return mode='pick' with top 2 options.\"\n",
+    "        ],\n",
+    "        \"output_schema\": {\"mode\":\"ok|pick\",\"row_idx\":\"int\",\"options\":[{\"row_idx\":\"int\",\"label\":\"string\"}]}\n",
+    "    }\n",
+    "    return gpt_json(sys, payload, max_tokens=300)\n",
+    "\n",
+    "def resolve_device(user_text: str) -> Dict[str, Any]:\n",
+    "    q = norm_text(user_text)\n",
+    "    exact_idxs = df_eos.index[df_eos[\"_norm_sku\"] == q].tolist()\n",
+    "    if len(exact_idxs) == 1:\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": int(exact_idxs[0])}\n",
+    "    if len(exact_idxs) > 1:\n",
+    "        opts = [{\"row_idx\": int(i), \"label\": EOS_LABELS[int(i)]} for i in exact_idxs[:2]]\n",
+    "        return {\"mode\":\"pick\",\"options\": opts}\n",
+    "\n",
+    "    cands = local_candidates(user_text, top_k=6)\n",
+    "    if not cands:\n",
+    "        return {\"mode\":\"not_found\"}\n",
+    "\n",
+    "    if cands[0][1] >= 95 and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= 8):\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": cands[0][0]}\n",
+    "\n",
+    "    g = gpt_choose_device(user_text, cands)\n",
+    "    if g.get(\"mode\") == \"ok\" and isinstance(g.get(\"row_idx\"), int):\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": int(g[\"row_idx\"])}\n",
+    "\n",
+    "    if g.get(\"mode\") == \"pick\":\n",
+    "        opts = g.get(\"options\", []) or []\n",
+    "        opts2 = [{\"row_idx\": int(o[\"row_idx\"]), \"label\": str(o[\"label\"])} for o in opts[:2] if \"row_idx\" in o]\n",
+    "        if opts2:\n",
+    "            return {\"mode\":\"pick\",\"options\": opts2}\n",
+    "\n",
+    "    # fallback\n",
+    "    if len(cands) > 1:\n",
+    "        return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]},{\"row_idx\":cands[1][0],\"label\":cands[1][2]}]}\n",
+    "    return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]}]}\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Replacements — lifecycle CSV source of truth\n",
+    "# ============================\n",
+    "def _extract_model_token(text: str) -> str:\n",
+    "    s = _safe_str(text)\n",
+    "    if not s:\n",
+    "        return \"\"\n",
+    "    parts = [p.strip() for p in s.split(\"|\") if p.strip()]\n",
+    "    candidates = parts[::-1] if parts else [s]\n",
+    "\n",
+    "    for cand in candidates:\n",
+    "        m = re.search(r\"\\bRUT[A-Z]?\\d{2,4}\\b\", cand.upper())\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "        m = re.search(r\"\\bIX\\d{2}\\b\", cand, flags=re.IGNORECASE)\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "        m = re.search(r\"\\b(R\\d{3,4}|E\\d{3,4}|S\\d{3,4})\\b\", cand, flags=re.IGNORECASE)\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "        m = re.search(r\"\\b[A-Z]{1,6}\\d{2,4}[A-Z]?\\b\", cand.upper())\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "\n",
+    "    return candidates[0][:60]\n",
+    "\n",
+    "def _device_is_4g(life_row: pd.Series) -> bool:\n",
+    "    t = norm_text(life_row.get(\"description\",\"\")) + \" \" + norm_text(life_row.get(\"notes\",\"\"))\n",
+    "    return ((\"lte\" in t or \"4g\" in t) and (\"5g\" not in t and \"nr\" not in t))\n",
+    "\n",
+    "def _candidate_5g_models_from_lifecycle(manufacturer: str) -> List[str]:\n",
+    "    mfr = norm_text(manufacturer)\n",
+    "    pool = df_eos[df_eos[\"manufacturer\"].astype(str).str.lower().eq(mfr)].copy() if \"manufacturer\" in df_eos.columns else df_eos.copy()\n",
+    "    vals = pool[\"advanced_5g_option\"].tolist() if \"advanced_5g_option\" in pool.columns else []\n",
+    "    out, seen = [], set()\n",
+    "    for v in vals:\n",
+    "        tok = _extract_model_token(v)\n",
+    "        if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "            seen.add(tok); out.append(tok)\n",
+    "    return out\n",
+    "\n",
+    "def _candidate_4g_models_from_lifecycle(manufacturer: str) -> List[str]:\n",
+    "    mfr = norm_text(manufacturer)\n",
+    "    pool = df_eos[df_eos[\"manufacturer\"].astype(str).str.lower().eq(mfr)].copy() if \"manufacturer\" in df_eos.columns else df_eos.copy()\n",
+    "    vals = pool[\"suggested_replacement\"].tolist() if \"suggested_replacement\" in pool.columns else []\n",
+    "    out, seen = [], set()\n",
+    "    for v in vals:\n",
+    "        tok = _extract_model_token(v)\n",
+    "        if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "            seen.add(tok); out.append(tok)\n",
+    "    return out\n",
+    "\n",
+    "def _gpt_pick_from_candidates(old_row: pd.Series, candidates: List[str], need: str) -> str:\n",
+    "    if client is None or not candidates:\n",
+    "        return \"\"\n",
+    "    sys = \"Pick the best replacement model. Choose only from candidates. Return strict JSON only.\"\n",
+    "    payload = {\n",
+    "        \"old_device\": {\n",
+    "            \"sku\": str(old_row.get(\"sku\",\"\")),\n",
+    "            \"manufacturer\": str(old_row.get(\"manufacturer\",\"\")),\n",
+    "            \"description\": str(old_row.get(\"description\",\"\")),\n",
+    "            \"need\": need,\n",
+    "        },\n",
+    "        \"candidates\": candidates[:40],\n",
+    "        \"output_schema\": {\"choice\":\"string\"}\n",
+    "    }\n",
+    "    out = gpt_json(sys, payload, max_tokens=240) or {}\n",
+    "    choice = str(out.get(\"choice\",\"\") or \"\").strip()\n",
+    "    return choice if choice in candidates else \"\"\n",
+    "\n",
+    "def _fallback_5g_from_dec(canon_make: str) -> str:\n",
+    "    pool5 = df_dec[(df_dec[\"_canon_make\"] == canon_make) & (df_dec[\"_is5g\"] == True)]\n",
+    "    return str(pool5.iloc[0][\"Model\"]).strip() if not pool5.empty else \"\"\n",
+    "\n",
+    "def pick_replacements_lifecycle(life_row: pd.Series, status: str, use_gpt: bool = True) -> Dict[str, Any]:\n",
+    "    canon = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    manufacturer = str(life_row.get(\"manufacturer\",\"\") or \"\")\n",
+    "\n",
+    "    is_4g_device = _device_is_4g(life_row)\n",
+    "    want_5g = is_4g_device or (status in {\"End of Sale\",\"End of Life\"})\n",
+    "\n",
+    "    repl_4g = \"Not applicable\"\n",
+    "    if is_4g_device:\n",
+    "        repl_4g = _extract_model_token(_safe_str(life_row.get(\"suggested_replacement\",\"\")))\n",
+    "        if not repl_4g:\n",
+    "            cand4 = _candidate_4g_models_from_lifecycle(manufacturer)\n",
+    "            repl_4g = (_gpt_pick_from_candidates(life_row, cand4, \"4G alternative\") if (use_gpt and client) else \"\") or (cand4[0] if cand4 else \"\")\n",
+    "        if not repl_4g:\n",
+    "            repl_4g = \"Not applicable\"\n",
+    "\n",
+    "    repl_5g = \"Not applicable\"\n",
+    "    if want_5g:\n",
+    "        repl_5g = _extract_model_token(_safe_str(life_row.get(\"advanced_5g_option\",\"\")))\n",
+    "        if not repl_5g:\n",
+    "            cand5 = _candidate_5g_models_from_lifecycle(manufacturer)\n",
+    "            repl_5g = (_gpt_pick_from_candidates(life_row, cand5, \"5G replacement/upgrade\") if (use_gpt and client) else \"\") or (cand5[0] if cand5 else \"\")\n",
+    "        if not repl_5g:\n",
+    "            repl_5g = _fallback_5g_from_dec(canon)\n",
+    "\n",
+    "    if repl_5g.lower() == \"nan\":\n",
+    "        repl_5g = \"\"\n",
+    "\n",
+    "    return {\n",
+    "        \"repl_4g\": repl_4g,\n",
+    "        \"repl_5g\": repl_5g if repl_5g else \"Not listed\",\n",
+    "        \"why\": \"Lifecycle replacements (GPT fallback when missing).\",\n",
+    "        \"sources\": [\"lifecycle_csv\"] + ([\"gpt\"] if (use_gpt and client) else []) + ([\"dec_fallback\"] if (want_5g and (repl_5g == \"Not listed\" or repl_5g == \"\")) else []),\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Antennas (Parsec-only; family + connectors hint)\n",
+    "# ============================\n",
+    "PARSEC_FAMILY_WORDS = {\n",
+    "    \"chinook\",\"labrador\",\"boxer\",\"bloodhound\",\"husky\",\"beagle\",\"mastiff\",\"collie\",\n",
+    "    \"shepherd\",\"belgian\",\"australian\",\"terrier\",\"pyrenees\"\n",
+    "}\n",
+    "BAD_NAME_MARKERS = {\n",
+    "    \"customization\", \"standard connectors\", \"connectors\", \"features\", \"benefits\",\n",
+    "    \"specifications\", \"mechanical\", \"electrical\", \"mounting\", \"accessories\",\n",
+    "    \"description:\", \"standard sku\"\n",
+    "}\n",
+    "\n",
+    "def _clean_line(s: str) -> str:\n",
+    "    s = re.sub(r\"\\s+\", \" \", str(s or \"\").strip())\n",
+    "    if re.fullmatch(r\"-[a-z0-9]+\", s.lower()):\n",
+    "        return \"\"\n",
+    "    return s\n",
+    "\n",
+    "def _is_bad_name_line(line: str) -> bool:\n",
+    "    low = line.lower()\n",
+    "    if any(m in low for m in BAD_NAME_MARKERS):\n",
+    "        return True\n",
+    "    if re.search(r\"\\b-[a-z0-9]{1,4}\\b\", low) and len(low) <= 25:\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "def _family_from_line(line: str) -> str:\n",
+    "    low = line.lower()\n",
+    "    for fam in PARSEC_FAMILY_WORDS:\n",
+    "        if fam in low:\n",
+    "            return fam.capitalize()\n",
+    "    return \"\"\n",
+    "\n",
+    "def _parsec_connectors_from_card(t: str) -> str:\n",
+    "    m = re.search(r\"Standard\\s+Connectors:\\s*(.+)\", t, flags=re.IGNORECASE)\n",
+    "    if m:\n",
+    "        val = re.sub(r\"\\s+\", \" \", m.group(1).strip())\n",
+    "        return val[:80]\n",
+    "    return \"\"\n",
+    "\n",
+    "def _parsec_name_from_card(card_text: str) -> str:\n",
+    "    lines = [_clean_line(ln) for ln in str(card_text or \"\").splitlines()]\n",
+    "    lines = [ln for ln in lines if ln]\n",
+    "\n",
+    "    for ln in lines:\n",
+    "        if _is_bad_name_line(ln):\n",
+    "            continue\n",
+    "        fam = _family_from_line(ln)\n",
+    "        if fam:\n",
+    "            return fam\n",
+    "\n",
+    "    sku_i = None\n",
+    "    for i, ln in enumerate(lines):\n",
+    "        if \"standard sku\" in ln.lower():\n",
+    "            sku_i = i\n",
+    "            break\n",
+    "    if sku_i is not None:\n",
+    "        window = lines[max(0, sku_i - 12):sku_i]\n",
+    "        for ln in reversed(window):\n",
+    "            if _is_bad_name_line(ln):\n",
+    "                continue\n",
+    "            if 3 <= len(ln) <= 40 and re.search(r\"[A-Za-z]\", ln):\n",
+    "                return ln.split()[0].capitalize()\n",
+    "\n",
+    "    return \"Parsec antenna\"\n",
+    "\n",
+    "def _parsec_part_from_card(t: str) -> str:\n",
+    "    m = re.search(r\"Standard\\s+SKU:\\s*([A-Z0-9]+)\", t)\n",
+    "    return m.group(1).strip() if m else \"\"\n",
+    "\n",
+    "def _parsec_desc_from_card(t: str) -> str:\n",
+    "    m = re.search(r\"Description:\\s*(.+?)(?:\\n|$)\", t, flags=re.IGNORECASE)\n",
+    "    return re.sub(r\"\\s+\",\" \",m.group(1).strip())[:220] if m else \"\"\n",
+    "\n",
+    "def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:\n",
+    "    qv = embedder.encode([query], normalize_embeddings=True)\n",
+    "    qv = np.asarray(qv, dtype=np.float32)\n",
+    "    scores, ids = parsec_index.search(qv, top_k)\n",
+    "    out = []\n",
+    "    for sc, i in zip(scores[0].tolist(), ids[0].tolist()):\n",
+    "        if 0 <= int(i) < len(parsec_cards):\n",
+    "            card = parsec_cards[int(i)]\n",
+    "            out.append({\n",
+    "                \"score\": float(sc),\n",
+    "                \"name\": _parsec_name_from_card(card),\n",
+    "                \"part_number\": _parsec_part_from_card(card),\n",
+    "                \"description\": _parsec_desc_from_card(card),\n",
+    "                \"connectors\": _parsec_connectors_from_card(card),\n",
+    "            })\n",
+    "    return out\n",
+    "\n",
+    "def infer_mimo_for_replacement(model: str, canon_make: str) -> str:\n",
+    "    if not model or model in {\"Not applicable\",\"Not listed\"}:\n",
+    "        return \"2x2\"\n",
+    "    pool = df_dec[df_dec[\"_canon_make\"] == canon_make].copy()\n",
+    "    if pool.empty:\n",
+    "        return \"4x4\" if (\"5g\" in model.lower()) else \"2x2\"\n",
+    "    hit = process.extractOne(norm_text(model), pool[\"_norm_model\"].tolist(), scorer=fuzz.WRatio)\n",
+    "    if hit and hit[1] >= MATCH_OK:\n",
+    "        row = pool.iloc[int(hit[2])]\n",
+    "        txt = (str(row.get(\"Antennas (internal/external/both)\",\"\")) + \" \" + str(row.get(\"Modem Type\",\"\"))).lower()\n",
+    "        if \"4x4\" in txt or \"4 x 4\" in txt:\n",
+    "            return \"4x4\"\n",
+    "    return \"4x4\" if (\"5g\" in model.lower()) else \"2x2\"\n",
+    "\n",
+    "def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, Any]:\n",
+    "    q_stationary = f\"{router_model} {tech} {mimo} omni stationary outdoor Parsec\"\n",
+    "    q_vehicle = f\"{router_model} {tech} {mimo} omni vehicle mobile Parsec\"\n",
+    "\n",
+    "    cand_stationary = parsec_retrieve(q_stationary, top_k=10)\n",
+    "    cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)\n",
+    "\n",
+    "    s = cand_stationary[0] if cand_stationary else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\",\"connectors\":\"\"}\n",
+    "    v = cand_vehicle[0] if cand_vehicle else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\",\"connectors\":\"\"}\n",
+    "    s.update({\"mimo\": mimo, \"why\": \"Stationary omni best match.\"})\n",
+    "    v.update({\"mimo\": mimo, \"why\": \"Vehicle omni best match.\"})\n",
+    "    return {\"stationary_omni\": s, \"vehicle_omni\": v, \"sources\":[\"parsec_rag\"]}\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Feature table + GPT fill for missing fields (not lazy: fill missing)\n",
+    "# ============================\n",
+    "FEATURE_COLS = [\"Name\",\"Modem technology\",\"WiFi\",\"Ports\",\"Antennas\",\"Ruggedness\",\"Use case\"]\n",
+    "\n",
+    "def dec_features_by_model(model: str, canon_make: str) -> Dict[str, str]:\n",
+    "    if not model or model in {\"Not applicable\",\"Not listed\"}:\n",
+    "        return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "    pool = df_dec[df_dec[\"_canon_make\"] == canon_make].copy()\n",
+    "    if pool.empty:\n",
+    "        return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "    hit = process.extractOne(norm_text(model), pool[\"_norm_model\"].tolist(), scorer=fuzz.WRatio)\n",
+    "    if not hit or hit[1] < MATCH_OK:\n",
+    "        return {k:\"Not listed\" for k in FEATURE_COLS}\n",
+    "    r = pool.iloc[int(hit[2])]\n",
+    "    ports = f\"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}\"\n",
+    "    return {\n",
+    "        \"Name\": str(r.get(\"Model\",\"\")),\n",
+    "        \"Modem technology\": str(r.get(\"Modem Type\",\"\")),\n",
+    "        \"WiFi\": str(r.get(\"WiFi type\",\"\")),\n",
+    "        \"Ports\": ports,\n",
+    "        \"Antennas\": str(r.get(\"Antennas (internal/external/both)\",\"\")),\n",
+    "        \"Ruggedness\": str(r.get(\"Ruggedization\",\"\")),\n",
+    "        \"Use case\": str(r.get(\"Primary use case\",\"\")),\n",
+    "    }\n",
+    "\n",
+    "def gpt_fill_features(device_label: str, feats: Dict[str,str], context: str) -> Dict[str,str]:\n",
+    "    missing = [k for k,v in feats.items() if (not v) or v.strip().lower() in {\"not listed\",\"nan\"}]\n",
+    "    if client is None or not missing:\n",
+    "        return feats\n",
+    "    sys = \"Fill missing router feature fields. Return strict JSON only.\"\n",
+    "    payload = {\n",
+    "        \"device\": device_label,\n",
+    "        \"known\": feats,\n",
+    "        \"context\": context[:2000],\n",
+    "        \"fill_only\": missing,\n",
+    "        \"rules\": [\"Fill only requested fields. Best guess if needed. Return JSON only.\"],\n",
+    "        \"output_schema\": {k:\"string\" for k in missing}\n",
+    "    }\n",
+    "    out = gpt_json(sys, payload, max_tokens=350) or {}\n",
+    "    for k in missing:\n",
+    "        v = str(out.get(k,\"\") or \"\").strip()\n",
+    "        if v:\n",
+    "            feats[k] = v\n",
+    "    return feats\n",
+    "\n",
+    "def current_features_guess(life_row: pd.Series) -> Dict[str,str]:\n",
+    "    sku = str(life_row.get(\"sku\",\"\") or \"\").strip()\n",
+    "    desc = str(life_row.get(\"description\",\"\") or \"\").strip()\n",
+    "    notes = str(life_row.get(\"notes\",\"\") or \"\").strip()\n",
+    "    base = {\n",
+    "        \"Name\": sku,\n",
+    "        \"Modem technology\": \"4G\" if _device_is_4g(life_row) else (\"5G\" if (\"5g\" in (desc+notes).lower() or \"nr\" in (desc+notes).lower()) else \"Not listed\"),\n",
+    "        \"WiFi\": \"Not listed\",\n",
+    "        \"Ports\": \"Not listed\",\n",
+    "        \"Antennas\": \"Not listed\",\n",
+    "        \"Ruggedness\": \"Not listed\",\n",
+    "        \"Use case\": \"Not listed\",\n",
+    "    }\n",
+    "    return gpt_fill_features(\"Current device\", base, f\"{desc}\\n{notes}\")\n",
+    "\n",
+    "def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str]) -> str:\n",
+    "    cols = [\"Device\", \"Modem technology\", \"WiFi\", \"Ports\", \"Antennas\", \"Ruggedness\", \"Use case\"]\n",
+    "    header = \"| \" + \" | \".join(cols) + \" |\"\n",
+    "    sep = \"| \" + \" | \".join([\"---\"]*len(cols)) + \" |\"\n",
+    "    def row(name: str, feats: Dict[str,str]) -> str:\n",
+    "        return \"| \" + \" | \".join([\n",
+    "            name,\n",
+    "            feats.get(\"Modem technology\",\"Not listed\"),\n",
+    "            feats.get(\"WiFi\",\"Not listed\"),\n",
+    "            feats.get(\"Ports\",\"Not listed\"),\n",
+    "            feats.get(\"Antennas\",\"Not listed\"),\n",
+    "            feats.get(\"Ruggedness\",\"Not listed\"),\n",
+    "            feats.get(\"Use case\",\"Not listed\"),\n",
+    "        ]) + \" |\"\n",
+    "    return \"\\n\".join([header, sep, row(\"Current\", cur), row(\"4G alternative\", r4), row(\"5G replacement\", r5)])\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Output + install-ready checklist (Feature #9)\n",
+    "# ============================\n",
+    "def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:\n",
+    "    canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    current_name = f\"{life_row.get('sku','')} — {life_row.get('description','')}\".strip(\" —\")\n",
+    "\n",
+    "    st = ant.get(\"stationary_omni\", {})\n",
+    "    vh = ant.get(\"vehicle_omni\", {})\n",
+    "\n",
+    "    cur_feats = current_features_guess(life_row)\n",
+    "    r4_feats = dec_features_by_model(repl.get(\"repl_4g\",\"\"), canon_make)\n",
+    "    r5_feats = dec_features_by_model(repl.get(\"repl_5g\",\"\"), canon_make)\n",
+    "    if client is not None:\n",
+    "        r4_feats = gpt_fill_features(\"4G alternative\", r4_feats, f\"Model: {repl.get('repl_4g','')}\\nMake: {canon_make}\")\n",
+    "        r5_feats = gpt_fill_features(\"5G replacement\", r5_feats, f\"Model: {repl.get('repl_5g','')}\\nMake: {canon_make}\")\n",
+    "\n",
+    "    table_md = build_features_table(cur_feats, r4_feats, r5_feats)\n",
+    "\n",
+    "    lines = []\n",
+    "    lines.append(f\"1. Current device: **{current_name}**\")\n",
+    "    lines.append(f\"2. Status: **{status}**\")\n",
+    "    lines.append(f\"3. End of Sale date: **{eos}**\")\n",
+    "    lines.append(f\"4. End of Life date: **{eol}**\")\n",
+    "    lines.append(f\"5. 4G alternative (lifecycle): **{repl.get('repl_4g','Not applicable')}**\")\n",
+    "    lines.append(f\"6. 5G replacement (lifecycle): **{repl.get('repl_5g','Not listed')}**\")\n",
+    "    lines.append(\"7. Antenna options (Parsec-only):\")\n",
+    "    conn_s = f\" | Conn: {st.get('connectors','')}\" if st.get(\"connectors\") else \"\"\n",
+    "    conn_v = f\" | Conn: {vh.get('connectors','')}\" if vh.get(\"connectors\") else \"\"\n",
+    "    lines.append(f\"   - Stationary (Omni): **{st.get('name','')}** (Part #: {st.get('part_number','')}) — {st.get('description','')} — MIMO: {st.get('mimo','')}{conn_s} — {st.get('why','')}\")\n",
+    "    lines.append(f\"   - Vehicle (Omni): **{vh.get('name','')}** (Part #: {vh.get('part_number','')}) — {vh.get('description','')} — MIMO: {vh.get('mimo','')}{conn_v} — {vh.get('why','')}\")\n",
+    "    lines.append(\"8. Recommended features table:\")\n",
+    "    lines.append(table_md)\n",
+    "\n",
+    "    lines.append(\"\\nSources (debug):\")\n",
+    "    for s in repl.get(\"sources\", []) if isinstance(repl.get(\"sources\"), list) else []:\n",
+    "        lines.append(f\"- {s}\")\n",
+    "    lines.append(\"- ParsecCatalog.pdf (local RAG)\")\n",
+    "    lines.append(\"- routers_eos_eol_by_sku.csv (replacements)\")\n",
+    "    lines.append(\"- dec2025routers.csv (features)\")\n",
+    "    return \"\\n\".join(lines)\n",
+    "\n",
+    "def install_ready_checklist(life_row: pd.Series, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:\n",
+    "    current_sku = str(life_row.get(\"sku\",\"\") or \"\").strip()\n",
+    "    repl4 = str(repl.get(\"repl_4g\",\"\") or \"\")\n",
+    "    repl5 = str(repl.get(\"repl_5g\",\"\") or \"\")\n",
+    "    st = ant.get(\"stationary_omni\", {})\n",
+    "    vh = ant.get(\"vehicle_omni\", {})\n",
+    "\n",
+    "    if client is not None:\n",
+    "        sys = \"Create a short, install-ready checklist for a Verizon rep. Keep it scannable. Return markdown only.\"\n",
+    "        payload = {\n",
+    "            \"current_device\": current_sku,\n",
+    "            \"replacements\": {\"4g_alternative\": repl4, \"5g_replacement\": repl5},\n",
+    "            \"antennas\": {\"stationary\": st, \"vehicle\": vh},\n",
+    "            \"rules\": [\n",
+    "                \"Include: router(s), antennas, connector/cable notes, mounting notes, power notes, and 'next steps'.\",\n",
+    "                \"Keep it concise and practical.\"\n",
+    "            ]\n",
+    "        }\n",
+    "        resp = client.responses.create(\n",
+    "            model=OPENAI_MODEL,\n",
+    "            reasoning=OPENAI_REASONING,\n",
+    "            input=[{\"role\":\"system\",\"content\":sys},{\"role\":\"user\",\"content\":json.dumps(payload)}],\n",
+    "            max_output_tokens=550,\n",
+    "        )\n",
+    "        return (getattr(resp, \"output_text\", \"\") or \"\").strip()\n",
+    "\n",
+    "    lines = []\n",
+    "    lines.append(\"### Install-ready checklist\")\n",
+    "    lines.append(f\"- Current device: {current_sku}\")\n",
+    "    lines.append(f\"- 5G replacement: {repl5}\")\n",
+    "    lines.append(f\"- 4G alternative: {repl4 if repl4 else 'Not applicable'}\")\n",
+    "    lines.append(f\"- Stationary omni antenna: {st.get('name','')} (PN {st.get('part_number','')})\")\n",
+    "    lines.append(f\"- Vehicle omni antenna: {vh.get('name','')} (PN {vh.get('part_number','')})\")\n",
+    "    if st.get(\"connectors\"):\n",
+    "        lines.append(f\"- Stationary connectors: {st.get('connectors')}\")\n",
+    "    if vh.get(\"connectors\"):\n",
+    "        lines.append(f\"- Vehicle connectors: {vh.get('connectors')}\")\n",
+    "    lines.append(\"- Next steps: confirm mounting + cable lengths + power method; place order; schedule install.\")\n",
+    "    return \"\\n\".join(lines)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Batch mode (Feature #4)\n",
+    "# ============================\n",
+    "def parse_batch_inputs(text_blob: str, file_obj: Optional[Any]) -> List[str]:\n",
+    "    items = []\n",
+    "    if file_obj is not None:\n",
+    "        try:\n",
+    "            path = file_obj.name if hasattr(file_obj, \"name\") else str(file_obj)\n",
+    "            df = pd.read_csv(path)\n",
+    "            col = df.columns[0]\n",
+    "            items.extend([str(x).strip() for x in df[col].tolist() if str(x).strip()])\n",
+    "        except Exception:\n",
+    "            pass\n",
+    "    if text_blob:\n",
+    "        for ln in str(text_blob).splitlines():\n",
+    "            ln = ln.strip()\n",
+    "            if ln:\n",
+    "                items.append(ln)\n",
+    "    seen=set()\n",
+    "    out=[]\n",
+    "    for x in items:\n",
+    "        k=norm_text(x)\n",
+    "        if k and k not in seen:\n",
+    "            seen.add(k); out.append(x)\n",
+    "    return out\n",
+    "\n",
+    "def run_batch(text_blob: str, file_obj: Optional[Any], include_antennas: bool):\n",
+    "    inputs = parse_batch_inputs(text_blob, file_obj)\n",
+    "    if not inputs:\n",
+    "        return \"\", pd.DataFrame(), None, \"\"\n",
+    "\n",
+    "    rows=[]\n",
+    "    for item in inputs:\n",
+    "        res = resolve_device(item)\n",
+    "        if res.get(\"mode\") != \"ok\":\n",
+    "            rows.append({\n",
+    "                \"Input\": item,\n",
+    "                \"Matched\": \"\",\n",
+    "                \"Status\": \"Needs review\",\n",
+    "                \"EOS\": \"\",\n",
+    "                \"EOL\": \"\",\n",
+    "                \"4G alternative\": \"\",\n",
+    "                \"5G replacement\": \"\",\n",
+    "                \"Stationary antenna\": \"\",\n",
+    "                \"Vehicle antenna\": \"\",\n",
+    "                \"Notes\": \"Not found / ambiguous\"\n",
+    "            })\n",
+    "            continue\n",
+    "\n",
+    "        life_row = df_eos.iloc[int(res[\"row_idx\"])]\n",
+    "        eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "        repl = pick_replacements_lifecycle(life_row, status, use_gpt=False)  # fast: no GPT in batch\n",
+    "\n",
+    "        if include_antennas:\n",
+    "            canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "            mimo = infer_mimo_for_replacement(repl.get(\"repl_5g\",\"\"), canon_make)\n",
+    "            tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") not in {\"Not applicable\",\"Not listed\"} else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "            ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo)\n",
+    "            stA = ant.get(\"stationary_omni\", {})\n",
+    "            vhA = ant.get(\"vehicle_omni\", {})\n",
+    "            ant_s = f\"{stA.get('name','')} {stA.get('part_number','')}\"\n",
+    "            ant_v = f\"{vhA.get('name','')} {vhA.get('part_number','')}\"\n",
+    "        else:\n",
+    "            ant_s = \"\"\n",
+    "            ant_v = \"\"\n",
+    "\n",
+    "        rows.append({\n",
+    "            \"Input\": item,\n",
+    "            \"Matched\": str(life_row.get(\"sku\",\"\")),\n",
+    "            \"Status\": status,\n",
+    "            \"EOS\": eos,\n",
+    "            \"EOL\": eol,\n",
+    "            \"4G alternative\": repl.get(\"repl_4g\",\"\"),\n",
+    "            \"5G replacement\": repl.get(\"repl_5g\",\"\"),\n",
+    "            \"Stationary antenna\": ant_s,\n",
+    "            \"Vehicle antenna\": ant_v,\n",
+    "            \"Notes\": \"\",\n",
+    "        })\n",
+    "\n",
+    "    out_df = pd.DataFrame(rows)\n",
+    "\n",
+    "    # Summary counts + rollup\n",
+    "    counts = out_df[\"Status\"].value_counts(dropna=False).to_dict()\n",
+    "    top_5g = out_df[\"5G replacement\"].value_counts(dropna=False).head(5).to_dict()\n",
+    "    summary = f\"Rows: {len(out_df)} | \" + \" | \".join([f\"{k}: {v}\" for k,v in counts.items()])\n",
+    "    rollup = \"Top 5G recommendations:\\n\" + \"\\n\".join([f\"- {k}: {v}\" for k,v in top_5g.items() if str(k).strip()])\n",
+    "\n",
+    "    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=\".csv\")\n",
+    "    out_df.to_csv(tmp.name, index=False)\n",
+    "\n",
+    "    return summary, out_df, tmp.name, rollup\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Gradio app (Single + Batch + Install-ready)\n",
+    "# ============================\n",
+    "def run_lookup(user_text: str, st: Dict[str,Any]):\n",
+    "    user_text = str(user_text or \"\").strip()\n",
+    "    if not user_text:\n",
+    "        return \"Enter a router SKU/model.\", gr.update(visible=False), gr.update(visible=False), {}, gr.update(value=\"\")\n",
+    "\n",
+    "    res = resolve_device(user_text)\n",
+    "    if res.get(\"mode\") == \"pick\":\n",
+    "        opts = res.get(\"options\", [])\n",
+    "        choices = [o[\"label\"] for o in opts]\n",
+    "        st2 = {\"mode\":\"pick\",\"options\": opts}\n",
+    "        return \"Did you mean A or B? Pick one, then click Use selection.\", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2, gr.update(value=\"\")\n",
+    "\n",
+    "    if res.get(\"mode\") != \"ok\":\n",
+    "        return \"Not found.\", gr.update(visible=False), gr.update(visible=False), {}, gr.update(value=\"\")\n",
+    "\n",
+    "    life_row = df_eos.iloc[int(res[\"row_idx\"])]\n",
+    "    eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "\n",
+    "    repl = pick_replacements_lifecycle(life_row, status, use_gpt=True)\n",
+    "\n",
+    "    canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    mimo = infer_mimo_for_replacement(repl.get(\"repl_5g\",\"\"), canon_make)\n",
+    "    tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") not in {\"Not applicable\",\"Not listed\"} else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "    ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo)\n",
+    "\n",
+    "    output = assemble_output(life_row, status, eos, eol, repl, ant)\n",
+    "    st_out = {\"row_idx\": int(res[\"row_idx\"]), \"repl\": repl, \"ant\": ant}\n",
+    "    return output, gr.update(visible=False), gr.update(visible=False), st_out, gr.update(value=\"\")\n",
+    "\n",
+    "def use_selection(selected_label: str, st: Dict[str,Any]):\n",
+    "    if not st or st.get(\"mode\") != \"pick\":\n",
+    "        return \"Run a search first.\", gr.update(visible=False), gr.update(visible=False), {}, gr.update(value=\"\")\n",
+    "    if not selected_label:\n",
+    "        return \"Pick A or B first.\", gr.update(visible=True), gr.update(visible=True), st, gr.update(value=\"\")\n",
+    "\n",
+    "    chosen_row = None\n",
+    "    for o in st.get(\"options\", []):\n",
+    "        if o.get(\"label\") == selected_label:\n",
+    "            chosen_row = int(o[\"row_idx\"])\n",
+    "            break\n",
+    "    if chosen_row is None:\n",
+    "        return \"Pick a valid option.\", gr.update(visible=True), gr.update(visible=True), st, gr.update(value=\"\")\n",
+    "\n",
+    "    life_row = df_eos.iloc[int(chosen_row)]\n",
+    "    eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "    repl = pick_replacements_lifecycle(life_row, status, use_gpt=True)\n",
+    "\n",
+    "    canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    mimo = infer_mimo_for_replacement(repl.get(\"repl_5g\",\"\"), canon_make)\n",
+    "    tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") not in {\"Not applicable\",\"Not listed\"} else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "    ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo)\n",
+    "\n",
+    "    output = assemble_output(life_row, status, eos, eol, repl, ant)\n",
+    "    st_out = {\"row_idx\": int(chosen_row), \"repl\": repl, \"ant\": ant}\n",
+    "    return output, gr.update(visible=False), gr.update(visible=False), st_out, gr.update(value=\"\")\n",
+    "\n",
+    "def make_install_ready(st_state: Dict[str,Any]):\n",
+    "    if not st_state or \"row_idx\" not in st_state:\n",
+    "        return \"Run a lookup first.\"\n",
+    "    life_row = df_eos.iloc[int(st_state[\"row_idx\"])]\n",
+    "    repl = st_state.get(\"repl\", {}) or {}\n",
+    "    ant = st_state.get(\"ant\", {}) or {}\n",
+    "    return install_ready_checklist(life_row, repl, ant)\n",
+    "\n",
+    "with gr.Blocks(title=\"Only-Routers\") as demo:\n",
+    "    gr.Markdown(\"## Only-Routers\\nSingle lookup + Batch upload for Verizon reps.\")\n",
+    "\n",
+    "    with gr.Tabs():\n",
+    "        with gr.Tab(\"Single\"):\n",
+    "            user_text = gr.Textbox(label=\"Router SKU or model\", placeholder=\"Examples: IBR650B, AER1600, ES450, WR21, RUT240\", lines=1)\n",
+    "            st = gr.State({})\n",
+    "\n",
+    "            check_btn = gr.Button(\"Check\", variant=\"primary\")\n",
+    "            pick_dd = gr.Dropdown(label=\"Pick A or B\", choices=[], visible=False)\n",
+    "            use_btn = gr.Button(\"Use selection\", visible=False)\n",
+    "\n",
+    "            output_md = gr.Markdown()\n",
+    "\n",
+    "            install_btn = gr.Button(\"Make install-ready checklist\")\n",
+    "            install_md = gr.Markdown()\n",
+    "\n",
+    "            check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st, install_md])\n",
+    "            use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st, install_md])\n",
+    "            install_btn.click(fn=make_install_ready, inputs=[st], outputs=[install_md])\n",
+    "\n",
+    "        with gr.Tab(\"Batch\"):\n",
+    "            gr.Markdown(\"Paste one per line or upload a CSV (first column). Batch runs fast (no GPT), and can optionally include antenna picks.\")\n",
+    "            batch_text = gr.Textbox(label=\"Paste devices (one per line)\", lines=8, placeholder=\"WR21\\nRUT240\\nIBR650B\")\n",
+    "            batch_file = gr.File(label=\"Upload CSV\", file_types=[\".csv\"])\n",
+    "            include_ant = gr.Checkbox(label=\"Include antenna picks (slower)\", value=False)\n",
+    "            run_btn = gr.Button(\"Run batch\", variant=\"primary\")\n",
+    "\n",
+    "            summary_md = gr.Markdown()\n",
+    "            rollup_md = gr.Markdown()\n",
+    "            table = gr.Dataframe(interactive=False, wrap=True)\n",
+    "            dl = gr.File(label=\"Download results CSV\")\n",
+    "\n",
+    "            run_btn.click(fn=run_batch, inputs=[batch_text, batch_file, include_ant], outputs=[summary_md, table, dl, rollup_md])\n",
+    "\n",
+    "demo.launch()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}