Upload folder using huggingface_hub

app.py

@@ -2,7 +2,6 @@ import os
 import re
 import json
 import math
-import glob
 import hashlib
 from dataclasses import dataclass
 from datetime import datetime, date
@@ -29,7 +28,6 @@ OPENAI_REASONING = {"effort": "high"}
 
 MATCH_OK = 80
 EMBED_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-
 PARSEC_CONTEXT_BEFORE = 900
 PARSEC_CONTEXT_AFTER = 1600
 
@@ -45,7 +43,7 @@ client = OpenAI(api_key=API_KEY) if API_KEY else None
 
 
 # ============================
-# Small utilities
+# Utilities
 # ============================
 def norm_text(s: Any) -> str:
     try:
@@ -125,14 +123,14 @@ def _region_ok(x: Any) -> bool:
 if "region" in df_eos.columns:
     df_eos = df_eos[df_eos["region"].apply(_region_ok)].reset_index(drop=True)
 
-# Optional "Device Type" column
+# 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
+# Maker mapping (expanded — adds Teltonika)
 CANON_MAKER = {
     "CRADLEPOINT": {"cradlepoint", "ericsson", "ericsson enterprise wireless"},
     "SIERRA": {"sierra", "sierra wireless", "semtech", "airlink"},
@@ -140,6 +138,7 @@ CANON_MAKER = {
     "DIGI": {"digi", "accelerated", "accelerated concepts"},
     "CISCO_MERAKI": {"meraki", "cisco meraki"},
     "CISCO": {"cisco"},
+    "TELTONIKA": {"teltonika"},
 }
 DISPLAY_MAKER = {
     "CRADLEPOINT": "Cradlepoint",
@@ -148,6 +147,7 @@ DISPLAY_MAKER = {
     "DIGI": "Digi",
     "CISCO_MERAKI": "Cisco Meraki",
     "CISCO": "Cisco",
+    "TELTONIKA": "Teltonika",
     "UNKNOWN": "Unknown",
 }
 
@@ -168,14 +168,6 @@ df_dec["_canon_make"] = df_dec["Make"].apply(canon_maker_from_text) if "Make" in
 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
 
-def display_maker_for_row(life_row: pd.Series) -> str:
-    canon = str(life_row.get("_canon_make","UNKNOWN"))
-    if canon != "DIGI":
-        return DISPLAY_MAKER.get(canon, "Unknown")
-    desc = norm_text(life_row.get("description",""))
-    notes = norm_text(life_row.get("notes",""))
-    return "Accelerated Concepts (now Digi)" if ("accelerated" in desc or "accelerated" in notes) else "Digi"
-
 
 # ============================
 # Date helpers
@@ -238,11 +230,10 @@ def row_to_dates_and_status(life_row: pd.Series) -> Tuple[str, str, str]:
 
 
 # ============================
-# Embeddings + indices
+# Embeddings + Parsec index
 # ============================
 embedder = SentenceTransformer(EMBED_MODEL_NAME)
 
-# Parsec cards around "Standard SKU"
 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))]
@@ -309,7 +300,6 @@ def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> D
 
 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])}
@@ -341,7 +331,8 @@ def resolve_device(user_text: str) -> Dict[str, Any]:
 
 
 # ============================
-# Replacements — source of truth is lifecycle CSV (with GPT fallback)
+# 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)
@@ -351,20 +342,33 @@ 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()
-        m = re.search(r"\b[A-Z]{1,5}\d{2,4}[A-Z]?\b", cand.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 _candidate_5g_models_from_lifecycle(canon_make: str) -> List[str]:
-    pool = df_eos[df_eos["_canon_make"] == canon_make].copy()
+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:
@@ -373,8 +377,9 @@ def _candidate_5g_models_from_lifecycle(canon_make: str) -> List[str]:
             seen.add(tok); out.append(tok)
     return out
 
-def _candidate_4g_models_from_lifecycle(canon_make: str) -> List[str]:
-    pool = df_eos[df_eos["_canon_make"] == canon_make].copy()
+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:
@@ -383,21 +388,21 @@ def _candidate_4g_models_from_lifecycle(canon_make: str) -> List[str]:
             seen.add(tok); out.append(tok)
     return out
 
-def _gpt_pick_from_lifecycle_models(old_row: pd.Series, candidates: List[str], need: str) -> str:
+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","")),
-            "description": str(old_row.get("description","")),
             "manufacturer": str(old_row.get("manufacturer","")),
+            "description": str(old_row.get("description","")),
             "need": need,
         },
-        "candidates": candidates[:30],
+        "candidates": candidates[:40],
         "output_schema": {"choice":"string"}
     }
-    out = gpt_json(sys, payload, max_tokens=220) or {}
+    out = gpt_json(sys, payload, max_tokens=240) or {}
     choice = str(out.get("choice","") or "").strip()
     return choice if choice in candidates else ""
 
@@ -405,36 +410,33 @@ 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 _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 pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, Any]:
     canon = str(life_row.get("_canon_make","UNKNOWN"))
-    if canon == "UNKNOWN":
-        return {"repl_4g":"Not applicable","repl_5g":"", "why":"", "sources":[]}
+    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 needs_4g_repl:
+    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(canon)
-            repl_4g = _gpt_pick_from_lifecycle_models(life_row, cand4, "4G replacement") or (cand4[0] if cand4 else "")
+            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(canon)
-            repl_5g = _gpt_pick_from_lifecycle_models(life_row, cand5, "5G replacement/upgrade") or (cand5[0] if cand5 else "")
+            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
+            # last resort: dec catalog fallback
             repl_5g = _fallback_5g_from_dec(canon)
 
     if repl_5g.lower() == "nan":
@@ -444,7 +446,7 @@ def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, A
         "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 _extract_model_token(_safe_str(life_row.get("advanced_5g_option","")))) else []),
+        "sources": ["lifecycle_csv"] + (["gpt"] if client else []) + (["dec_fallback"] if (want_5g and not repl_5g) else []),
     }
 
 
@@ -493,6 +495,7 @@ 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():
@@ -529,7 +532,6 @@ 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),
-                "card": card[:1100],
             })
     return out
 
@@ -539,60 +541,21 @@ def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, An
     cand_stationary = parsec_retrieve(q_stationary, top_k=10)
     cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)
 
-    if client is None:
-        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"]}
-
-    sys = "Select Parsec antennas. Choose only from candidates. Return strict JSON only."
-    payload = {
-        "router_model": router_model,
-        "tech": tech,
-        "mimo": mimo,
-        "stationary_candidates": cand_stationary,
-        "vehicle_candidates": cand_vehicle,
-        "rules": [
-            "Return two options: stationary_omni and vehicle_omni.",
-            "Use only candidates. Prefer family names like Labrador/Chinook/Boxer.",
-            "Include name, part_number, description, mimo, why.",
-            "Return JSON only."
-        ],
-        "output_schema": {
-            "stationary_omni": {"name":"string","part_number":"string","description":"string","mimo":"2x2|4x4","why":"string"},
-            "vehicle_omni": {"name":"string","part_number":"string","description":"string","mimo":"2x2|4x4","why":"string"}
-        }
-    }
-    out = gpt_json(sys, payload, max_tokens=650) or {}
-
-    def _fix(x: Dict[str, Any], default_why: str) -> Dict[str, str]:
-        return {
-            "name": str(x.get("name","Parsec antenna") or "Parsec antenna")[:110],
-            "part_number": str(x.get("part_number","") or "")[:40],
-            "description": str(x.get("description","") or "")[:220],
-            "mimo": str(x.get("mimo", mimo) or mimo),
-            "why": str(x.get("why", default_why) or default_why)[:160],
-        }
-
-    s = _fix(out.get("stationary_omni", {}) if isinstance(out, dict) else {}, "Stationary omni best match.")
-    v = _fix(out.get("vehicle_omni", {}) if isinstance(out, dict) else {}, "Vehicle omni best match.")
-    if not s.get("part_number") and cand_stationary:
-        top = cand_stationary[0]
-        s = {"name": top.get("name","Parsec antenna"), "part_number": top.get("part_number",""), "description": top.get("description",""), "mimo": mimo, "why":"Stationary omni best match."}
-    if not v.get("part_number") and cand_vehicle:
-        top = cand_vehicle[0]
-        v = {"name": top.get("name","Parsec antenna"), "part_number": top.get("part_number",""), "description": top.get("description",""), "mimo": mimo, "why":"Vehicle omni best match."}
-    return {"stationary_omni": s, "vehicle_omni": v, "sources":["parsec_rag","gpt"]}
+    # 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 (no more ****; fill missing via GPT)
+# 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 == "Not applicable":
+    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:
@@ -638,7 +601,7 @@ def current_features_guess(life_row: pd.Series) -> Dict[str,str]:
     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"),
+        "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",
@@ -651,7 +614,6 @@ def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[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,
@@ -662,34 +624,28 @@ def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str
             feats.get("Ruggedness","Not listed"),
             feats.get("Use case","Not listed"),
         ]) + " |"
-
-    return "\n".join([header, sep, row("Current", cur), row("4G replacement", r4), row("5G replacement", r5)])
+    return "\n".join([header, sep, row("Current", cur), row("4G alternative", r4), row("5G replacement", r5)])
 
 
 # ============================
-# Output + Gradio UI
+# Output + Gradio
 # ============================
-def fmt(v: Any, fallback: str = "Not listed") -> str:
-    s = _safe_str(v)
-    if not s or s.lower() == "nan":
-        return fallback
-    return s
-
 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(" —")
 
-    # Antenna
     st = ant.get("stationary_omni", {})
     vh = ant.get("vehicle_omni", {})
 
-    # Feature table (fill missing via GPT)
     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 replacement", r4_feats, "")
-        r5_feats = gpt_fill_features("5G replacement", r5_feats, "")
+        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 = []
@@ -697,28 +653,19 @@ def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl:
     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 recommended replacement: **{fmt(repl.get('repl_4g'), 'Not applicable')}**")
-    # If 5G is empty, force GPT to pick from lifecycle pool
-    repl5 = fmt(repl.get("repl_5g"), "")
-    if (not repl5) and client is not None:
-        cand5 = _candidate_5g_models_from_lifecycle(str(life_row.get('_canon_make','UNKNOWN')))
-        repl5 = _gpt_pick_from_lifecycle_models(life_row, cand5, "5G replacement/upgrade") or (cand5[0] if cand5 else "")
-    if not repl5:
-        repl5 = "Not listed"
-    lines.append(f"6. 5G recommended replacement: **{repl5}**")
-
+    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): **{fmt(st.get('name'))}** (Part #: {fmt(st.get('part_number'))}) — {fmt(st.get('description'))} — MIMO: {fmt(st.get('mimo'))} — {fmt(st.get('why'))}")
-    lines.append(f"   - Vehicle (Omni): **{fmt(vh.get('name'))}** (Part #: {fmt(vh.get('part_number'))}) — {fmt(vh.get('description'))} — MIMO: {fmt(vh.get('mimo'))} — {fmt(vh.get('why'))}")
-
+    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("- dec2025routers.csv (features + fallback)")
+    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]):
@@ -741,7 +688,7 @@ def run_lookup(user_text: str, st: Dict[str,Any]):
 
     repl = pick_replacements_lifecycle(life_row, status)
 
-    tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") != "Not applicable" else ("4G" if _device_is_4g(life_row) else "Unknown")
+    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)
 
@@ -764,8 +711,7 @@ def use_selection(selected_label: str, st: Dict[str,Any]):
     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 applicable" else ("4G" if _device_is_4g(life_row) else "Unknown")
+    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)
 
@@ -773,7 +719,7 @@ def use_selection(selected_label: str, st: Dict[str,Any]):
 
 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", lines=1)
+    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")

only-routers_ai_poc_v4_6.ipynb

@@ -0,0 +1,768 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0300079d",
+   "metadata": {},
+   "source": [
+    "# 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": [
+    "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",
+    "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 (expanded — adds 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",
+    "DISPLAY_MAKER = {\n",
+    "    \"CRADLEPOINT\": \"Cradlepoint\",\n",
+    "    \"SIERRA\": \"Sierra Wireless\",\n",
+    "    \"FEENEY\": \"Feeney Wireless\",\n",
+    "    \"DIGI\": \"Digi\",\n",
+    "    \"CISCO_MERAKI\": \"Cisco Meraki\",\n",
+    "    \"CISCO\": \"Cisco\",\n",
+    "    \"TELTONIKA\": \"Teltonika\",\n",
+    "    \"UNKNOWN\": \"Unknown\",\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 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",
+    "    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",
+    "        # Teltonika family\n",
+    "        m = re.search(r\"\\bRUT[A-Z]?\\d{2,4}\\b\", cand.upper())\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "        # Digi IX-series\n",
+    "        m = re.search(r\"\\bIX\\d{2}\\b\", cand, flags=re.IGNORECASE)\n",
+    "        if m:\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",
+    "        if m:\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",
+    "        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",
+    "    # Pool within same manufacturer text (not just canon) to support Teltonika etc\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) -> 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",
+    "    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",
+    "\n",
+    "    # 4G alternative: ALWAYS if suggested_replacement exists for 4G devices\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\") or (cand4[0] if cand4 else \"\")\n",
+    "        if not repl_4g:\n",
+    "            repl_4g = \"Not applicable\"\n",
+    "\n",
+    "    # 5G replacement: ALWAYS when want_5g is true\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\") or (cand5[0] if cand5 else \"\")\n",
+    "        if not repl_5g:\n",
+    "            # last resort: dec catalog fallback\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,\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",
+    "    }\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Antennas (Parsec-only; family name extraction)\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_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",
+    "    # fallback near SKU line\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",
+    "            })\n",
+    "    return out\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",
+    "    cand_stationary = parsec_retrieve(q_stationary, 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",
+    "    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",
+    "    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\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 + 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",
+    "    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",
+    "\n",
+    "    # If dec doesn't know the model, ask GPT to fill missing cells (best guess)\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",
+    "    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.get('why','')}\")\n",
+    "    lines.append(\"8. Recommended features table:\")\n",
+    "    lines.append(table_md)\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 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), {}\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\n",
+    "\n",
+    "    if res.get(\"mode\") != \"ok\":\n",
+    "        return \"Not found.\", gr.update(visible=False), gr.update(visible=False), {}\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)\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",
+    "    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",
+    "\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",
+    "    if not st or st.get(\"mode\") != \"pick\":\n",
+    "        return \"Run a search first.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "    if not selected_label:\n",
+    "        return \"Pick A or B first.\", gr.update(visible=True), gr.update(visible=True), st\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\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)\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",
+    "    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",
+    "\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",
+    "    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",
+    "    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",
+    "\n",
+    "demo.launch()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}