try fix again

app.py

@@ -331,6 +331,227 @@ COUNTRY_ALIASES = {
     "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: