Create app.py

app.py

@@ -0,0 +1,290 @@
+import os
+import re
+import numpy as np
+import gradio as gr
+from datasets import load_dataset
+from sentence_transformers import SentenceTransformer
+
+# ========================
+# Config
+# ========================
+DATASET_ID = "motimmom/cocktails_clean_nobrand"
+EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+FLAVOR_BOOST = 0.20
+
+# Use the image you uploaded at the root of the Space repo:
+BACKGROUND_IMAGE_URL = "file=bar.jpg"  # <-- safest: served by Gradio from your Space files
+
+# If you prefer the remote URL, make sure the space name uses the HY-PHEN:
+# BACKGROUND_IMAGE_URL = "https://huggingface.co/spaces/OGOGOG/AI-Bartender/resolve/main/bar.jpg"
+
+# If dataset is private, add Space secret HF_TOKEN (read scope)
+HF_READ_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")
+load_kwargs = {}
+if HF_READ_TOKEN:
+    load_kwargs["token"] = HF_READ_TOKEN
+    load_kwargs["use_auth_token"] = HF_READ_TOKEN
+
+# ========================
+# Base & Flavor tagging rules
+# ========================
+BASE_SPIRITS = {
+    "vodka":    [r"\bvodka\b"],
+    "gin":      [r"\bgin\b"],
+    "rum":      [r"\brum\b", r"\bwhite rum\b", r"\bdark rum\b"],
+    "tequila":  [r"\btequila\b"],
+    "whiskey":  [r"\bwhisk(?:e|)y\b", r"\bbourbon\b", r"\bscotch\b", r"\brye\b"],
+    "mezcal":   [r"\bmezcal\b"],
+    "brandy":   [r"\bbrandy\b", r"\bcognac\b"],
+    "vermouth": [r"\bvermouth\b"],
+    "other":    [r"\btriple sec\b", r"\bliqueur\b", r"\bcointreau\b", r"\baperol\b", r"\bcampari\b"],
+}
+FLAVORS = {
+    "citrus":      [r"lime", r"lemon", r"grapefruit", r"orange", r"\bcitrus\b"],
+    "sweet":       [r"simple syrup", r"\bsugar\b", r"\bhoney\b", r"\bagave\b", r"\bmaple\b", r"\bgrenadine\b", r"\bvanilla\b", r"\bsweet\b"],
+    "sour":        [r"\bsour\b", r"lemon juice", r"lime juice", r"\bacid\b"],
+    "bitter":      [r"\bbitter", r"\bamaro\b", r"\bcampari\b", r"\baperol\b"],
+    "smoky":       [r"\bsmoky\b", r"\bsmoked\b", r"\bmezcal\b", r"\bpeated\b"],
+    "spicy":       [r"\bspicy\b", r"\bchili\b", r"\bginger\b", r"\bjalapeño\b", r"\bcayenne\b"],
+    "herbal":      [r"\bmint\b", r"\bbasil\b", r"\brosemary\b", r"\bthyme\b", r"\bherb", r"\bchartreuse\b"],
+    "fruity":      [r"pineapple", r"cranberr", r"strawberr", r"mango", r"passion", r"peach", r"\bfruit"],
+    "creamy":      [r"\bcream\b", r"coconut cream", r"\begg white\b", r"\bcreamy\b"],
+    "floral":      [r"\brose\b", r"\bviolet\b", r"\belderflower\b", r"\blavender\b", r"\bfloral\b"],
+    "refreshing":  [r"soda water", r"\btonic\b", r"\bhighball\b", r"\bcollins\b", r"\bfizz\b", r"\brefreshing\b"],
+    "boozy":       [r"\bstirred\b", r"\bmartini\b", r"old fashioned", r"\bboozy\b", r"\bstrong\b"],
+}
+FLAVOR_OPTIONS = list(FLAVORS.keys())
+
+# ========================
+# Robust extraction helpers (with measures)
+# ========================
+def _clean(s): return s.strip() if isinstance(s, str) else ""
+
+def _norm_measure(s: str) -> str:
+    if not isinstance(s, str): return ""
+    s = re.sub(r"\s+", " ", s.strip())
+    s = re.sub(r"\bml\b", "ml", s, flags=re.I)
+    s = re.sub(r"\boz\b", "oz", s, flags=re.I)
+    s = re.sub(r"\btsp\b", "tsp", s, flags=re.I)
+    s = re.sub(r"\btbsp\b", "tbsp", s, flags=re.I)
+    return s
+
+def _join_measure_name(measure, name):
+    m = _norm_measure(measure)
+    n = name.strip() if isinstance(name, str) else ""
+    if m and n: return f"{m} {n}"
+    return n or m
+
+def _split_ingredient_blob(s):
+    if not isinstance(s, str): return []
+    parts = re.split(r"[,\n;•\-–]+", s)
+    return [p.strip() for p in parts if p and p.strip()]
+
+def _from_list_of_pairs(val):
+    out_disp, out_tokens = [], []
+    for x in val:
+        if not isinstance(x, (list, tuple)) or len(x) == 0: continue
+        if len(x) == 1:
+            name = str(x[0]).strip()
+            if name: out_disp.append(name); out_tokens.append(name.lower()); continue
+        a, b = str(x[0]).strip(), str(x[1]).strip()
+        if re.search(r"\d", a) and not re.search(r"\d", b):
+            disp = _join_measure_name(a, b); out_disp.append(disp); out_tokens.append(b.lower())
+        elif re.search(r"\d", b) and not re.search(r"\d", a):
+            disp = _join_measure_name(b, a); out_disp.append(disp); out_tokens.append(a.lower())
+        else:
+            disp = (a + " " + b).strip(); out_disp.append(disp); out_tokens.append((b if len(b) > len(a) else a).lower())
+    return out_disp, out_tokens
+
+def _from_list_of_dicts(val):
+    out_disp, out_tokens = [], []
+    for x in val:
+        if not isinstance(x, dict): continue
+        name = next((x[k].strip() for k in ["name","ingredient","item","raw","text","strIngredient"] if isinstance(x.get(k), str) and x[k].strip()), None)
+        meas = next((x[k].strip() for k in ["measure","qty","quantity","amount","unit","Measure","strMeasure"] if isinstance(x.get(k), str) and x[k].strip()), None)
+        if name and meas:
+            out_disp.append(_join_measure_name(meas, name)); out_tokens.append(name.lower())
+        elif name:
+            out_disp.append(name); out_tokens.append(name.lower())
+    return out_disp, out_tokens
+
+def _ingredients_from_any(val):
+    if isinstance(val, str):
+        lines = _split_ingredient_blob(val)
+        tokens = []
+        for line in lines:
+            parts = re.split(r"\s+", line); idx = 0
+            for i, p in enumerate(parts):
+                if re.search(r"[A-Za-z]", p): idx = i; break
+            tokens.append(" ".join(parts[idx:]).lower())
+        return lines, tokens
+    if isinstance(val, list) and all(isinstance(x, str) for x in val):
+        disp = [x.strip() for x in val if x and x.strip()]
+        return disp, [x.lower().strip() for x in disp]
+    if isinstance(val, list) and any(isinstance(x, (list, tuple)) for x in val):
+        return _from_list_of_pairs(val)
+    if isinstance(val, list) and any(isinstance(x, dict) for x in val):
+        return _from_list_of_dicts(val)
+    return [], []
+
+def _get_title(row, cols):
+    for k in ["title","name","cocktail_name","drink","Drink","strDrink"]:
+        if k in cols and _clean(row.get(k)): return _clean(row[k])
+    return "Untitled"
+
+def _get_ingredients_with_measures(row, cols):
+    if "ingredient_tokens" in cols and row.get("ingredient_tokens"):
+        toks = [str(x).strip().lower() for x in row["ingredient_tokens"] if str(x).strip()]
+        for mkey in ["measure_tokens","measures","measure_list"]:
+            if mkey in cols and row.get(mkey) and isinstance(row[mkey], list) and len(row[mkey]) == len(toks):
+                disp = []
+                for m, n in zip(row[mkey], row["ingredient_tokens"]):
+                    m = _norm_measure(str(m)); n = str(n).strip()
+                    disp.append(_join_measure_name(m, n) if m else n)
+                return disp, toks
+        return toks, toks
+    for key in ["ingredients","ingredients_raw","raw_ingredients","Raw_Ingredients","Raw Ingredients","ingredient_list","ingredients_list"]:
+        if key in cols and row.get(key) not in (None, "", [], {}): return _ingredients_from_any(row[key])
+    return [], []
+
+def tag_base(text):
+    t = text.lower()
+    for base, pats in BASE_SPIRITS.items():
+        if any(re.search(p, t) for p in pats): return base
+    return "other"
+
+def tag_flavors(text):
+    t = text.lower(); tags = []
+    for flv, pats in FLAVORS.items():
+        if any(re.search(p, t) for p in pats): tags.append(flv)
+    return tags
+
+# ========================
+# Load dataset & build docs
+# ========================
+ds = load_dataset(DATASET_ID, split="train", **load_kwargs)
+cols = ds.column_names
+
+DOCS = []
+for r in ds:
+    title = _get_title(r, cols)
+    ing_disp, ing_tokens = _get_ingredients_with_measures(r, cols)
+    ing_disp = [x for x in ing_disp if x]; ing_tokens = [x for x in ing_tokens if x]
+    fused = f"{title}\nIngredients: {', '.join(ing_tokens)}"
+    DOCS.append({
+        "title": title,
+        "ingredients_display": ing_disp,
+        "ingredients_tokens": ing_tokens,
+        "text": fused,
+        "base": tag_base(fused),
+        "flavors": tag_flavors(fused),
+    })
+
+# ========================
+# Embeddings
+# ========================
+encoder = SentenceTransformer(EMBED_MODEL)
+doc_embs = encoder.encode([d["text"] for d in DOCS], normalize_embeddings=True, convert_to_numpy=True).astype("float32")
+
+# ========================
+# Pretty ingredient formatting
+# ========================
+_MEASURE_RE = re.compile(r"^\s*(?P<meas>(?:\d+(\.\d+)?|\d+\s*/\s*\d+|\d+\s*\d*/\d+)\s*(?:ml|oz|tsp|tbsp)?|\d+\s*(?:ml|oz|tsp|tbsp)|(?:dash|dashes|drop|drops|barspoon)s?)\b[\s\-–:]*", flags=re.I)
+
+def _split_measure_name_line(line: str):
+    if not isinstance(line, str): return None, line
+    m = _MEASURE_RE.match(line.strip())
+    if m:
+        meas = _norm_measure(m.group("meas")); name = line[m.end():].strip()
+        return meas, name or ""
+    return "", line.strip()
+
+def _format_ingredients_markdown(lines):
+    """Bullet points as 'Ingredient (amount)'. Also removes [ and ]."""
+    if not lines: return "—"
+    formatted = []
+    for ln in lines:
+        ln = ln.replace("[","").replace("]","")
+        meas, name = _split_measure_name_line(ln)
+        if name and meas: formatted.append(f"- {name} ({meas})")
+        elif name:        formatted.append(f"- {name}")
+        else:             formatted.append(f"- {ln}")
+    return "\n".join(formatted)
+
+# ========================
+# Recommendation
+# ========================
+def recommend(base_alcohol_text, flavor, top_k=3):
+    inferred_base = tag_base(base_alcohol_text or "")
+    if flavor not in FLAVOR_OPTIONS: return "Please choose a flavor."
+    idxs = [i for i, d in enumerate(DOCS) if d["base"] == inferred_base] or list(range(len(DOCS)))
+    q_text = f"Base spirit: {base_alcohol_text}. Flavor: {flavor}. Cocktail recipe."
+    q_emb = encoder.encode([q_text], normalize_embeddings=True, convert_to_numpy=True).astype("float32")[0]
+    sims = doc_embs[idxs].dot(q_emb)
+    scored = []
+    for pos, i in enumerate(idxs):
+        score = float(sims[pos]) + (FLAVOR_BOOST if flavor in DOCS[i]['flavors'] else 0.0)
+        scored.append((score, i))
+    scored.sort(reverse=True)
+    picks = scored[:max(1,int(top_k))]
+    if not picks: return "No matches found."
+    blocks = []
+    for sc, i in picks:
+        d = DOCS[i]
+        ing_lines = d["ingredients_display"] or d["ingredients_tokens"]
+        ing_md = _format_ingredients_markdown(ing_lines)
+        meta = f"**Base:** {d['base']}  |  **Flavor tags:** {', '.join(d['flavors']) or '—'}  |  **Score:** {sc:.3f}"
+        blocks.append(f"### {d['title']}\n{meta}\n\n**Ingredients:**\n{ing_md}")
+    return "\n\n---\n\n".join(blocks)
+
+# ========================
+# Background + UI (robust)
+# ========================
+CUSTOM_CSS = f"""
+html, body, #root {{ height: 100%; }}
+/* Background on BODY to avoid component stacking issues */
+body {{
+  background-image: url('{BACKGROUND_IMAGE_URL}');
+  background-size: cover;
+  background-position: center;
+  background-attachment: fixed;
+}}
+/* Dark overlay for text contrast */
+body::before {{
+  content: "";
+  position: fixed;
+  inset: 0;
+  background: rgba(0,0,0,0.30);  /* slightly lighter so image shows */
+  z-index: 0;
+}}
+/* Make the app transparent and float above overlay */
+.gradio-container {{ background: transparent !important; position: relative; z-index: 1; }}
+.glass-card {{
+  background: rgba(255, 255, 255, 0.08);
+  backdrop-filter: blur(6px);
+  -webkit-backdrop-filter: blur(6px);
+  border-radius: 14px;
+  padding: 18px;
+  border: 1px solid rgba(255, 255, 255, 0.12);
+}}
+"""
+
+with gr.Blocks(css=CUSTOM_CSS) as demo:
+    with gr.Column(elem_classes=["glass-card"]):
+        gr.Markdown("# 🍹 AI Bartender — Type a Base + Flavor")
+        with gr.Row():
+            base_text = gr.Textbox(value="gin", label="Base alcohol (type any spirit, e.g., 'gin', 'white rum', 'bourbon')")
+            flavor = gr.Dropdown(choices=FLAVOR_OPTIONS, value="citrus", label="Flavor")
+            topk = gr.Slider(1, 10, value=3, step=1, label="Number of recommendations")
+        with gr.Row():
+            ex1 = gr.Button("Example: Gin + Citrus")
+            ex2 = gr.Button("Example: Rum + Fruity")
+            ex3 = gr.Button("Example: Mezcal + Smoky")
+        out = gr.Markdown()
+        gr.Button("Recommend").click(recommend, [base_text, flavor, topk], out)
+        ex1.click(lambda: ("gin", "citrus", 3), outputs=[base_text, flavor, topk])
+        ex2.click(lambda: ("white rum", "fruity", 3), outputs=[base_text, flavor, topk])
+        ex3.click(lambda: ("mezcal", "smoky", 3), outputs=[base_text, flavor, topk])
+
+if __name__ == "__main__":
+    demo.launch()