show search results even when inventory is 0

app.py

@@ -17,7 +17,9 @@ _cache = {"data": None, "timestamp": 0, "last_update": "Unknown"}
 # ---------------- Load category map ----------------
 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")
 
@@ -136,8 +138,8 @@ def parse_freeform_query(text: str):
             return first, second
     return text, ""
 
-# ---------------- Improved semantic search ----------------
-def semantic_match(query, top_k=15, debug_top_n=8):
+# ---------------- Semantic Match ----------------
+def semantic_match(query, top_k=15, debug_top_n=5):
     """Full diagnostic semantic search — logs item and category similarity scores, fallback logic."""
     if not query:
         print("⚠️ semantic_match called with empty query")
@@ -146,67 +148,32 @@ def semantic_match(query, top_k=15, debug_top_n=8):
     query = query.strip().lower()
     print(f"\n🧠 [semantic_match] Input query: '{query}'")
 
-    try:
-        q_emb = embedder.encode(query, convert_to_tensor=True)
-    except Exception as e:
-        print(f"⚠️ Semantic encode error: {e}")
-        return {"category": None, "items": []}
-
-    # --- Item similarities ---
+    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)
-    top_items_preview = [f"{n} ({s:.2f})" for n, s in ranked_items[:debug_top_n]]
-    print(f"   🔸 Top item similarities: {', '.join(top_items_preview)}")
-
     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
-    print(f"   ✅ Found {len(item_hits)} item hits (top score={top_item_score:.2f})")
 
-    # --- Category similarities ---
     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_cats_preview = [f"{c} ({s:.2f})" for c, s in ranked_cats[:debug_top_n]]
-    print(f"   🔹 Top category similarities: {', '.join(top_cats_preview)}")
-
     top_cat, cat_score = (ranked_cats[0] if ranked_cats else (None, 0.0))
-    strong_category = cat_score > 0.35
-    weak_items = len(item_hits) == 0 or (top_item_score < 0.4)
-    clearly_better = cat_score - top_item_score > 0.1
-
-    print(f"   💡 top_cat={top_cat}, cat_score={cat_score:.2f}, strong_category={strong_category}, "
-          f"weak_items={weak_items}, clearly_better={clearly_better}")
-
-    # --- Heuristic substring fallback ---
-    if not top_cat:
-        for c in CATEGORY_EMBEDS.keys():
-            if c in query or query in c:
-                print(f"   🧩 Heuristic substring fallback → '{c}'")
-                top_cat = c
-                strong_category = True
-                cat_score = 0.5
-                break
-
-    # --- Plural heuristic ---
-    if not top_cat and query.endswith("s"):
-        singular = query[:-1]
-        if singular in CATEGORY_EMBEDS:
-            print(f"   🧩 Plural fallback → '{singular}'")
-            top_cat = singular
-            strong_category = True
-            cat_score = 0.5
-
-    # --- Decision ---
-    if top_cat and (strong_category and (weak_items or clearly_better)):
-        related_items = [n for n, t in ITEM_TO_TYPE.items() if t and t == top_cat]
-        print(f"✅ [FALLBACK] '{query}' → category '{top_cat}' "
-              f"({len(related_items)} items, cat_score={cat_score:.2f}, item_score={top_item_score:.2f})")
-        return {"category": top_cat, "items": related_items}
 
-    print(f"🚫 No semantic fallback triggered for '{query}' — returning {len(item_hits)} item matches.")
-    return {"category": None, "items": item_hits}
+    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}")
 
+    # Always include category items if strong enough
+    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):
@@ -259,9 +226,16 @@ def query_inventory(query_text="", category="", country_name="", capacity=10, re
         else:
             country_ok = True
 
-        for item in cdata.get("stocks", []):
-            iname = item.get("name", "")
+        if not country_ok:
+            continue
+
+        # --- Merge with all known items (show zeroes too) ---
+        live_lookup = {i["name"]: i for i in cdata.get("stocks", [])}
+        for iname in ALL_ITEMS:
             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 = (
@@ -274,9 +248,7 @@ def query_inventory(query_text="", category="", country_name="", capacity=10, re
             else:
                 item_ok = True
 
-            if country_ok and item_ok:
-                cost = item.get("cost", 0)
-                qty = item.get("quantity", 0)
+            if item_ok:
                 rows.append({
                     "Country": cname,
                     "Item": iname,
@@ -288,6 +260,7 @@ def query_inventory(query_text="", category="", country_name="", capacity=10, re
                 })
 
     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)
@@ -321,6 +294,7 @@ 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"
+                "Shows items even if out of stock.  \n"
                 "Your travel capacity is saved automatically for next time.")
     with gr.Row():
         query_box.render()