Update app.py

app.py

@@ -20,6 +20,7 @@ with open("items.json", "r", encoding="utf-8") as f:
 
 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_ITEMS_LOWER = {name.lower(): name for name in ALL_ITEMS}
 ALL_CATEGORIES = sorted(set(ITEM_TO_TYPE.values()))
 ITEM_FILE_MTIME = os.path.getmtime("items.json")
 
@@ -115,7 +116,7 @@ def parse_freeform_query(text: str):
     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()
@@ -155,7 +156,7 @@ def fetch_yata(force_refresh=False):
         _cache.update({
             "data": data,
             "timestamp": time.time(),
-            "last_update": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+            "last_update": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())  # UTC ISO
         })
         return data, _cache["last_update"]
     except Exception as e:
@@ -172,38 +173,62 @@ def get_live_categories(data):
                 live_cats.add(cat.lower())
     return sorted(live_cats)
 
-# ---------------- Core logic ----------------
+# ---------------- Core logic: single query ----------------
 def query_inventory(query_text="", category="", country_name="", capacity=10, refresh=False):
     data, last_update = fetch_yata(force_refresh=refresh)
     rows = []
+
+    # Parse freeform if present
     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"]
+
+    # Detect if user meant an exact item (e.g., "xanax")
+    item_lower = (item_term or "").lower()
+    exact_item_name = ALL_ITEMS_LOWER.get(item_lower)
+    sem = semantic_match(item_term) if item_term and not exact_item_name else {"category": None, "items": []}
+    semantic_items = sem["items"]
+    semantic_category = sem["category"]
+
+    # Country gating (strict)
     user_code = normalize_country_query(country_name)
+
     for code_raw, cdata in data.get("stocks", {}).items():
         code = code_raw.upper()
         cname = COUNTRY_NAMES.get(code, code)
+
         if country_name:
-            if user_code and code != user_code:
-                continue
-            elif not user_code and country_name.lower() not in cname.lower():
+            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-%dT%H:%M:%SZ", time.gmtime(update_ts)) if update_ts else "Unknown"
+
         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)
-            item_ok = (
-                (item_term and (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)
-            )
+
+            # Strict item filtering
+            if item_term:
+                if exact_item_name:
+                    item_ok = (iname.lower() == item_lower)  # exact item only
+                else:
+                    item_ok = (
+                        (item_lower and item_lower in iname.lower()) or
+                        (semantic_category and itype == semantic_category.lower()) or
+                        (iname in semantic_items)
+                    )
+            elif category:
+                item_ok = (category.lower() == itype)
+            else:
+                item_ok = True
+
             if item_ok:
                 rows.append({
                     "Country": cname,
@@ -214,13 +239,97 @@ def query_inventory(query_text="", category="", country_name="", capacity=10, re
                     "Max Capacity Cost": cost * capacity,
                     "Updated": update_str
                 })
+
     if not rows:
         return pd.DataFrame([{"Result": "No inventory found for that query."}]), f"Last update: {last_update}"
+
     df = pd.DataFrame(rows).sort_values(by=["Country", "Item"])
     for col in ["Quantity", "Cost", "Max Capacity Cost"]:
         df[col] = df[col].apply(lambda x: f"{x:,.0f}" if isinstance(x, (int, float)) else x)
     return df, f"Last update: {last_update}"
 
+# ---------------- Multi-query (convenience buttons) ----------------
+def run_multi(phrases, capacity):
+    """
+    Execute multiple 'item in country' phrases with strict per-country filtering and no duplicates.
+    """
+    data, last_update = fetch_yata(False)
+
+    # Group requested item_terms by normalized country code
+    tasks_by_code = {}  # code -> [item_term, ...]
+    for phrase in phrases:
+        item_term, country_term = parse_freeform_query(phrase)
+        code = normalize_country_query(country_term) or ""
+        if not code:
+            # If country not recognized (shouldn't happen with our lists), fall back to pass-through single query
+            code = "__ALL__"
+        tasks_by_code.setdefault(code, []).append(item_term)
+
+    rows = []
+    for code_raw, cdata in data.get("stocks", {}).items():
+        code = code_raw.upper()
+        if code not in tasks_by_code:
+            continue
+
+        cname = COUNTRY_NAMES.get(code, code)
+        update_ts = cdata.get("update")
+        update_str = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(update_ts)) if update_ts else "Unknown"
+
+        # Precompute semantic intents for each term in this country
+        compiled_terms = []
+        for term in tasks_by_code[code]:
+            t = (term or "").strip().lower()
+            exact_item_name = ALL_ITEMS_LOWER.get(t)
+            if exact_item_name:
+                compiled_terms.append({"mode": "exact", "value": t})
+            else:
+                sem = semantic_match(t) if t else {"category": None, "items": []}
+                compiled_terms.append({
+                    "mode": "fuzzy",
+                    "value": t,
+                    "category": (sem["category"] or "").lower() if sem["category"] else "",
+                    "items": set(sem["items"])
+                })
+
+        # Scan this country's items once
+        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)
+
+            matched = False
+            for ct in compiled_terms:
+                if ct["mode"] == "exact":
+                    if iname.lower() == ct["value"]:
+                        matched = True
+                        break
+                else:
+                    q = ct["value"]
+                    if (q and q in iname.lower()) or (ct["category"] and itype == ct["category"]) or (iname in ct["items"]):
+                        matched = True
+                        break
+
+            if matched:
+                rows.append({
+                    "Country": cname,
+                    "Item": iname,
+                    "Category": itype.title(),
+                    "Quantity": qty,
+                    "Cost": cost,
+                    "Max Capacity Cost": cost * capacity,
+                    "Updated": update_str
+                })
+
+    if not rows:
+        return pd.DataFrame([{"Result": "No results for that set."}]), f"Last update: {last_update}"
+
+    # Deduplicate rows by (Country, Item, Updated)
+    df = pd.DataFrame(rows).drop_duplicates(subset=["Country", "Item", "Updated"]).sort_values(by=["Country", "Item"])
+    for col in ["Quantity", "Cost", "Max Capacity Cost"]:
+        df[col] = df[col].apply(lambda x: f"{x:,.0f}" if isinstance(x, (int, float)) else x)
+    return df, f"Last update: {last_update}"
+
 # ---------------- Wrappers ----------------
 def run_query(query_text, category, country, capacity, refresh):
     data, _ = fetch_yata(force_refresh=refresh)
@@ -228,67 +337,59 @@ def run_query(query_text, category, country, capacity, refresh):
     live_categories = get_live_categories(data)
     return df, ts, gr.update(choices=[""] + live_categories)
 
-def run_multi(searches, capacity):
-    """Executes multiple searches (like convenience buttons) correctly filtering by country."""
-    dfs = []
-    print(f"🧩 Running multi-search: {len(searches)} queries")
-    for q in searches:
-        item_term, country_term = parse_freeform_query(q)
-        print(f"  🔍 Sub-query → item='{item_term}', country='{country_term}'")
-        df, _ = query_inventory(item_term, "", country_term, capacity, False)
-        dfs.append(df)
-    merged = pd.concat(dfs, ignore_index=True)
-    total = pd.DataFrame([{
-        "Country": "—", "Item": "TOTAL", "Category": "",
-        "Quantity": merged["Quantity"].replace(",", "", regex=True).astype(float).sum(),
-        "Cost": "", "Max Capacity Cost": "", "Updated": ""
-    }])
-    merged = pd.concat([merged, total])
-    return merged, f"Last update: {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}"
-
 # ---------------- Gradio UI ----------------
-with gr.Blocks(title="🧳 Torn Foreign Stocks") as iface:
-    gr.Markdown("## 🧳 Torn Foreign Stocks")
-    gr.Markdown("_Search YATA's foreign stocks data_")
-
-    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)
+with gr.Blocks(title="🧳 Torn Inventory Viewer") as iface:
+    gr.Markdown("## 🧳 Torn Inventory Viewer")
+    gr.Markdown("_Search Torn YATA travel stocks — timestamps shown in your local timezone._")
 
+    # Convenience buttons
     with gr.Row():
         btn_short = gr.Button("🌸 Flushies (short haul)")
         btn_medium = gr.Button("🧸 Flushies (medium haul)")
         btn_long = gr.Button("🎁 Flushies (long haul)")
-        btn_xanax = gr.Button("💊 Xanax (SA)")
+        btn_xanax = gr.Button("💊 Xanax")
         btn_temps = gr.Button("🧨 Temps")
 
+    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)
+
     result_df = gr.Dataframe(label="Results")
     meta_box = gr.Textbox(label="Metadata / Last Update")
     run_btn = gr.Button("🔍 Search / Refresh")
 
-    run_btn.click(run_query, inputs=[query_box, category_drop, country_box, capacity_slider, refresh_check],
+    run_btn.click(run_query,
+                  inputs=[query_box, category_drop, country_box, capacity_slider, refresh_check],
                   outputs=[result_df, meta_box, category_drop])
 
-    btn_short.click(lambda c: run_multi(["flowers in mexico", "flowers in cayman islands", "flowers in canada",
-                                         "plushies in mexico", "plushies in cayman islands", "plushies in canada"], c),
-                    inputs=[capacity_slider], outputs=[result_df, meta_box])
-    btn_medium.click(lambda c: run_multi(["flowers in hawaii", "flowers in united kingdom", "flowers in argentina",
-                                          "flowers in switzerland", "flowers in japan",
-                                          "plushies in hawaii", "plushies in united kingdom", "plushies in argentina",
-                                          "plushies in switzerland", "plushies in japan"], c),
-                     inputs=[capacity_slider], outputs=[result_df, meta_box])
-    btn_long.click(lambda c: run_multi(["flowers in uae", "flowers in china", "flowers in south africa",
-                                        "plushies in uae", "plushies in china", "plushies in south africa"], c),
-                   inputs=[capacity_slider], outputs=[result_df, meta_box])
+    # Convenience button bindings (use run_multi with per-country grouping)
+    btn_short.click(lambda c: run_multi(
+        ["flowers in mexico", "flowers in cayman islands", "flowers in canada",
+         "plushies in mexico", "plushies in cayman islands", "plushies in canada"], c),
+        inputs=[capacity_slider], outputs=[result_df, meta_box])
+
+    btn_medium.click(lambda c: run_multi(
+        ["flowers in hawaii", "flowers in united kingdom", "flowers in argentina",
+         "flowers in switzerland", "flowers in japan",
+         "plushies in hawaii", "plushies in united kingdom", "plushies in argentina",
+         "plushies in switzerland", "plushies in japan"], c),
+        inputs=[capacity_slider], outputs=[result_df, meta_box])
+
+    btn_long.click(lambda c: run_multi(
+        ["flowers in uae", "flowers in china", "flowers in south africa",
+         "plushies in uae", "plushies in china", "plushies in south africa"], c),
+        inputs=[capacity_slider], outputs=[result_df, meta_box])
+
     btn_xanax.click(lambda c: run_multi(["xanax in south africa"], c),
-                    inputs=[capacity_slider], outputs=[result_df, meta_box])
-    btn_temps.click(lambda c: run_multi(["tear gas in argentina", "smoke grenade in south africa",
-                                         "flash grenade in switzerland"], c),
-                    inputs=[capacity_slider], outputs=[result_df, meta_box])
+        inputs=[capacity_slider], outputs=[result_df, meta_box])
+
+    btn_temps.click(lambda c: run_multi(
+        ["tear gas in argentina", "smoke grenade in south africa", "flash grenade in switzerland"], c),
+        inputs=[capacity_slider], outputs=[result_df, meta_box])
 
-    # --- JS for local time conversion ---
+    # --- JS: convert all UTC ISO timestamps to browser's local time ---
     gr.HTML("""
     <script>
     (function(){