Upload folder using huggingface_hub

app.py

@@ -26,10 +26,9 @@ from openai import OpenAI
 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"
 
+EMBED_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
 PARSEC_CONTEXT_BEFORE = 900
 PARSEC_CONTEXT_AFTER = 1600
 
@@ -42,26 +41,7 @@ client = OpenAI(api_key=API_KEY) if API_KEY else None
 
 
 # ============================
-# Gradio state helpers
-# IMPORTANT: We keep state as a JSON STRING to avoid HF / Gradio API schema crashes.
-# ============================
-def state_load(st_json: str) -> Dict[str, Any]:
-    try:
-        if not st_json:
-            return {}
-        return json.loads(st_json) if isinstance(st_json, str) else {}
-    except Exception:
-        return {}
-
-def state_dump(st: Dict[str, Any]) -> str:
-    try:
-        return json.dumps(st or {}, ensure_ascii=False)
-    except Exception:
-        return "{}"
-
-
-# ============================
-# Utilities
+# Helpers
 # ============================
 def norm_text(s: Any) -> str:
     try:
@@ -95,17 +75,14 @@ def gpt_json(system: str, payload: Dict[str, Any], max_tokens: int = 600) -> Dic
     resp = client.responses.create(
         model=OPENAI_MODEL,
         reasoning=OPENAI_REASONING,
-        input=[
-            {"role": "system", "content": system},
-            {"role": "user", "content": json.dumps(payload)},
-        ],
+        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)
+# Load data
 # ============================
 EOS_PATH = "routers_eos_eol_by_sku.csv"
 DEC_PATH = "dec2025routers.csv"
@@ -121,7 +98,6 @@ if not os.path.exists(PARSEC_PDF):
 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:
@@ -141,13 +117,6 @@ 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
-device_type_col = None
-for c in df_eos.columns:
-    if norm_text(c) == "device type":
-        device_type_col = c
-        break
-
 # Maker mapping (includes Teltonika)
 CANON_MAKER = {
     "CRADLEPOINT": {"cradlepoint", "ericsson", "ericsson enterprise wireless"},
@@ -270,7 +239,7 @@ parsec_index.add(parsec_emb)
 
 
 # ============================
-# Device resolution (exact SKU -> GPT A/B)
+# Device resolution
 # ============================
 def label_for_row(i: int) -> str:
     r = df_eos.iloc[i]
@@ -294,22 +263,20 @@ def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> D
         "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 one 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)
+    return gpt_json(sys, payload, max_tokens=280)
 
 def resolve_device(user_text: str) -> Dict[str, Any]:
     q = norm_text(user_text)
-
-    # Exact SKU match first
-    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]]
+    exact = df_eos.index[df_eos["_norm_sku"] == q].tolist()
+    if len(exact) == 1:
+        return {"mode":"ok","row_idx": int(exact[0])}
+    if len(exact) > 1:
+        opts = [{"row_idx": int(i), "label": EOS_LABELS[int(i)]} for i in exact[:2]]
         return {"mode":"pick","options": opts}
 
     cands = local_candidates(user_text, top_k=6)
@@ -329,7 +296,6 @@ def resolve_device(user_text: str) -> Dict[str, Any]:
         if opts2:
             return {"mode":"pick","options": opts2}
 
-    # fallback top 2
     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]}]}
@@ -414,7 +380,6 @@ def pick_replacements_lifecycle(row: pd.Series, status: str, use_gpt: bool = Tru
     is_4g = device_is_4g(row)
     want_5g = is_4g or (status in {"End of Sale","End of Life"})
 
-    # 4G alternative ALWAYS for 4G devices
     repl_4g = "Not applicable"
     if is_4g:
         repl_4g = extract_model_token(safe_str(row.get("suggested_replacement","")))
@@ -424,7 +389,6 @@ def pick_replacements_lifecycle(row: pd.Series, status: str, use_gpt: bool = Tru
         if not repl_4g:
             repl_4g = "Not applicable"
 
-    # 5G replacement ALWAYS when want_5g
     repl_5g = "Not listed"
     if want_5g:
         repl_5g = extract_model_token(safe_str(row.get("advanced_5g_option","")))
@@ -437,26 +401,14 @@ def pick_replacements_lifecycle(row: pd.Series, status: str, use_gpt: bool = Tru
     if repl_5g.lower() == "nan":
         repl_5g = "Not listed"
 
-    return {
-        "repl_4g": repl_4g,
-        "repl_5g": repl_5g,
-        "why": "Lifecycle replacements (GPT fallback when missing).",
-        "sources": ["lifecycle_csv"] + (["gpt"] if (use_gpt and client) else []) + (["dec_fallback"] if (want_5g and repl_5g == "Not listed") else []),
-    }
+    return {"repl_4g": repl_4g, "repl_5g": repl_5g, "sources": ["lifecycle_csv"] + (["gpt"] if (use_gpt and client) else [])}
 
 
 # ============================
-# Antennas (Parsec-only; family + connectors hint)
+# Antennas (Parsec-only)
 # ============================
-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"
-}
+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())
@@ -482,34 +434,18 @@ def family_from_line(line: str) -> str:
 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 re.sub(r"\s+", " ", m.group(1).strip())[: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]
-
     for ln in lines:
         if is_bad_name_line(ln):
             continue
         fam = family_from_line(ln)
         if fam:
             return fam
-
-    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:
@@ -524,7 +460,7 @@ 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 = []
+    out: List[Dict[str, Any]] = []
     for sc, i in zip(scores[0].tolist(), ids[0].tolist()):
         if 0 <= int(i) < len(parsec_cards):
             card = parsec_cards[int(i)]
@@ -538,7 +474,6 @@ def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:
     return out
 
 def infer_mimo_for_5g(model: str, canon_make: str) -> str:
-    # Use dec when possible; else simple heuristic
     if not model or model in {"Not applicable","Not listed"}:
         return "2x2"
     pool = df_dec[df_dec["_canon_make"] == canon_make].copy()
@@ -556,7 +491,6 @@ def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, An
     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)
-
     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."})
@@ -565,19 +499,14 @@ def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, An
 
 
 # ============================
-# Install-ready checklist (Feature #9)
+# Install-ready checklist
 # ============================
 def install_ready_checklist(current_sku: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:
     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. Return markdown only."
-        payload = {
-            "current_device": current_sku,
-            "replacements": repl,
-            "antennas": {"stationary": st, "vehicle": vh},
-            "rules": ["Keep it short. Include power + mount + cables + next steps."]
-        }
+        payload = {"current_device": current_sku, "replacements": repl, "antennas": {"stationary": st, "vehicle": vh}}
         resp = client.responses.create(
             model=OPENAI_MODEL,
             reasoning=OPENAI_REASONING,
@@ -585,24 +514,19 @@ def install_ready_checklist(current_sku: str, repl: Dict[str,Any], ant: Dict[str
             max_output_tokens=520,
         )
         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: {repl.get('repl_5g','')}")
-    lines.append(f"- 4G alternative: {repl.get('repl_4g','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 cable lengths + mounting + power; place order; schedule install.")
-    return "\n".join(lines)
+    return "\n".join([
+        "### Install-ready checklist",
+        f"- Current device: {current_sku}",
+        f"- 5G replacement: {repl.get('repl_5g','')}",
+        f"- 4G alternative: {repl.get('repl_4g','Not applicable')}",
+        f"- Stationary omni antenna: {st.get('name','')} (PN {st.get('part_number','')})",
+        f"- Vehicle omni antenna: {vh.get('name','')} (PN {vh.get('part_number','')})",
+        "- Next steps: confirm mounting + cable lengths + power; place order; schedule install.",
+    ])
 
 
 # ============================
-# Batch mode (Feature #4) — NO GPT for speed
+# Batch mode (NO GPT)
 # ============================
 def parse_batch_inputs(text_blob: str, file_obj: Any) -> List[str]:
     items: List[str] = []
@@ -636,36 +560,13 @@ def run_batch(text_blob: str, file_obj: Any, include_antennas: bool):
     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"
-            })
+            rows.append({"Input": item, "Matched":"", "Status":"Needs review", "EOS":"", "EOL":"", "4G alternative":"", "5G replacement":"", "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)
 
-        stA = ""
-        vhA = ""
-        if include_antennas:
-            canon_make = str(life_row.get("_canon_make","UNKNOWN"))
-            mimo = infer_mimo_for_5g(repl.get("repl_5g",""), canon_make)
-            tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") != "Not listed" else ("4G" if device_is_4g(life_row) else "Unknown")
-            ant = antenna_options_for(repl.get("repl_5g") or str(life_row.get("sku","")), tech, mimo)
-            s = ant.get("stationary_omni", {})
-            v = ant.get("vehicle_omni", {})
-            stA = f"{s.get('name','')} {s.get('part_number','')}"
-            vhA = f"{v.get('name','')} {v.get('part_number','')}"
-
         rows.append({
             "Input": item,
             "Matched": str(life_row.get("sku","")),
@@ -674,13 +575,10 @@ def run_batch(text_blob: str, file_obj: Any, include_antennas: bool):
             "EOL": eol,
             "4G alternative": repl.get("repl_4g",""),
             "5G replacement": repl.get("repl_5g",""),
-            "Stationary antenna": stA,
-            "Vehicle antenna": vhA,
             "Notes": "",
         })
 
     out_df = pd.DataFrame(rows)
-
     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()])
@@ -710,8 +608,8 @@ def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl:
     lines.append("7. Antenna options (Parsec-only):")
     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(f"   - Stationary (Omni): **{st.get('name','')}** (Part #: {st.get('part_number','')}) — {st.get('description','')} — MIMO: {st.get('mimo','')}{conn_s}")
+    lines.append(f"   - Vehicle (Omni): **{vh.get('name','')}** (Part #: {vh.get('part_number','')}) — {vh.get('description','')} — MIMO: {vh.get('mimo','')}{conn_v}")
 
     lines.append("\nSources (debug):")
     for s in repl.get("sources", []) if isinstance(repl.get("sources"), list) else []:
@@ -722,7 +620,8 @@ def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl:
 
 
 # ============================
-# Gradio callbacks (NO dict state)
+# Gradio callbacks
+# IMPORTANT: no dict state and ALL events have api_name=False (prevents api_info schema generation)
 # ============================
 def run_lookup(user_text: str, st_json: str):
     user_text = str(user_text or "").strip()
@@ -730,6 +629,7 @@ def run_lookup(user_text: str, st_json: str):
         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]
@@ -791,7 +691,7 @@ def make_install_ready(st_json: str):
 
 
 # ============================
-# Gradio UI
+# UI
 # ============================
 with gr.Blocks(title="Only-Routers") as demo:
     gr.Markdown("## Only-Routers\nSingle lookup + Batch upload for Verizon reps.")
@@ -799,7 +699,7 @@ with gr.Blocks(title="Only-Routers") as demo:
     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("{}")
+            st = gr.State("{}")  # JSON string
 
             check_btn = gr.Button("Check", variant="primary")
             pick_dd = gr.Dropdown(label="Pick A or B", choices=[], visible=False)
@@ -810,9 +710,9 @@ with gr.Blocks(title="Only-Routers") as demo:
             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.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st, install_md], api_name=False)
+            use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st, install_md], api_name=False)
+            install_btn.click(fn=make_install_ready, inputs=[st], outputs=[install_md], api_name=False)
 
         with gr.Tab("Batch"):
             gr.Markdown("Paste one per line or upload a CSV (first column). Batch runs fast (no GPT).")
@@ -826,11 +726,7 @@ with gr.Blocks(title="Only-Routers") as demo:
             table = gr.Dataframe(interactive=False, wrap=True)
             dl = gr.File(label="Download results CSV")
 
-            run_btn.click(fn=run_batch, inputs=[batch_text, batch_file, include_ant], outputs=[summary_md, table, dl, rollup_md])
-
+            run_btn.click(fn=run_batch, inputs=[batch_text, batch_file, include_ant], outputs=[summary_md, table, dl, rollup_md], api_name=False)
 
-# ============================
-# Launch (Hugging Face Spaces)
-# NOTE: Don't use share=True on Spaces.
-# ============================
-demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")), show_api=False)
+# IMPORTANT: On Spaces, demo.launch() is correct; do NOT use share=True.
+demo.launch(show_api=False)