Upload app.py

app.py

@@ -1,17 +1,468 @@
+# app.py  (single-file Gradio app with all helpers)
+
+from __future__ import annotations
+import json
 import math
-import pandas as pd
+import re
+from html import escape as _esc
+from pathlib import Path
+from typing import Any, Dict, Optional
+
 import gradio as gr
+import pandas as pd
 
-from vehciles_offers_common import (
-    h,
-    css,
-    load_data,
-    _cmp_cell_html,
-    card_css_in_iframe,
-    price_number,
-    first_image,
-    BRAND_MODEL_TYPES,
-)
+# -------------------------------------------------------------
+# Config & Data loading
+# -------------------------------------------------------------
+
+def h(x: str) -> str:
+    """HTML-escape helper."""
+    return _esc(x or "")
+
+
+def find_offers_csv() -> Optional[Path]:
+    """Try multiple locations for the offers CSV."""
+    candidates = [
+        Path("offers_with_prices.csv"),
+        Path("offers_with_prices.csv"),
+        Path("offers_with_prices.csv"),
+        Path("offers_with_prices.csv"),
+    ]
+    for p in candidates:
+        if p.exists():
+            return p
+    return None
+
+
+def _load_config_json(possible_paths) -> Dict[str, Any]:
+    """Try a list of paths; return parsed JSON or {}."""
+    for p in possible_paths:
+        p = Path(p)
+        if p.exists():
+            try:
+                with open(p, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"⚠️ Could not read config {p}: {e}")
+    print(f"⚠️ Config not found in any of: {possible_paths}")
+    return {}
+
+
+def filter_heading_rows(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Remove rows where:
+      1) heading contains certain keywords (CSV_FILTER_KEYWORDS)
+      2) heading is ONLY a currency amount like 'AED 26,000' or 'AED 26,000*'
+         (based on MONEY regex)
+    BUT keep rows where heading contains a known model name (BRAND_MODEL_TYPES).
+    """
+    if "heading" not in df.columns:
+        return df
+
+    col = "heading"
+    heading_series = df[col].astype(str)
+
+    # Load keyword config
+    config_offers = _load_config_json(
+        [
+            "config_offers.json",
+            "config_offers.json",
+            "config_offers.json",
+        ]
+    )
+    csv_filter_keywords = config_offers.get("CSV_FILTER_KEYWORDS", [])
+
+    # Load pricing config
+    config_pricing = _load_config_json(
+        [
+            "config_pricing_generic.json",
+            "config_pricing_generic.json",
+            "config_pricing_generic.json",
+        ]
+    )
+    brand_model_types_cfg: Dict[str, Dict[str, Any]] = config_pricing.get(
+        "BRAND_MODEL_TYPES", {}
+    )
+    money_pattern: str = config_pricing.get("MONEY", r"[A-Z]{3}")
+
+    # Flatten list of all model names for heading matching
+    all_model_names = [
+        m.strip()
+        for models in brand_model_types_cfg.values()
+        for m in models.keys()
+        if m.strip()
+    ]
+
+    def heading_has_model(heading: str) -> bool:
+        if not isinstance(heading, str):
+            return False
+        text = heading.upper()
+        for model in all_model_names:
+            if model.upper() in text:
+                return True
+        return False
+
+    # Condition 1: keyword filter
+    if csv_filter_keywords:
+        keyword_pattern = "|".join(re.escape(k) for k in csv_filter_keywords)
+        cond1 = heading_series.str.contains(keyword_pattern, case=False, na=False)
+    else:
+        cond1 = pd.Series(False, index=df.index)
+
+    # Condition 2: currency-only headings
+    currency_pattern = rf"^(?:{money_pattern})\s*\d[\d,]*(?:\*)?$"
+    cond2 = heading_series.str.strip().str.match(currency_pattern, case=False)
+
+    has_model = heading_series.apply(heading_has_model)
+    drop_mask = (cond1 | cond2) & ~has_model
+
+    return df[~drop_mask].copy()
+
+
+def normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """Normalize column names and ensure all expected columns exist."""
+    alias = {
+        "brand_name": "brand",
+        "make": "brand",
+        "model_name": "model",
+        "img": "images",
+        "image_url": "images",
+        "image": "images",
+        "imageurl": "images",
+        "desc": "offer_description",
+        "offer_text": "offer_description",
+        "price": "starting_price",
+        "offer heading": "heading",
+        "title": "heading",
+        "vehcileoffer_url": "vehicle_offer_url",
+    }
+
+    for src, dest in alias.items():
+        if src in df.columns and dest not in df.columns:
+            df[dest] = df[src]
+
+    for col in [
+        "country",
+        "dealer",
+        "brand",
+        "model",
+        "trim_or_variant",
+        "starting_price",
+        "heading",
+        "offer_description",
+        "images",
+        "currency",
+    ]:
+        if col not in df.columns:
+            df[col] = ""
+
+    return df
+
+
+def load_csv(path: str) -> pd.DataFrame:
+    df = pd.read_csv(path)
+    df.columns = [c.strip().lower() for c in df.columns]
+    df = normalize_columns(df)
+    df = filter_heading_rows(df)
+
+    ctx_cols = [
+        c
+        for c in df.columns
+        if c.startswith("_debug_ctx_country_dealer_brand_currency")
+    ]
+    if not ctx_cols:
+        ctx_cols = [c for c in df.columns if c.startswith("_debug_ctx_")]
+
+    if ctx_cols:
+        df["__price_context_ok"] = df[ctx_cols].fillna(0).apply(
+            lambda r: any(pd.to_numeric(r, errors="coerce").fillna(0) > 0),
+            axis=1,
+        )
+    else:
+        df["__price_context_ok"] = True
+
+    return df
+
+
+def load_data() -> pd.DataFrame:
+    csv_path = find_offers_csv()
+    if not csv_path:
+        print("⚠️ offers_with_prices.csv not found. Using empty DataFrame.")
+        cols = [
+            "country",
+            "dealer",
+            "brand",
+            "model",
+            "trim_or_variant",
+            "starting_price",
+            "heading",
+            "offer_description",
+            "images",
+            "currency",
+            "vehicle_offer_url",
+            "__price_context_ok",
+        ]
+        return pd.DataFrame(columns=cols)
+
+    df = load_csv(str(csv_path))
+    if df.empty:
+        print("⚠️ offers_with_prices.csv appears empty.")
+    return df
+
+
+# Global dataframe used by UI
+df = load_data()
+
+
+# -------------------------------------------------------------
+# Price / image helpers
+# -------------------------------------------------------------
+
+_IMG_URL_RE = re.compile(r"https?://[^\s<>()'\"]+")
+
+
+def first_image(url_field) -> str:
+    """Pick first sensible image URL from messy field."""
+    if not url_field:
+        return ""
+
+    s = str(url_field).strip().replace("&amp;", "&")
+
+    # Try JSON
+    try:
+        if s[:1] in "[{" or (s[:1] == '"' and s[-1:] == '"'):
+            j = json.loads(s)
+            if isinstance(j, list):
+                for item in j:
+                    m = _IMG_URL_RE.search(str(item))
+                    if m:
+                        return m.group(0).rstrip(".,);]")
+            elif isinstance(j, dict):
+                for k in ("image", "image_url", "url", "src"):
+                    if k in j:
+                        m = _IMG_URL_RE.search(str(j[k]))
+                        if m:
+                            return m.group(0).rstrip(".,);]")
+    except Exception:
+        pass
+
+    # Fallback
+    m = _IMG_URL_RE.search(s)
+    if m:
+        return m.group(0).rstrip(".,);]")
+
+    for sep in ("|", "\n", " "):
+        if sep in s:
+            for part in s.split(sep):
+                m = _IMG_URL_RE.search(part)
+                if m:
+                    return m.group(0).rstrip(".,);]")
+
+    return ""
+
+
+def price_number(s: str) -> Optional[float]:
+    if not isinstance(s, str):
+        return None
+    s = s.replace(",", "")
+    m = re.search(r"([\d]+(?:\.\d+)?)", s)
+    return float(m.group(1)) if m else None
+
+
+def fmt_price(n: Optional[float], currency: str = "") -> str:
+    if n is None:
+        return "—"
+    try:
+        s = f"{int(round(n)):,}"
+    except Exception:
+        return "—"
+    return f"{currency} {s}".strip() if currency else s
+
+
+# -------------------------------------------------------------
+# BRAND_MODEL_TYPES (optional, used only for model list per brand)
+# -------------------------------------------------------------
+
+def load_brand_model_types() -> Dict[str, Dict[str, Any]]:
+    cfg = _load_config_json(
+        [
+            "config_pricing_generic.json",
+            "config_pricing_generic.json",
+            "config_pricing_generic.json",
+        ]
+    )
+    raw = cfg.get("BRAND_MODEL_TYPES", {}) or {}
+    return {str(brand).strip().upper(): models for brand, models in raw.items()}
+
+
+BRAND_MODEL_TYPES: Dict[str, Dict[str, Any]] = load_brand_model_types()
+
+
+# -------------------------------------------------------------
+# Card CSS and HTML
+# -------------------------------------------------------------
+
+def card_css_in_iframe() -> str:
+    return """
+      :root{
+        --bg:#f6f7fb; --card:#ffffff; --ink:#111827; --muted:#f3eac0;
+        --line:#e5e7eb; --brand:#4f46e5; --chip:#1e2640; --accent:#2563eb;
+        --good:#16a34a;
+        --popover-bg: rgba(255,255,255,.92);
+        --popover-border1: rgba(99,102,241,.25);
+        --popover-border2: rgba(99,102,241,.05);
+        --shadow-strong: 0 18px 50px rgba(2,6,23,.18);
+      }
+
+      html, body { height:100vh; margin:0; overflow:auto; background:var(--bg); }
+      .wrap { width: 96vw; max-width: 1700px; margin: 0 auto; padding: 6px 8px 10px; }
+
+      .cards{
+        position: relative; z-index: 0;
+        display:grid;
+        grid-template-columns:repeat(auto-fill,minmax(320px,1fr));
+        gap:18px;
+        padding:2px 8px 8px 2px;
+      }
+
+      .card{
+        background:var(--card);
+        border:1px solid var(--line);
+        border-radius:16px;
+        overflow:visible;
+        box-shadow:0 4px 18px rgba(0,0,0,.05);
+        display:flex; flex-direction:column;
+        position:relative; cursor:pointer;
+        transition: transform .08s ease, box-shadow .2s ease;
+        z-index: 1;
+        will-change: transform;
+      }
+      .card:hover{ box-shadow: 0 10px 28px rgba(2,6,23,.12); transform: translateY(-1px); }
+      .thumb{
+        background:#0b0b0b; height:180px; overflow:hidden;
+        border-top-left-radius:16px; border-top-right-radius:16px;
+      }
+      .thumb img{ width:100%; height:100%; object-fit:cover; }
+      .body{ padding:14px 14px 12px; display:flex; flex-direction:column; gap:6px; }
+      .sp{ font-size:15px; color:#070708; letter-spacing:.02em; }
+      .sp strong{ display:block; font-size:22px; color:#e5c100; line-height:1.05; margin-top:2px; }
+      .heading{ font-weight:700; color:var(--ink); margin:6px 0 2px; line-height:1.25; }
+      .offer{ color:var(--ink); font-size:15px; line-height:1.45; opacity:.88; display:-webkit-box; -webkit-line-clamp:5; -webkit-box-orient: vertical; overflow:hidden; }
+      .meta{ display:flex; gap:8px; flex-wrap:wrap; padding:0 14px 12px; }
+      .chip{ font-size:14px; color:var(--muted); background:var(--chip); border:1px solid var(--line); padding:4px 8px; border-radius:999px; }
+
+      .card{ height:100%; }
+      .body{ flex: 1 1 auto; }
+      .meta{ margin-top: auto; }
+
+      .card-tooltip-template { display:none; }
+      .card-tooltip{ overflow-x: hidden; }
+      .card-tooltip,
+      .card-tooltip .tt-title,
+      .card-tooltip .tt-v,
+      .card-tooltip .tt-link{
+        white-space: normal;
+        overflow-wrap: anywhere;
+        word-break: break-word;
+      }
+      .card-tooltip, .card-tooltip *{ box-sizing: border-box; }
+      .card-tooltip img,
+      .card-tooltip svg,
+      .card-tooltip video{
+        max-width: 100%;
+        height: auto;
+        display: block;
+      }
+
+      .card-tooltip .tt-grid{
+        grid-template-columns: 120px minmax(0, 1fr);
+      }
+
+      #tt-portal {
+        position: fixed;
+        top: 0; left: 0;
+        transform: translate3d(0,0,0);
+        z-index: 2147483647;
+        display: none;
+        width: min(520px, 86vw);
+        max-height: 72vh;
+        overflow-x: hidden;
+        overflow-y: auto;
+        white-space: normal;
+        overflow-wrap: anywhere;
+        word-break: break-word;
+        background: var(--popover-bg);
+        -webkit-backdrop-filter: saturate(1.4) blur(8px);
+        backdrop-filter: saturate(1.4) blur(8px);
+        border: 1px solid transparent;
+        border-radius: 14px;
+        box-shadow: var(--shadow-strong);
+        padding: 14px 16px;
+        color: #0f172a;
+        font-size: 13px;
+        line-height: 1.5;
+        background-clip: padding-box, border-box;
+        background-image:
+          linear-gradient(var(--popover-bg), var(--popover-bg)),
+          linear-gradient(135deg, var(--popover-border1), var(--popover-border2));
+      }
+
+      #tt-portal.show { display: block; animation: tt-fade .16s ease-out; }
+      @keyframes tt-fade {
+        from { opacity:0; transform: translateY(-2px); }
+        to   { opacity:1; transform: translateY(0); }
+      }
+      #tt-portal::after{
+        content:"";
+        position: absolute; top: 16px;
+        width: 12px; height: 12px; transform: rotate(45deg);
+        background: var(--popover-bg);
+        -webkit-backdrop-filter: saturate(1.4) blur(8px);
+        backdrop-filter: saturate(1.4) blur(8px);
+        border-left: 1px solid rgba(99,102,241,.18);
+        border-top: 1px solid rgba(99,102,241,.18);
+      }
+      #tt-portal.right::after{ left: -8px; }
+      #tt-portal.left::after {
+        right: -8px; left:auto;
+        border-left: none; border-top: none;
+        border-right: 1px solid rgba(99,102,241,.18);
+        border-bottom: 1px solid rgba(99,102,241,.18);
+      }
+
+      .tt-head{ display:flex; align-items:flex-start; gap:10px; margin-bottom:10px; }
+      .tt-dot{
+        width:10px; height:10px; border-radius:999px; margin-top:4px;
+        background: radial-gradient( circle at 30% 30%, #a78bfa, #6366f1 );
+        box-shadow: 0 0 0 3px rgba(99,102,241,.12);
+        flex: 0 0 auto;
+      }
+      .tt-title{ font-weight:800; font-size:15px; color:#0b1220; line-height:1.25; }
+      .tt-meta{ display:flex; gap:6px; flex-wrap:wrap; margin:2px 0 8px; }
+      .tt-chip{ font-size:13px; color:#f3eac0; background:#1e2640; border:1px solid #e2e8f0; padding:4px 8px; border-radius:10px; }
+      .tt-grid{
+        display:grid;
+        grid-template-columns: 120px minmax(0, 1fr);
+        gap:8px 12px;
+        background: linear-gradient(180deg, rgba(99,102,241,.06), rgba(99,102,241,0) 45%);
+        border:1px dashed rgba(99,102,241,.15);
+        border-radius:10px;
+        padding:10px 12px;
+        margin:8px 0;
+      }
+      .tt-k{ color:#334155; font-weight:600; font-size:14px; }
+      .tt-v{ color:#0f172a; font-size:14px; }
+
+      .tt-link{
+        display:inline-flex; align-items:center; gap:6px;
+        margin-top:8px; color:var(--accent); text-decoration:none; font-weight:600;
+      }
+      .tt-link:hover{ text-decoration:underline; }
+
+      @media (prefers-reduced-motion: reduce){
+        .card{ transition:none !important; }
+      }
+    """
 
 
 def card_html(row: pd.Series) -> str:
@@ -70,14 +521,28 @@ def card_html(row: pd.Series) -> str:
           {f"<div class='chip'>{model}</div>" if model else ""}
           {f"<div class='chip'>{trim}</div>" if trim else ""}
         </div>
+
+        <div class="card-tooltip-template" aria-hidden="true" style="display:none">
+          <div class="tt-head">
+            <span class="tt-dot"></span>
+            <div class="tt-title">{heading}</div>
+          </div>
+          <div class="tt-meta">{meta_chips}</div>
+          <div class="tt-grid">
+            <div class="tt-k">Starting Price</div>
+            <div class="tt-v">{price or "—"}</div>
+            <div class="tt-k">Details</div>
+            <div class="tt-v">{offer if offer else "—"}</div>
+          </div>
+          {tooltip_link}
+        </div>
       </div>
     """
 
 
-# ---- Tooltip JS (same as original) ----
+# Tooltip JS (same as your original)
 js_portal = r"""
 (function(){
-  // Create or reuse the global portal
   let portal = document.getElementById('tt-portal');
   if(!portal){
     portal = document.createElement('div');
@@ -91,18 +556,17 @@ js_portal = r"""
   let hideTimeout = null;
   let overPortal = false;
 
-  function placePortal(anchor, side /*'right'|'left'*/){
+  function placePortal(anchor, side){
     const a = anchor.getBoundingClientRect();
     const p = portal.getBoundingClientRect();
     const vw = window.innerWidth;
     const vh = window.innerHeight;
 
     const gap = 14;
-    let left = a.right + gap;   // default right
+    let left = a.right + gap;
     portal.classList.remove('left','right');
 
     if (side === 'left' || left + p.width > vw - 6){
-      // flip left
       left = Math.max(6, a.left - gap - p.width);
       portal.classList.add('left');
     } else {
@@ -129,7 +593,6 @@ js_portal = r"""
 
     requestAnimationFrame(()=>{
       placePortal(card, 'right');
-      // if still overflowing, try left side
       const pr = portal.getBoundingClientRect();
       if (pr.right > window.innerWidth - 2){
         placePortal(card, 'left');
@@ -152,12 +615,11 @@ js_portal = r"""
   function scheduleHide(){
     clearTimeout(hideTimeout);
     hideTimeout = setTimeout(()=>{
-      // keep open if mouse is over portal or back over the card
       const stillOverCard = activeCard && activeCard.matches(':hover');
       if (!overPortal && !stillOverCard){
         hide();
       }
-    }, 120); // small grace period prevents flicker at edges
+    }, 120);
   }
 
   const cards = document.querySelectorAll('.card');
@@ -168,7 +630,6 @@ js_portal = r"""
     card.addEventListener('focusout',  scheduleHide);
   });
 
-  // Keep positioned on scroll/resize
   function maybeReposition(){
     if(!portal.classList.contains('show') || !activeCard) return;
     const side = portal.classList.contains('left') ? 'left' : 'right';
@@ -177,25 +638,24 @@ js_portal = r"""
   window.addEventListener('resize', maybeReposition, {passive:true});
   window.addEventListener('scroll', maybeReposition, {passive:true});
 
-  // Let the portal itself keep the tooltip open while hovered
   portal.addEventListener('mouseenter', ()=>{ overPortal = true; clearTimeout(hideTimeout); });
   portal.addEventListener('mouseleave', ()=>{ overPortal = false; scheduleHide(); });
 
-  // Prevent clicks inside the portal from bubbling to the card
   portal.addEventListener('click', e=> e.stopPropagation());
 })();
 """
 
 
-# ---- Data + helpers ----
-df = load_data()
-
+# -------------------------------------------------------------
+# Gradio rendering logic
+# -------------------------------------------------------------
 
 def _unique_vals(series: pd.Series):
-    return sorted({str(x).strip() for x in series.dropna().astype(str) if str(x).strip()})
+    return sorted(
+        {str(x).strip() for x in series.dropna().astype(str) if str(x).strip()}
+    )
 
 
-# ---- Core rendering logic (replaces Streamlit layout) ----
 def render_offers(
     selected_countries,
     selected_dealers,
@@ -205,20 +665,14 @@ def render_offers(
 ):
     df_f = df.copy()
 
-    # Country filter
     if selected_countries:
         df_f = df_f[df_f["country"].astype(str).isin(selected_countries)]
-
-    # Dealer filter
     if selected_dealers:
         df_f = df_f[df_f["dealer"].astype(str).isin(selected_dealers)]
-
-    # Brand filter
     if selected_brands:
         df_f = df_f[df_f["brand"].astype(str).isin(selected_brands)]
 
-    # Sorting
-    if sort_choice != "Default":
+    if sort_choice != "Default" and not df_f.empty:
         tmp_price = df_f.apply(
             lambda r: price_number(r["starting_price"])
             if r.get("__price_context_ok", True)
@@ -236,65 +690,28 @@ def render_offers(
         )
 
     if df_f.empty:
-        return "<p><em>No rows match your filters.</em></p>"
+        css_iframe = card_css_in_iframe()
+        return f"<style>{css_iframe}</style><p><em>No rows match your filters.</em></p>"
 
+    df_show = df_f.head(int(limit))
+    cards_html = "".join(card_html(r) for _, r in df_show.iterrows())
     css_iframe = card_css_in_iframe()
-    extra_css = """
-    .brand-row-title{
-        font-size: 1.4rem;
-        font-weight: 700;
-        margin: 0.75rem 0 0.25rem 0;
-    }
-    """
-
-    html_parts = [f"<style>{css_iframe}{extra_css}</style>"]
-
-    # If NO brand filter → single grid (same as original)
-    if not selected_brands:
-        df_show = df_f.head(limit)
-        cards_html = "".join(card_html(r) for _, r in df_show.iterrows())
-        html_parts.append(
-            f"""
-            <div class="wrap">
-              <div class="cards">{cards_html}</div>
-            </div>
-            <script>{js_portal}</script>
-            """
-        )
-        return "\n".join(html_parts)
-
-    # BRAND ROWS VIEW (one row per selected brand), same layout as original
-    html_parts.append("<div class='wrap'>")
-    for brand in selected_brands:
-        df_brand = df_f[df_f["brand"].astype(str) == brand]
-        df_brand_show = df_brand.head(limit)
-
-        if df_brand_show.empty:
-            continue
-
-        cards_html = "".join(card_html(r) for _, r in df_brand_show.iterrows())
-
-        html_parts.append(
-            f"""
-            <div class='brand-row'>
-              <div class='brand-row-title'>{h(brand)}</div>
-              <div class="cards">{cards_html}</div>
-            </div>
-            """
-        )
-
-    html_parts.append("</div>")
-    html_parts.append(f"<script>{js_portal}</script>")
 
-    return "\n".join(html_parts)
+    html = f"""
+    <style>{css_iframe}</style>
+    <div class="wrap">
+      <div class="cards">{cards_html}</div>
+    </div>
+    <script>{js_portal}</script>
+    """
+    return html
 
 
-# ---- Dynamic option updates (like Streamlit sidebar cascading filters) ----
 def update_dealers_and_brands(selected_countries):
-    # When country changes, update dealer + brand choices
     df_c = df if not selected_countries else df[df["country"].astype(str).isin(selected_countries)]
-    dealer_opts = _unique_vals(df_c["dealer"])
-    brand_opts = _unique_vals(df_c["brand"])
+    dealer_opts = _unique_vals(df_c["dealer"]) if not df_c.empty else []
+    brand_opts = _unique_vals(df_c["brand"]) if not df_c.empty else []
+
     return (
         gr.Dropdown.update(choices=dealer_opts, value=[]),
         gr.Dropdown.update(choices=brand_opts, value=[]),
@@ -304,26 +721,25 @@ def update_dealers_and_brands(selected_countries):
 def update_brands(selected_countries, selected_dealers):
     df_c = df if not selected_countries else df[df["country"].astype(str).isin(selected_countries)]
     df_cd = df_c if not selected_dealers else df_c[df_c["dealer"].astype(str).isin(selected_dealers)]
-    brand_opts = _unique_vals(df_cd["brand"])
+    brand_opts = _unique_vals(df_cd["brand"]) if not df_cd.empty else []
     return gr.Dropdown.update(choices=brand_opts, value=[])
 
 
-# ---- Gradio app (for Hugging Face Space) ----
-with gr.Blocks(title="Offers Comparison V1") as demo:
-    # equivalent of css() side effects (if it injects global CSS)
-    try:
-        css()
-    except Exception:
-        # ignore if css() is Streamlit-specific; card_css_in_iframe covers grid styles
-        pass
+# -------------------------------------------------------------
+# Gradio app
+# -------------------------------------------------------------
 
+with gr.Blocks(title="Offers Comparison V1") as demo:
     gr.Markdown("## Offers Comparison V1")
 
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### Filters")
 
-            country_opts = _unique_vals(df["country"])
+            country_opts = _unique_vals(df["country"]) if not df.empty else []
+            dealer_opts = _unique_vals(df["dealer"]) if not df.empty else []
+            brand_opts = _unique_vals(df["brand"]) if not df.empty else []
+
             country_dd = gr.Dropdown(
                 label="Country",
                 choices=country_opts,
@@ -333,14 +749,14 @@ with gr.Blocks(title="Offers Comparison V1") as demo:
 
             dealer_dd = gr.Dropdown(
                 label="Dealer",
-                choices=_unique_vals(df["dealer"]),
+                choices=dealer_opts,
                 multiselect=True,
                 value=[],
             )
 
             brand_dd = gr.Dropdown(
                 label="Brand",
-                choices=_unique_vals(df["brand"]),
+                choices=brand_opts,
                 multiselect=True,
                 value=[],
             )
@@ -362,7 +778,7 @@ with gr.Blocks(title="Offers Comparison V1") as demo:
         with gr.Column(scale=3):
             offers_html = gr.HTML()
 
-    # Wire cascading filters
+    # Cascading filters
     country_dd.change(
         fn=update_dealers_and_brands,
         inputs=country_dd,
@@ -375,7 +791,7 @@ with gr.Blocks(title="Offers Comparison V1") as demo:
         outputs=brand_dd,
     )
 
-    # Auto-refresh offers on any filter change
+    # Auto-refresh on any filter change
     for comp in [country_dd, dealer_dd, brand_dd, sort_dd, limit_slider]:
         comp.change(
             fn=render_offers,
@@ -383,8 +799,9 @@ with gr.Blocks(title="Offers Comparison V1") as demo:
             outputs=offers_html,
         )
 
-    # Initial render
+    # Initial view
     offers_html.value = render_offers([], [], [], "Default", 50)
 
+
 if __name__ == "__main__":
     demo.launch()