1#!/usr/bin/env python3
2"""YAR cafe menu automation over ChoiceQR.
3 
4Features:
5- Discover all sections from one URL (menu/bar/wine/etc)
6- Dump normalized menu JSON (name, price, category, section, photo, description)
7- Search by free text
8- Suggest pizza + drink combos with generic filters
9- Build "cards" payload (photo link + caption/description) for chat delivery
10 
11Examples:
12  python3 scripts/yar_menu_flow.py dump --out yar_dump.json
13  python3 scripts/yar_menu_flow.py search --input yar_dump.json --query "салат"
14  python3 scripts/yar_menu_flow.py suggest --input yar_dump.json --budget 600 --no-alcohol
15  python3 scripts/yar_menu_flow.py cards --input yar_dump.json --query "піца" --require-photo
16"""
17 
18from __future__ import annotations
19 
20import argparse
21import json
22import re
23import sys
24from dataclasses import dataclass
25from datetime import datetime, timezone
26from pathlib import Path
27from typing import Dict, Iterable, List, Optional, Sequence, Tuple
28from urllib.parse import urlparse
29 
30import requests
31 
32DEFAULT_URL = "https://yar.choiceqr.com/section:menu"
33SECTION_RE = re.compile(r"section:([A-Za-z0-9_-]+)")
34NEXT_DATA_RE = re.compile(r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>', re.S)
35 
36NON_ALCOHOL_CATEGORY_HINTS = (
37    "безалко",
38    "безалког",
39    "прохолод",
40    "гарячі напої",
41    "чай",
42    "фреш",
43    "кава",
44)
45 
46ALCOHOL_CATEGORY_HINTS = (
47    "віскі",
48    "ром",
49    "джин",
50    "горіл",
51    "коньяк",
52    "бренді",
53    "текіла",
54    "меск",
55    "аперитив",
56    "діджестив",
57    "пиво",
58    "коктейл",
59)
60 
61DRINK_CATEGORY_HINTS = tuple(dict.fromkeys(NON_ALCOHOL_CATEGORY_HINTS + ALCOHOL_CATEGORY_HINTS + (
62    "напої",
63    "чай",
64    "кава",
65    "фреш",
66    "лимонад",
67    "сік",
68)))
69 
70DRINK_INTENT_HINTS = (
71    "пити",
72    "попити",
73    "напій",
74    "напої",
75    "кава",
76    "чай",
77    "drink",
78    "beverage",
79)
80 
81STOPWORDS = {
82    "і", "й", "та", "або", "а", "але", "що", "щоб", "це", "ця", "цей", "ці",
83    "мені", "мене", "для", "дуже", "просто", "потрібно", "хочу", "хочеться", "щось",
84    "не", "так", "там", "тут", "по", "на", "в", "у", "з", "із", "до", "без",
85    "я", "мы", "мне", "меня", "хочу", "что", "это", "для", "или", "и", "но",
86    "please", "with", "without", "and", "the", "want", "something",
87}
88 
89TOKEN_RE = re.compile(r"[\w'’\-]{3,}", re.UNICODE)
90 
91TERM_EXPANSIONS = {
92    "ситне": ["м'яс", "гриль", "стейк", "ребра", "шашлич", "піц"],
93    "сытное": ["м'яс", "гриль", "стейк", "ребра", "шашлич", "піц"],
94    "hearty": ["м'яс", "гриль", "стейк", "ребра", "шашлич", "піц"],
95    "легке": ["салат", "риба", "морепродукт"],
96    "легкое": ["салат", "риба", "морепродукт"],
97    "light": ["салат", "риба", "морепродукт"],
98    "десерт": ["солод", "чізкейк", "торт", "медовик"],
99    "солодке": ["солод", "чізкейк", "торт", "медовик"],
100    "sweet": ["солод", "чізкейк", "торт", "медовик"],
101    "кава": ["еспресо", "латте", "капучино", "раф"],
102    "coffee": ["еспресо", "латте", "капучино", "раф"],
103}
104 
105 
106@dataclass
107class MenuItem:
108    name: str
109    price_uah: Optional[float]
110    description: str
111    category_name: str
112    section_name: str
113    section_slug: str
114    hurl: str
115    available: bool
116    media_url: Optional[str]
117 
118    def to_dict(self) -> Dict[str, object]:
119        return {
120            "name": self.name,
121            "price_uah": self.price_uah,
122            "description": self.description,
123            "category_name": self.category_name,
124            "section_name": self.section_name,
125            "section_slug": self.section_slug,
126            "hurl": self.hurl,
127            "available": self.available,
128            "media_url": self.media_url,
129        }
130 
131 
132def _site_base(url: str) -> str:
133    p = urlparse(url)
134    if not p.scheme or not p.netloc:
135        raise ValueError(f"Invalid URL: {url}")
136    return f"{p.scheme}://{p.netloc}"
137 
138 
139def _get_html(url: str, timeout: int = 30) -> str:
140    r = requests.get(url, timeout=timeout)
141    r.raise_for_status()
142    return r.text
143 
144 
145def discover_sections(url: str) -> List[str]:
146    html = _get_html(url)
147    found = sorted(set(SECTION_RE.findall(html)))
148    if not found:
149        m = SECTION_RE.search(url)
150        if m:
151            return [m.group(1)]
152    return found
153 
154 
155def _extract_next_data(html: str) -> Dict[str, object]:
156    m = NEXT_DATA_RE.search(html)
157    if not m:
158        raise RuntimeError("Could not find __NEXT_DATA__ payload in HTML")
159    return json.loads(m.group(1))
160 
161 
162def _pick_media_url(media: object) -> Optional[str]:
163    if not isinstance(media, list) or not media:
164        return None
165    first = media[0]
166    if not isinstance(first, dict):
167        return None
168    for k in ("big", "medium", "url", "thumbnail"):
169        v = first.get(k)
170        if isinstance(v, str) and v:
171            return v
172    return None
173 
174 
175def fetch_section(site_base: str, section_slug: str) -> Dict[str, object]:
176    url = f"{site_base}/section:{section_slug}"
177    html = _get_html(url)
178    payload = _extract_next_data(html)
179 
180    app = ((payload.get("props") or {}).get("app") or {})
181    place = app.get("place") or {}
182    menu = app.get("menu") or []
183    categories = app.get("categories") or []
184    sections = app.get("sections") or []
185 
186    category_map = {str(c.get("_id")): str(c.get("name") or "") for c in categories if isinstance(c, dict)}
187    section_map = {
188        str(s.get("_id")): {"name": str(s.get("name") or ""), "hurl": str(s.get("hurl") or "")}
189        for s in sections
190        if isinstance(s, dict)
191    }
192 
193    normalized: List[MenuItem] = []
194    for raw in menu:
195        if not isinstance(raw, dict):
196            continue
197        price_raw = raw.get("price")
198        price_uah = round(float(price_raw) / 100.0, 2) if isinstance(price_raw, (int, float)) else None
199        section_meta = section_map.get(str(raw.get("section")), {})
200 
201        normalized.append(
202            MenuItem(
203                name=str(raw.get("name") or "").strip(),
204                price_uah=price_uah,
205                description=str(raw.get("description") or "").strip(),
206                category_name=category_map.get(str(raw.get("category")), ""),
207                section_name=str(section_meta.get("name") or ""),
208                section_slug=str(section_meta.get("hurl") or section_slug),
209                hurl=str(raw.get("hurl") or ""),
210                available=bool(raw.get("available", True)),
211                media_url=_pick_media_url(raw.get("media")),
212            )
213        )
214 
215    return {
216        "section_slug": section_slug,
217        "url": url,
218        "place_name": str(place.get("name") or ""),
219        "place_type": str(place.get("type") or ""),
220        "item_count": len(normalized),
221        "items": [i.to_dict() for i in normalized],
222    }
223 
224 
225def dump_menu(url: str, explicit_sections: Optional[Sequence[str]] = None) -> Dict[str, object]:
226    site = _site_base(url)
227    sections = list(explicit_sections or discover_sections(url))
228    if not sections:
229        raise RuntimeError("No sections discovered. Provide --sections explicitly.")
230 
231    data_sections = []
232    for slug in sections:
233        try:
234            data_sections.append(fetch_section(site, slug))
235        except Exception as e:  # noqa: BLE001
236            data_sections.append(
237                {
238                    "section_slug": slug,
239                    "url": f"{site}/section:{slug}",
240                    "error": str(e),
241                    "item_count": 0,
242                    "items": [],
243                }
244            )
245 
246    place_name = ""
247    for s in data_sections:
248        if isinstance(s, dict) and s.get("place_name"):
249            place_name = str(s.get("place_name"))
250            break
251 
252    return {
253        "source_url": url,
254        "site_base": site,
255        "place_name": place_name,
256        "fetched_at": datetime.now(timezone.utc).isoformat(),
257        "sections": data_sections,
258    }
259 
260 
261def _iter_items(dataset: Dict[str, object]) -> Iterable[Dict[str, object]]:
262    for sec in dataset.get("sections", []):
263        if not isinstance(sec, dict):
264            continue
265        for item in sec.get("items", []):
266            if isinstance(item, dict):
267                yield item
268 
269 
270def _matches(text: str, terms: Sequence[str]) -> bool:
271    t = text.lower()
272    return all(term.lower() in t for term in terms)
273 
274 
275def search_items(dataset: Dict[str, object], query: str, limit: int = 30) -> List[Dict[str, object]]:
276    terms = [x for x in re.split(r"\s+", query.strip()) if x]
277    rows = []
278    for item in _iter_items(dataset):
279        hay = " ".join(
280            [
281                str(item.get("name", "")),
282                str(item.get("description", "")),
283                str(item.get("category_name", "")),
284                str(item.get("section_name", "")),
285            ]
286        )
287        if not terms or _matches(hay, terms):
288            rows.append(item)
289    rows.sort(key=lambda x: (x.get("section_name", ""), x.get("category_name", ""), x.get("name", "")))
290    return rows[:limit]
291 
292 
293def _is_non_alcohol_drink(item: Dict[str, object]) -> bool:
294    cat = str(item.get("category_name", "")).lower()
295    name = str(item.get("name", "")).lower()
296    if any(k in cat for k in NON_ALCOHOL_CATEGORY_HINTS):
297        return True
298    if "n/a" in name:
299        return True
300    if "pepsi" in name or "компот" in name or "моршин" in name or "borjomi" in name:
301        return True
302    return False
303 
304 
305def _is_alcohol(item: Dict[str, object]) -> bool:
306    cat = str(item.get("category_name", "")).lower()
307    return any(k in cat for k in ALCOHOL_CATEGORY_HINTS)
308 
309 
310def _tokenize_preference_text(text: str) -> List[str]:
311    tokens = [t.lower() for t in TOKEN_RE.findall(text or "")]
312    out: List[str] = []
313    for t in tokens:
314        if t in STOPWORDS:
315            continue
316        if t.isdigit():
317            continue
318        out.append(t)
319    # Keep order + uniqueness.
320    seen = set()
321    uniq: List[str] = []
322    for t in out:
323        if t in seen:
324            continue
325        seen.add(t)
326        uniq.append(t)
327    return uniq
328 
329 
330def _expand_positive_terms(terms: Sequence[str]) -> List[str]:
331    out: List[str] = []
332    for t in terms:
333        if t not in out:
334            out.append(t)
335        for key, extra in TERM_EXPANSIONS.items():
336            if key in t or t in key:
337                for x in extra:
338                    if x not in out:
339                        out.append(x)
340    return out
341 
342 
343def _extract_avoid_terms(text: str) -> List[str]:
344    low = (text or "").lower()
345    patterns = [
346        r"(?:без|without|avoid|exclude|no)\s+([\w'’\-]{3,})",
347        r"(?:не\s+хочу|не\s+люблю)\s+([\w'’\-]{3,})",
348    ]
349    found: List[str] = []
350    for p in patterns:
351        for m in re.findall(p, low, flags=re.UNICODE):
352            if m and m not in found:
353                found.append(m)
354    return found
355 
356 
357def _is_drink(item: Dict[str, object]) -> bool:
358    cat = str(item.get("category_name", "")).lower()
359    return any(k in cat for k in DRINK_CATEGORY_HINTS)
360 
361 
362def _is_food(item: Dict[str, object]) -> bool:
363    return not _is_drink(item)
364 
365 
366def _wants_drink(preference_text: str) -> bool:
367    low = (preference_text or "").lower()
368    return any(h in low for h in DRINK_INTENT_HINTS)
369 
370 
371def _item_text(item: Dict[str, object]) -> Tuple[str, str, str]:
372    name = str(item.get("name", "")).lower()
373    desc = str(item.get("description", "")).lower()
374    cat = str(item.get("category_name", "")).lower()
375    return name, desc, cat
376 
377 
378def _score_item(item: Dict[str, object], terms: Sequence[str]) -> Tuple[int, List[str]]:
379    name, desc, cat = _item_text(item)
380    score = 0
381    matched: List[str] = []
382    for t in terms:
383        tt = t.lower()
384        if tt in name:
385            score += 6
386            matched.append(tt)
387        elif tt in cat:
388            score += 4
389            matched.append(tt)
390        elif tt in desc:
391            score += 2
392            matched.append(tt)
393    if item.get("media_url"):
394        score += 1
395    if item.get("description"):
396        score += 1
397    return score, matched
398 
399 
400def suggest_combo(
401    dataset: Dict[str, object],
402    preference_text: str,
403    likes: Sequence[str],
404    avoid_terms: Sequence[str],
405    no_alcohol: bool,
406    budget: Optional[float],
407    with_drink: str,
408    limit: int = 3,
409) -> List[Dict[str, object]]:
410    items = [x for x in _iter_items(dataset) if bool(x.get("available", True))]
411 
412    auto_terms = _tokenize_preference_text(preference_text)
413    explicit_terms = [x.strip().lower() for x in likes if x.strip()]
414    positive_terms = _expand_positive_terms(list(dict.fromkeys(explicit_terms + auto_terms)))
415 
416    auto_avoid = _extract_avoid_terms(preference_text)
417    all_avoid = list(dict.fromkeys([x.strip().lower() for x in avoid_terms if x.strip()] + auto_avoid))
418 
419    def avoid_variants(term: str) -> List[str]:
420        t = term.strip().lower()
421        variants = [t]
422        stripped = re.sub(r"[уюоеаияіь]+$", "", t)
423        if len(stripped) >= 3:
424            variants.append(stripped)
425        if len(t) >= 4:
426            variants.append(t[:4])
427        return list(dict.fromkeys([v for v in variants if len(v) >= 3]))
428 
429    avoid_all_variants = []
430    for a in all_avoid:
431        avoid_all_variants.extend(avoid_variants(a))
432    avoid_all_variants = list(dict.fromkeys(avoid_all_variants))
433 
434    def bad(item: Dict[str, object]) -> bool:
435        text = " ".join(_item_text(item))
436        return any(a in text for a in avoid_all_variants)
437 
438    foods = [x for x in items if _is_food(x) and not bad(x)]
439    drinks = [x for x in items if _is_drink(x) and not bad(x)]
440 
441    if no_alcohol:
442        drinks = [x for x in drinks if not _is_alcohol(x)]
443 
444    scored_foods: List[Tuple[int, Dict[str, object], List[str]]] = []
445    for f in foods:
446        s, m = _score_item(f, positive_terms)
447        scored_foods.append((s, f, m))
448 
449    scored_drinks: List[Tuple[int, Dict[str, object], List[str]]] = []
450    for d in drinks:
451        s, m = _score_item(d, positive_terms)
452        scored_drinks.append((s, d, m))
453 
454    # If no clear terms, fallback to balanced picks (with photos first, then cheaper first).
455    def food_sort_key(x: Tuple[int, Dict[str, object], List[str]]) -> Tuple[int, int, float]:
456        score, item, _ = x
457        has_photo = 1 if item.get("media_url") else 0
458        price = float(item.get("price_uah") or 0)
459        return (score, has_photo, -price)
460 
461    def drink_sort_key(x: Tuple[int, Dict[str, object], List[str]]) -> Tuple[int, int, float]:
462        score, item, _ = x
463        has_photo = 1 if item.get("media_url") else 0
464        price = float(item.get("price_uah") or 0)
465        return (score, has_photo, -price)
466 
467    scored_foods.sort(key=food_sort_key, reverse=True)
468    scored_drinks.sort(key=drink_sort_key, reverse=True)
469 
470    need_drink = with_drink == "yes" or (with_drink == "auto" and _wants_drink(preference_text))
471 
472    suggestions: List[Tuple[float, Dict[str, object]]] = []
473 
474    if need_drink:
475        for fs, food, fmatch in scored_foods[:18]:
476            f_price = float(food.get("price_uah") or 0)
477            for ds, drink, dmatch in scored_drinks[:24]:
478                d_price = float(drink.get("price_uah") or 0)
479                total = f_price + d_price
480                if budget is not None and total > budget:
481                    continue
482                rank = (fs * 10 + ds) - abs((budget or total) - total)
483                suggestions.append(
484                    (
485                        rank,
486                        {
487                            "main": food,
488                            "drink": drink,
489                            "total_uah": round(total, 2),
490                            "matched_terms": list(dict.fromkeys(fmatch + dmatch)),
491                        },
492                    )
493                )
494    else:
495        for fs, food, fmatch in scored_foods[:40]:
496            total = float(food.get("price_uah") or 0)
497            if budget is not None and total > budget:
498                continue
499            rank = fs - abs((budget or total) - total)
500            suggestions.append(
501                (
502                    rank,
503                    {
504                        "