_fast5.py

# -*- coding: utf-8 -*-
import asyncio, sys, os, random, textwrap
from pathlib import Path
sys.path.insert(0, ".")

CITIES = [
    # крупные — много объектов
    "Краснодар","Воронеж","Самара","Саратов","Уфа","Тула","Ростов-на-Дону",
    "Красноярск","Хабаровск","Владивосток","Иркутск","Томск","Кемерово",
    # средние
    "Архангельск","Вологда","Тамбов","Белгород","Владимир","Ярославль",
    "Псков","Чебоксары","Саранск","Рязань","Пенза","Ульяновск","Киров",
    "Смоленск","Нижний Тагил","Магнитогорск","Стерлитамак","Сыктывкар",
    "Великий Новгород","Иваново","Кострома","Брянск","Калуга","Тверь",
    "Курск","Липецк","Орёл","Тамбов",
]
CATEGORY = "барбершоп"
RATING_MIN, RATING_MAX = 3.0, 4.6
NEG_THRESHOLD, NEG_THRESHOLD_EX = 3, 4
MIN_NEG, MAX_NEG = 1, 6
MAX_REVIEWS, NEED = 15, 5
LM_HOST, LM_MODEL = "http://localhost:1234", "local-model"
OUT_PATH = Path("output/leads_fast5.txt")

KNOWN_NAMES = {
    "барбершоп","5th avenue","barber blade","чио чио","gallant","штучка","hillman",
    "hair club ivanova","время стрижки","ножни-чик","модная цирюльня","джанго",
    "hair lab","зевс","chop x chop","dandy","лилия","friday",
}
PAIN_KW = [
    # запись / дозвон
    "запис","дозвон","не берут","трубку","не дозвон","недозвон","сбросил",
    "не отвечают","не перезвон","молчат","игнорир",
    # ожидание / опоздание
    "ждал","ждала","ждать","опоздал","опоздали","задержал","минут жд","час жд",
    # отмена / не предупредили
    "не предупредил","не позвонили","не написали","отменил","перенёс","перенос",
    "без предупреждения","закрыт","не открыт","не было никого",
    # потеря записи
    "не нашли","не было записи","не записан","в расписании нет",
    # мессенджеры
    "директ","вотсап","whatsapp","телефон",
    # качество / не слушают
    "не слушают","не то","сделали иначе","просил не","испортил","обкарнал",
    "не так как","пожелани",
    # хамство
    "нагрубил","хамит","грубо","по-хамски","накричал",
]
_BOOKING = {"yclients":"YClients","dikidi":"Dikidi","altegio":"Altegio",
            "easyweek":"EasyWeek","universeapp":"Universe"}


def _ps(t): return sum(1 for kw in PAIN_KW if kw in t.lower())

def _pain_quote(t):
    tl = t.lower()
    for kw in PAIN_KW:
        if kw in tl:
            i = tl.index(kw)
            return t[max(0, i-50):i+150].strip()

def _neg(reviews):
    ok = [rv for rv in reviews if rv.text.strip() and rv.rating is not None]
    strict = [rv for rv in ok if rv.rating <= NEG_THRESHOLD]
    pool = strict if len(strict) >= MIN_NEG else [rv for rv in ok if rv.rating <= NEG_THRESHOLD_EX]
    pool.sort(key=lambda rv: (rv.rating, -_ps(rv.text)))
    return pool[:MAX_NEG]

def _bf(card):
    if not card.has_booking: return []
    url = (card.booking_url or "").lower()
    for f, n in _BOOKING.items():
        if f in url: return [n]
    return ["онлайн-запись"]

def _tag(wa, tg):
    return "[WA+TG]" if (wa and tg) else ("[WA]" if wa else "[TG]")


def _write(c, n):
    wa, tg = c["whatsapp"], c["telegram"]
    bf = c.get("booking_found", [])
    lines = [
        f"\n{'─'*72}",
        f"ЛИД #{n}  {_tag(wa,tg)}  |  {c['name']}  |  {c['city']}  |  *{c['rating']}",
        f"Адрес   : {c['address']}",
        f"Тел     : {c['phones']}",
    ]
    if wa: lines.append(f"WA      : {wa}")
    if tg: lines.append(f"TG      : {tg}")
    lines += [
        f"Ссылка  : {c['card_url']}",
        f"Запись  : {', '.join(bf) if bf else 'только звонки/мессенджеры'}",
        f"Негативных: {len(c['neg_reviews'])}  |  боль: {c['pain_count']}",
        "",
        "НЕГАТИВНЫЕ ОТЗЫВЫ:",
    ]
    for j, rv in enumerate(c["neg_reviews"], 1):
        pm = " [БОЛЬ]" if rv["pain_score"] > 0 else ""
        lines.append(f"  {j}. *{rv['rating']}  {rv['author']}{pm}")
        lines.append(textwrap.fill(rv["text"], 68,
                                   initial_indent="     ", subsequent_indent="     "))
    lines += ["", f"БОЛЬ: {c['pain_summary']}", "",
              "СКРИПТ:", "."*72, c["script"], "."*72]
    with open(OUT_PATH, "a", encoding="utf-8") as f:
        f.write("\n".join(lines) + "\n")
        f.flush()
    print(f"  >> лид #{n} -> {OUT_PATH}", flush=True)


async def main():
    from playwright.async_api import async_playwright
    from scraper_yandex import search_cards, parse_card
    from dialog_gen import generate_dialog
    from card_cache import CardCache

    cache = CardCache()
    print(f"Кэш: {cache.size()} карточек", flush=True)
    results = []

    OUT_PATH.parent.mkdir(exist_ok=True)
    with open(OUT_PATH, "w", encoding="utf-8") as f:
        f.write("="*72 + "\n")
        f.write(f"ЛИДЫ {RATING_MIN}-{RATING_MAX}*  |  только WA/TG  |  нужно: {NEED}\n")
        f.write("="*72 + "\n")

    async with async_playwright() as pw:
        browser = await pw.chromium.launch(
            headless=True,
            args=["--disable-blink-features=AutomationControlled", "--no-sandbox"],
        )
        ctx = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
            locale="ru-RU", timezone_id="Europe/Moscow",
            viewport={"width": 1440, "height": 900},
        )
        await ctx.add_init_script(
            "Object.defineProperty(navigator,'webdriver',{get:()=>undefined})"
        )
        page = await ctx.new_page()

        for city in CITIES:
            if len(results) >= NEED: break
            print(f"\n=== {city} ===", flush=True)
            urls = await search_cards(page, city, CATEGORY, 30, 0.2, 0.5)
            print(f"  URL: {len(urls)}", flush=True)

            for url in urls:
                if len(results) >= NEED: break
                await asyncio.sleep(random.uniform(0.2, 0.4))

                cached = cache.get(url)
                if cached:
                    card, reviews = cached
                else:
                    card, reviews = await parse_card(page, url, city, CATEGORY, max_reviews=MAX_REVIEWS)
                    if card is None: continue
                    cache.put(url, card, reviews)

                if card is None or _is_known(card.name): continue

                r = card.rating
                if r is None or not (RATING_MIN <= r <= RATING_MAX): continue

                if not card.whatsapp and not card.telegram:
                    print(f"  нет мессенджера  *{r}  {card.name}", flush=True)
                    continue

                neg = _neg(reviews)
                if not neg:
                    print(f"  нет neg  *{r}  {card.name}", flush=True); continue

                pc = sum(1 for rv in neg if _ps(rv.text) > 0)
                if pc == 0:
                    print(f"  нет боли  *{r}  {card.name}", flush=True); continue

                print(f"  OK *{r}  {card.name}  {_tag(card.whatsapp,card.telegram)}  neg:{len(neg)} боль:{pc}", flush=True)

                top = next(rv for rv in neg if _ps(rv.text) > 0)
                card.pain_point_match = True
                card.pain_point_evidence = _pain_quote(top.text) or ""
                bf = _bf(card)

                print("    -> диалог...", flush=True)
                try:
                    script = generate_dialog(card,
                                             reviews=[rv.text for rv in neg],
                                             booking_found=bf,
                                             endpoint=LM_HOST, model=LM_MODEL)
                except Exception as e:
                    script = f"(ошибка: {e})"

                lead = {
                    "city": city, "name": card.name, "rating": r,
                    "address": card.address, "phones": card.phones_str,
                    "whatsapp": card.whatsapp or "", "telegram": card.telegram or "",
                    "card_url": card.card_url,
                    "neg_reviews": [{"rating": rv.rating, "author": rv.author,
                                     "text": rv.text, "pain_score": _ps(rv.text)} for rv in neg],
                    "pain_count": pc, "booking_found": bf,
                    "pain_summary": f"«{card.pain_point_evidence[:150]}»",
                    "script": script,
                }
                results.append(lead)
                _write(lead, len(results))

        await browser.close()

    with open(OUT_PATH, "a", encoding="utf-8") as f:
        f.write(f"\n{'='*72}\nИТОГО: {len(results)} лидов\n{'='*72}\n")
    print(f"\nГотово: {len(results)} лидов", flush=True)


def _is_known(name): return name.lower().strip() in KNOWN_NAMES

asyncio.run(main())