try fixes again

app.py

@@ -19,7 +19,6 @@ with open("items.json", "r", encoding="utf-8") as f:
     items_data = json.load(f)["items"]
 
 ITEM_TO_TYPE = {v["name"]: v["type"].lower() for v in items_data.values() if "name" in v and "type" in v}
-ALL_ITEMS = list(ITEM_TO_TYPE.keys())
 ALL_CATEGORIES = sorted(set(ITEM_TO_TYPE.values()))
 ITEM_FILE_MTIME = os.path.getmtime("items.json")
 
@@ -67,7 +66,6 @@ def save_cached_embeddings(aliases, embeds):
         print(f"⚠️ Cache save failed: {e}")
 
 def auto_alias_categories(embedder, all_categories, all_item_names, top_k=6, threshold=0.38):
-    """Builds semantic aliases for each category by finding similar item names."""
     print("🤖 Building category aliases dynamically...")
     cat_embs = {c: embedder.encode(c, convert_to_tensor=True) for c in all_categories}
     item_embs = {i: embedder.encode(i, convert_to_tensor=True) for i in all_item_names}
@@ -120,12 +118,13 @@ def normalize_country_query(q: str) -> str | None:
         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)
+    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()
@@ -137,23 +136,29 @@ def parse_freeform_query(text: str):
             return first, second
     return text, ""
 
+# ---------------- Semantic Match ----------------
 def semantic_match(query, top_k=15):
     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"]
@@ -172,19 +177,14 @@ def fetch_yata(force_refresh=False):
         print(f"❌ Fetch error: {e}")
         return {"stocks": {}}, "Fetch failed"
 
-# ✅ Persistent capacity memory (server side)
-_user_capacity = 10
-
+# ---------------- Core logic ----------------
 def query_inventory(query_text="", category="", country_name="", capacity=10, refresh=False):
-    global _user_capacity
-    if capacity != _user_capacity:
-        print(f"🔄 Updating stored capacity: {_user_capacity} → {capacity}")
-        _user_capacity = capacity
-
+    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 = []
 
+    # Parse query
     parsed_item, parsed_country = parse_freeform_query(query_text)
     if not country_name and parsed_country:
         country_name = parsed_country
@@ -192,38 +192,43 @@ def query_inventory(query_text="", category="", country_name="", capacity=10, re
     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)
 
-    COUNTRY_CATALOG = {code.upper(): {i["name"] for i in cdata.get("stocks", [])} for code, cdata in stocks.items()}
+    # Country gating (strict)
+    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:
                 if code != user_code:
                     continue
             elif country_name.lower() not in cname.lower():
                 continue
+
         update_ts = cdata.get("update")
         update_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(update_ts)) if update_ts else "Unknown"
-        live_lookup = {i["name"]: i for i in cdata.get("stocks", [])}
-        candidate_names = sorted(COUNTRY_CATALOG.get(code, set()))
 
-        for iname in candidate_names:
+        # ONLY iterate this country's actual items (no global catalog)
+        for item in cdata.get("stocks", []):
+            iname = item.get("name", "")
             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)
-            item_ok = (
-                (item_term and (
+            qty = item.get("quantity", 0)
+            cost = item.get("cost", 0)
+
+            # Item filter
+            if item_term:
+                item_ok = (
                     item_term.lower() in iname.lower()
                     or iname in semantic_items
                     or (semantic_category and itype == semantic_category.lower())
-                ))
-                or (category and category.lower() == itype)
-                or (not item_term and not category)
-            )
+                )
+            elif category:
+                item_ok = category.lower() == itype
+            else:
+                item_ok = True
+
             if item_ok:
                 rows.append({
                     "Country": cname,
@@ -231,7 +236,8 @@ def query_inventory(query_text="", category="", country_name="", capacity=10, re
                     "Category": itype.title() if itype else "",
                     "Quantity": qty,
                     "Cost": cost,
-                    "Max Capacity Cost": cost * _user_capacity,
+                    # IMPORTANT: use the function arg 'capacity' directly
+                    "Max Capacity Cost": cost * capacity,
                     "Updated": update_str,
                 })
 
@@ -242,20 +248,37 @@ def query_inventory(query_text="", category="", country_name="", capacity=10, re
     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} | Capacity: {_user_capacity}"
+    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)
 
+# ---------------- Gradio UI ----------------
 with gr.Blocks(title="🧳 Torn Inventory Viewer") as iface:
     gr.Markdown("## 🧳 Torn Inventory Viewer")
-    gr.Markdown("_Search Torn YATA travel stocks with semantic and persistent capacity._")
+    gr.Markdown("_Search Torn YATA travel stocks with semantic matching._")
+
+    query_box = gr.Textbox(label="Search (semantic, e.g. 'flowers in England')", elem_id="qbox")
+    category_drop = gr.Dropdown(label="Category (optional exact match)", choices=[""] + ALL_CATEGORIES, elem_id="catdrop")
+    country_box = gr.Textbox(label="Country (optional, e.g. UK, Cayman, Japan)", elem_id="countrybox")
+    capacity_slider = gr.Number(label="Travel Capacity", value=10, minimum=5, maximum=88, precision=0, elem_id="cap_num")
+    refresh_check = gr.Checkbox(label="Force refresh (ignore cache)", value=False)
+
+    # Hidden bridge for capacity → backend init
+    cap_bridge = gr.Textbox(visible=False, elem_id="cap_bridge")
+
+    def apply_bridge(cap_text):
+        try:
+            v = float(cap_text)
+            if 5 <= v <= 88:
+                return gr.Number.update(value=v)
+        except:
+            pass
+        return gr.Number.update()  # no change
 
-    query_box = gr.Textbox(label="Search (e.g. 'flowers in England')")
-    category_drop = gr.Dropdown(label="Category", choices=[""] + ALL_CATEGORIES)
-    country_box = gr.Textbox(label="Country")
-    capacity_slider = gr.Number(label="Travel Capacity", value=_user_capacity, minimum=5, maximum=88, precision=0)
-    refresh_check = gr.Checkbox(label="Force refresh", value=False)
+    # When the bridge receives a value, update the slider (so backend sees it)
+    cap_bridge.change(apply_bridge, inputs=[cap_bridge], outputs=[capacity_slider])
 
     run_btn = gr.Button("🔍 Search / Refresh")
     result_df = gr.Dataframe(label="Results")
@@ -265,6 +288,7 @@ with gr.Blocks(title="🧳 Torn Inventory Viewer") as iface:
                   inputs=[query_box, category_drop, country_box, capacity_slider, refresh_check],
                   outputs=[result_df, meta_box])
 
+    # --- Shadow-DOM aware JS: restore capacity & push into hidden bridge BEFORE first search ---
     gr.HTML("""
     <script>
     (function () {
@@ -272,24 +296,42 @@ with gr.Blocks(title="🧳 Torn Inventory Viewer") as iface:
         const app = document.querySelector('gradio-app');
         return app && app.shadowRoot ? app.shadowRoot : document;
       }
-      function restoreOnce() {
+      function el(sel) { return root().querySelector(sel); }
+
+      function restoreCapacity() {
         const saved = localStorage.getItem('travel_capacity');
-        const r = root();
-        const field = r.querySelector('input[type=number]');
-        if (saved && field) field.value = saved;
-      }
-      function attachSaver() {
-        const r = root();
-        const field = r.querySelector('input[type=number]');
-        if (!field || field.dataset.tcListen === '1') return;
-        field.dataset.tcListen = '1';
-        field.addEventListener('input', () => {
-          localStorage.setItem('travel_capacity', field.value);
-        });
+        const capField = el('#cap_num input[type=number]');
+        const bridge = el('#cap_bridge textarea');
+
+        if (saved && capField) {
+          // Update visible field
+          capField.value = saved;
+          // Update frontend state
+          capField.dispatchEvent(new Event('input', { bubbles: true }));
+          // Push into hidden bridge -> triggers backend .change -> updates slider value server-side
+          if (bridge) {
+            bridge.value = saved;
+            bridge.dispatchEvent(new Event('input', { bubbles: true }));
+            bridge.dispatchEvent(new Event('change', { bubbles: true }));
+          }
+        }
+
+        // Save on changes
+        if (capField && !capField.dataset.synced) {
+          capField.dataset.synced = '1';
+          capField.addEventListener('input', () => {
+            localStorage.setItem('travel_capacity', capField.value);
+          });
+        }
       }
+
       window.addEventListener('DOMContentLoaded', () => {
-        setTimeout(() => { restoreOnce(); attachSaver(); }, 500);
+        setTimeout(restoreCapacity, 500);
       });
+
+      // Keep trying on re-renders
+      const obs = new MutationObserver(() => setTimeout(restoreCapacity, 100));
+      obs.observe(document.documentElement, { childList: true, subtree: true });
     })();
     </script>
     """)
@@ -299,4 +341,5 @@ try:
     iface.launch()
 except Exception as e:
     import traceback
+    print("❌ Application failed to start:")
     traceback.print_exc()