fix copy/paste error

app.py

@@ -306,493 +306,4 @@ try:
 except Exception as e:
     import traceback
     print("❌ Failed to start:")
-    traceback.print_exc()if not CATEGORY_ALIASES or not CATEGORY_EMBEDS:
-    CATEGORY_ALIASES = auto_alias_categories(embedder, ALL_CATEGORIES, list(ITEM_TO_TYPE.keys()))
-    CATEGORY_EMBEDS = {
-        cat: sum([embedder.encode(a, convert_to_tensor=True) for a in aliases]) / len(aliases)
-        for cat, aliases in CATEGORY_ALIASES.items()
-    }
-    save_cached_embeddings(CATEGORY_ALIASES, CATEGORY_EMBEDS)
-else:
-    print("✅ Using cached dynamic category embeddings.")
-
-# ---------------- Country mapping ----------------
-COUNTRY_NAMES = {
-    "ARG": "Argentina", "MEX": "Mexico", "CAN": "Canada", "UNI": "United Kingdom",
-    "JAP": "Japan", "SOU": "South Africa", "SWI": "Switzerland", "UAE": "United Arab Emirates",
-    "CHI": "China", "HAW": "Hawaii", "CAY": "Cayman Islands"
-}
-COUNTRY_ALIASES = {
-    "uk": "UNI", "england": "UNI", "united kingdom": "UNI",
-    "uae": "UAE", "united arab emirates": "UAE",
-    "south africa": "SOU", "switzerland": "SWI",
-    "cayman": "CAY", "cayman islands": "CAY",
-    "argentina": "ARG", "mexico": "MEX", "canada": "CAN",
-    "japan": "JAP", "china": "CHI", "hawaii": "HAW"
-}
-
-def normalize_country_query(q: str) -> str | None:
-    q = (q or "").strip().lower()
-    if not q:
-        return None
-    if q in COUNTRY_ALIASES:
-        return COUNTRY_ALIASES[q]
-    if len(q) == 3 and q.upper() in COUNTRY_NAMES:
-        return q.upper()
-    return None
-
-def parse_freeform_query(text: str):
-    """Supports 'plushies in uk' and 'uk plushies'."""
-    if not text:
-        return "", ""
-    text = text.strip().lower()
-    m = re.match(r"(.+?)\\s+in\\s+(.+)", text, flags=re.IGNORECASE)
-    if m:
-        return m.group(1).strip(), m.group(2).strip()
-    parts = text.split()
-    if len(parts) == 2:
-        first, second = parts
-        if normalize_country_query(first):
-            return second, first
-        elif normalize_country_query(second):
-            return first, second
-    return text, ""
-
-# ---------------- Semantic Match ----------------
-def semantic_match(query, top_k=15, debug_top_n=5):
-    if not query:
-        return {"category": None, "items": []}
-
-    query = query.strip().lower()
-    q_emb = embedder.encode(query, convert_to_tensor=True)
-    sims_items = {n: float(util.cos_sim(q_emb, emb)) for n, emb in ITEM_EMBEDS.items()}
-    ranked_items = sorted(sims_items.items(), key=lambda x: x[1], reverse=True)
-    item_hits = [n for n, score in ranked_items[:top_k] if score > 0.35]
-
-    sims_cats = {c: float(util.cos_sim(q_emb, emb)) for c, emb in CATEGORY_EMBEDS.items()}
-    ranked_cats = sorted(sims_cats.items(), key=lambda x: x[1], reverse=True)
-    top_cat, cat_score = (ranked_cats[0] if ranked_cats else (None, 0.0))
-
-    related_items = []
-    if top_cat and cat_score > 0.35:
-        related_items = [n for n, t in ITEM_TO_TYPE.items() if t == top_cat]
-
-    combined = list(set(item_hits + related_items))
-    return {"category": top_cat if related_items else None, "items": combined}
-
-# ---------------- Fetch YATA ----------------
-def fetch_yata(force_refresh=False):
-    if not force_refresh and _cache["data"] and (time.time() - _cache["timestamp"] < 300):
-        return _cache["data"], _cache["last_update"]
-    try:
-        resp = requests.get(API_URL, timeout=10)
-        resp.raise_for_status()
-        data = resp.json()
-        _cache.update({
-            "data": data,
-            "timestamp": time.time(),
-            "last_update": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-        })
-        print(f"✅ Fetched YATA data at {_cache['last_update']}")
-        return data, _cache["last_update"]
-    except Exception as e:
-        print(f"❌ Fetch error: {e}")
-        return {"stocks": {}}, "Fetch failed"
-
-# ---------------- Core logic ----------------
-def query_inventory(query_text="", category="", country_name="", capacity=10, refresh=False):
-    data, last_update = fetch_yata(force_refresh=refresh)
-    stocks = data.get("stocks", {})
-    rows = []
-
-    parsed_item, parsed_country = parse_freeform_query(query_text)
-    if not country_name and parsed_country:
-        country_name = parsed_country
-    item_term = parsed_item
-    semantic_result = semantic_match(item_term) if item_term else {"category": None, "items": []}
-    semantic_items = semantic_result["items"]
-    semantic_category = semantic_result["category"]
-
-    user_code = normalize_country_query(country_name)
-
-    for code_raw, cdata in stocks.items():
-        code = code_raw.upper()
-        cname = COUNTRY_NAMES.get(code, code)
-        if country_name:
-            if user_code:
-                country_ok = (user_code == code)
-            else:
-                country_ok = country_name.lower() in cname.lower()
-        else:
-            country_ok = True
-
-        if not country_ok:
-            continue
-
-        for item in cdata.get("stocks", []):
-            iname = item.get("name", "")
-            itype = ITEM_TO_TYPE.get(iname, "").lower()
-            qty = item.get("quantity", 0)
-            cost = item.get("cost", 0)
-
-            if item_term:
-                item_ok = (
-                    item_term.lower() in iname.lower()
-                    or iname in semantic_items
-                    or (semantic_category and itype == semantic_category.lower())
-                )
-            elif category:
-                item_ok = category.lower() == itype
-            else:
-                item_ok = True
-
-            if item_ok:
-                rows.append({
-                    "Country": cname,
-                    "Item": iname,
-                    "Category": itype.title(),
-                    "Quantity": qty,
-                    "Cost": cost,
-                    "Max Capacity Cost": cost * capacity,
-                })
-
-    if not rows:
-        return pd.DataFrame([{"Result": "No inventory found for that query."}]), f"Last update: {last_update}"
-
-    df = pd.DataFrame(rows)
-    df = df.sort_values(by=["Country", "Item"])
-    for col in ["Quantity", "Cost", "Max Capacity Cost"]:
-        if col in df.columns:
-            df[col] = df[col].apply(lambda x: f"{x:,.0f}" if isinstance(x, (int, float)) and x != "" else x)
-    return df, f"Last update: {last_update}"
-
-# ---------------- Wrapper ----------------
-def run_query(query_text, category, country, capacity, refresh):
-    return query_inventory(query_text, category, country, capacity, refresh)
-
-def init_capacity(saved_capacity):
-    try:
-        if saved_capacity and 5 <= float(saved_capacity) <= 88:
-            return float(saved_capacity)
-    except Exception:
-        pass
-    return 10
-
-# ---------------- Gradio UI ----------------
-with gr.Blocks(title="🧳 Torn Inventory Viewer") as iface:
-    gr.Markdown("## 🧳 Torn Inventory Viewer")
-    gr.Markdown("_Search Torn YATA travel stocks with smart semantic matching._")
-
-    query_box = gr.Textbox(label="Search (semantic, e.g. 'flowers in England')")
-    category_drop = gr.Dropdown(label="Category (optional exact match)", choices=[""] + ALL_CATEGORIES)
-    country_box = gr.Textbox(label="Country (optional, e.g. UK, Cayman, Japan)")
-    capacity_slider = gr.Number(label="Travel Capacity", value=10, minimum=5, maximum=88, precision=0)
-    refresh_check = gr.Checkbox(label="Force refresh (ignore cache)", value=False)
-    saved_capacity_state = gr.State(value=None)
-
-    iface.load(init_capacity, inputs=[saved_capacity_state], outputs=[capacity_slider])
-
-    run_btn = gr.Button("🔍 Search / Refresh")
-    result_df = gr.Dataframe(label="Results")
-    meta_box = gr.Textbox(label="Metadata / Last Update")
-
-    run_btn.click(run_query,
-                  inputs=[query_box, category_drop, country_box, capacity_slider, refresh_check],
-                  outputs=[result_df, meta_box])
-
-    gr.HTML("""
-    <script>
-      function syncCapacity() {
-        const saved = localStorage.getItem('travel_capacity');
-        const stateEl = document.querySelector('textarea[name="saved_capacity_state"]');
-        if (stateEl && saved) {
-          stateEl.value = saved;
-          stateEl.dispatchEvent(new Event('input', { bubbles: true }));
-        }
-        const capField = document.querySelector('input[type=number]');
-        if (capField) {
-          capField.addEventListener('input', () => {
-            localStorage.setItem('travel_capacity', capField.value);
-          });
-        } else {
-          setTimeout(syncCapacity, 400);
-        }
-      }
-      setTimeout(syncCapacity, 800);
-    </script>
-    """)
-
-try:
-    iface.launch()
-except Exception as e:
-    import traceback
-    print("❌ Failed to start:")
-    traceback.print_exc()if not CATEGORY_ALIASES or not CATEGORY_EMBEDS:
-    CATEGORY_ALIASES = auto_alias_categories(embedder, ALL_CATEGORIES, list(ITEM_TO_TYPE.keys()))
-    CATEGORY_EMBEDS = {
-        cat: sum([embedder.encode(a, convert_to_tensor=True) for a in aliases]) / len(aliases)
-        for cat, aliases in CATEGORY_ALIASES.items()
-    }
-    save_cached_embeddings(CATEGORY_ALIASES, CATEGORY_EMBEDS)
-else:
-    print("✅ Using cached dynamic category embeddings.")
-
-# ---------------- Country mapping ----------------
-COUNTRY_NAMES = {
-    "ARG": "Argentina", "MEX": "Mexico", "CAN": "Canada", "UNI": "United Kingdom",
-    "JAP": "Japan", "SOU": "South Africa", "SWI": "Switzerland", "UAE": "United Arab Emirates",
-    "CHI": "China", "HAW": "Hawaii", "CAY": "Cayman Islands"
-}
-COUNTRY_ALIASES = {
-    "uk": "UNI", "england": "UNI", "united kingdom": "UNI",
-    "uae": "UAE", "united arab emirates": "UAE",
-    "south africa": "SOU", "switzerland": "SWI",
-    "cayman": "CAY", "cayman islands": "CAY",
-    "argentina": "ARG", "mexico": "MEX", "canada": "CAN",
-    "japan": "JAP", "china": "CHI", "hawaii": "HAW"
-}
-
-def normalize_country_query(q: str) -> str | None:
-    q = (q or "").strip().lower()
-    if not q:
-        return None
-    if q in COUNTRY_ALIASES:
-        return COUNTRY_ALIASES[q]
-    if len(q) == 3 and q.upper() in COUNTRY_NAMES:
-        return q.upper()
-    return None
-
-# ---------------- Helpers ----------------
-def parse_freeform_query(text: str):
-    """Supports 'plushies in uk' and 'uk plushies'."""
-    if not text:
-        return "", ""
-    text = text.strip().lower()
-    m = re.match(r"(.+?)\s+in\s+(.+)", text, flags=re.IGNORECASE)
-    if m:
-        return m.group(1).strip(), m.group(2).strip()
-    parts = text.split()
-    if len(parts) == 2:
-        first, second = parts
-        if normalize_country_query(first):
-            return second, first
-        elif normalize_country_query(second):
-            return first, second
-    return text, ""
-
-# ---------------- Semantic Match ----------------
-def semantic_match(query, top_k=15, debug_top_n=5):
-    if not query:
-        print("⚠️ semantic_match called with empty query")
-        return {"category": None, "items": []}
-
-    query = query.strip().lower()
-    print(f"\n🧠 [semantic_match] Input query: '{query}'")
-
-    q_emb = embedder.encode(query, convert_to_tensor=True)
-    sims_items = {n: float(util.cos_sim(q_emb, emb)) for n, emb in ITEM_EMBEDS.items()}
-    ranked_items = sorted(sims_items.items(), key=lambda x: x[1], reverse=True)
-    item_hits = [n for n, score in ranked_items[:top_k] if score > 0.35]
-    top_item_score = float(ranked_items[0][1]) if ranked_items else 0.0
-
-    sims_cats = {c: float(util.cos_sim(q_emb, emb)) for c, emb in CATEGORY_EMBEDS.items()}
-    ranked_cats = sorted(sims_cats.items(), key=lambda x: x[1], reverse=True)
-    top_cat, cat_score = (ranked_cats[0] if ranked_cats else (None, 0.0))
-
-    print(f"   🔸 Top item similarities: {[f'{n} ({s:.2f})' for n, s in ranked_items[:debug_top_n]]}")
-    print(f"   🔹 Top category similarities: {[f'{c} ({s:.2f})' for c, s in ranked_cats[:debug_top_n]]}")
-    print(f"   💡 top_cat={top_cat}, cat_score={cat_score:.2f}, top_item_score={top_item_score:.2f}")
-
-    related_items = []
-    if top_cat and cat_score > 0.35:
-        related_items = [n for n, t in ITEM_TO_TYPE.items() if t and t == top_cat]
-        print(f"✅ [CATEGORY DETECTED] '{query}' → '{top_cat}' ({len(related_items)} items, score={cat_score:.2f})")
-
-    combined = list(set(item_hits + related_items))
-    if combined:
-        return {"category": top_cat if related_items else None, "items": combined}
-
-    print(f"🚫 No semantic matches returned for '{query}'")
-    return {"category": None, "items": []}
-
-# ---------------- Fetch YATA ----------------
-def fetch_yata(force_refresh=False):
-    if not force_refresh and _cache["data"] and (time.time() - _cache["timestamp"] < 300):
-        return _cache["data"], _cache["last_update"]
-    headers = {"User-Agent": "Mozilla/5.0", "Accept": "application/json"}
-    try:
-        resp = requests.get(API_URL, headers=headers, timeout=10)
-        resp.raise_for_status()
-        data = resp.json()
-        _cache.update({
-            "data": data,
-            "timestamp": time.time(),
-            "last_update": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-        })
-        print(f"✅ Fetched YATA data at {_cache['last_update']}")
-        return data, _cache["last_update"]
-    except Exception as e:
-        print(f"❌ Fetch error: {e}")
-        return {"stocks": {}}, "Fetch failed"
-
-# ---------------- Core logic ----------------
-def query_inventory(query_text="", category="", country_name="", capacity=10, refresh=False):
-    print(f"🔎 Query received: '{query_text}', category='{category}', country='{country_name}', cap={capacity}")
-    data, last_update = fetch_yata(force_refresh=refresh)
-    stocks = data.get("stocks", {})
-    rows = []
-
-    parsed_item, parsed_country = parse_freeform_query(query_text)
-    if not country_name and parsed_country:
-        country_name = parsed_country
-    item_term = parsed_item
-    semantic_result = semantic_match(item_term) if item_term else {"category": None, "items": []}
-    semantic_items = semantic_result["items"]
-    semantic_category = semantic_result["category"]
-
-    user_code = normalize_country_query(country_name)
-
-    for code_raw, cdata in stocks.items():
-        code = code_raw.upper()
-        cname = COUNTRY_NAMES.get(code, code)
-        update_ts = cdata.get("update")
-        update_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_ts)) if update_ts else "Unknown"
-
-        if country_name:
-            if user_code:
-                country_ok = (user_code == code)
-            else:
-                country_ok = country_name.lower() in cname.lower()
-        else:
-            country_ok = True
-
-        if not country_ok:
-            continue
-
-        # --- Only use this country's actual stock catalog ---
-        live_lookup = {i["name"]: i for i in cdata.get("stocks", [])}
-        candidate_names = list(live_lookup.keys())
-
-        for iname in candidate_names:
-            itype = ITEM_TO_TYPE.get(iname, "").lower()
-            item_data = live_lookup.get(iname, {"quantity": 0, "cost": 0})
-            qty = item_data.get("quantity", 0)
-            cost = item_data.get("cost", 0)
-
-            if item_term:
-                item_ok = (
-                    item_term.lower() in iname.lower()
-                    or iname in semantic_items
-                    or (semantic_category and itype == semantic_category.lower())
-                )
-            elif category:
-                item_ok = category.lower() == itype
-            else:
-                item_ok = True
-
-            if item_ok:
-                rows.append({
-                    "Country": cname,
-                    "Item": iname,
-                    "Category": itype.title() if itype else "",
-                    "Quantity": qty,
-                    "Cost": cost,
-                    "Max Capacity Cost": cost * capacity,
-                    "Updated": update_str
-                })
-
-    if not rows:
-        print(f"⚠️ No '{item_term}' items found in {country_name.title()} — likely out of stock.")
-        return pd.DataFrame([{"Result": "No inventory found for that query."}]), f"Last update: {last_update}"
-
-    df = pd.DataFrame(rows)
-    df = df.sort_values(by=["Country", "Item"])
-    total_quantity = pd.to_numeric(df["Quantity"], errors="coerce").sum()
-    df.loc[len(df)] = {
-        "Country": "—", "Item": "TOTAL", "Category": "",
-        "Quantity": total_quantity, "Cost": "", "Max Capacity Cost": "", "Updated": ""
-    }
-
-    for col in ["Quantity", "Cost", "Max Capacity Cost"]:
-        if col in df.columns:
-            df[col] = df[col].apply(lambda x: f"{x:,.0f}" if isinstance(x, (int, float)) and x != "" else x)
-
-    df = df[["Country", "Item", "Category", "Quantity", "Cost", "Max Capacity Cost", "Updated"]]
-    return df, f"Last update: {last_update}"
-
-# ---------------- Wrapper ----------------
-def run_query(query_text, category, country, capacity, refresh):
-    df, ts = query_inventory(query_text, category, country, capacity, refresh)
-    return df, ts
-
-# ---------------- Gradio UI ----------------
-query_box = gr.Textbox(label="Search (semantic, e.g. 'flowers in England')")
-category_drop = gr.Dropdown(label="Category (optional exact match)", choices=[""] + ALL_CATEGORIES, value="")
-country_box = gr.Textbox(label="Country (optional, e.g. UK, Cayman, Japan)")
-capacity_slider = gr.Number(label="Travel Capacity", value=10, minimum=5, maximum=88, precision=0)
-refresh_check = gr.Checkbox(label="Force refresh (ignore cache)", value=False)
-saved_capacity_state = gr.State(value=None)
-
-def init_capacity(saved_capacity):
-    """Initialize slider with saved value (from browser localStorage)."""
-    try:
-        if saved_capacity and 5 <= float(saved_capacity) <= 88:
-            print(f"🔁 Restoring saved travel capacity: {saved_capacity}")
-            return float(saved_capacity)
-    except Exception:
-        pass
-    return 10  # fallback default
-
-with gr.Blocks(title="🧳 Torn Inventory Viewer") as iface:
-    gr.Markdown("## 🧳 Torn Inventory Viewer")
-    gr.Markdown("_Search Torn YATA travel stocks with smart semantic matching_  \n"
-                "Try phrases like **'flowers in England'**, **'plushies in UK'**, or **'xanax'**.  \n")
-
-    with gr.Row():
-        query_box.render()
-        category_drop.render()
-        country_box.render()
-    with gr.Row():
-        capacity_slider.render()
-        refresh_check.render()
-
-    run_btn = gr.Button("🔍 Search / Refresh")
-    result_df = gr.Dataframe(label="Results")
-    meta_box = gr.Textbox(label="Metadata / Last Update")
-
-    # When JS sends saved capacity, initialize the number field
-    iface.load(init_capacity, inputs=[saved_capacity_state], outputs=[capacity_slider])
-
-    run_btn.click(fn=run_query,
-                  inputs=[query_box, category_drop, country_box, capacity_slider, refresh_check],
-                  outputs=[result_df, meta_box])
-
-    # --- JS bridge to load and save localStorage ---
-    gr.HTML("""
-    <script>
-      function syncCapacity() {
-        const saved = localStorage.getItem('travel_capacity');
-        // Send saved capacity to backend Gradio state
-        if (saved) {
-          const gradioApp = window.gradioApp || document.querySelector('gradio-app')?.shadowRoot;
-          if (gradioApp) {
-            const pyInput = gradioApp.querySelector('textarea[name="saved_capacity_state"]');
-            if (pyInput) {
-              pyInput.value = saved;
-              pyInput.dispatchEvent(new Event('input', { bubbles: true }));
-            }
-          }
-        }
-        // Monitor changes to save updates
-        const capField = document.querySelector('input[type=number]');
-        if (capField) {
-          capField.addEventListener('input', () => {
-            localStorage.setItem('travel_capacity', capField.value);
-          });
-        } else {
-          setTimeout(syncCapacity, 400);
-        }
-      }
-      setTimeout(syncCapacity, 800);
-    </script>
-    """)
+    traceback.print_exc()