suggest.py

"""Подстановки, которые находятся сами - по истории диктовок.

Зачем. Страница «Слова» была формой, которую надо заполнять руками, и владелец
вынес ей приговор: «словари нужны каким-то айтишникам, никто это заполнять не
будет». Он прав, и доказательство лежало в самом проекте - демо-конфиг с
«Соколов, Кубернетес, Постгрес». Это список инженера, а не человека, который
пишет письма.

Голосовую команду «запомни: моя почта - такая-то» он отверг тем же доводом:
«это то же самое, только диктуешь вместо того, чтобы печатать». Тоже верно -
работа остаётся на человеке, меняется лишь способ ввода.

Значит источник должен быть один: то, что человек уже наговорил. Мы ищем в
истории то, что он повторяет, и предлагаем дать этому короткую фразу.

**Что мы НЕ делаем, и это важно.** Мы не придумываем, как эту фразу назвать.
Найти повтор машина может, а назвать его по-человечески - нет: «roman@почта»
это «моя почта», «рабочая» или «для счетов» - знает только владелец. Поэтому
находка приносит ЗНАЧЕНИЕ, а имя даёт человек. Одно поле вместо двух, и то
поле, которое без него не заполнить.

Всё считается локально и по уже сохранённой истории: ни одного нового байта
никуда не уходит.
"""

import re
from collections import Counter

# Точные штуки, которые диктовать мучительно, а ошибиться легко. Им хватает
# двух повторов: адрес почты, набранный дважды, - это уже привычка.
_EXACT = (
    ("почта", re.compile(r"\b[\w.+-]+@[\w-]+\.[\w.]{2,}\b", re.UNICODE)),
    ("ссылка", re.compile(r"\bhttps?://\S+|\b[\w-]+\.(?:ru|com|org|net|io)/\S*",
                          re.IGNORECASE)),
    ("телефон", re.compile(r"(?:\+7|8)[\s\-(]*\d{3}[\s\-)]*\d{3}[\s\-]*\d{2}[\s\-]*\d{2}")),
)

_MIN_EXACT = 2          # почте и телефону хватает двух раз
_MIN_PHRASE = 3         # обычной фразе - трёх: два раза бывает совпадением
_PHRASE_WORDS = (4, 14)  # короче - шум («я думаю, что»), длиннее - не повторяют
_MAX_OUT = 3            # больше трёх предложений подряд - это уже навязывание

_WORD = re.compile(r"[\w@.+-]+", re.UNICODE)


def _worth_it(phrase: str) -> bool:
    """Есть ли в повторе содержание, ради которого стоит заводить подстановку.

    Первый же прогон на живой истории нашёл «я хочу чтобы ты» - повторено
    честные три раза, и совершенно бесполезно. Повторяются не только адреса и
    реквизиты, но и служебные связки, которыми человек начинает каждую вторую
    фразу. Предложить такое - значит выдать шум за находку и научить человека
    закрывать наши предложения не читая.

    Признак содержания берём грубый, но проверяемый: цифра, собака, заглавная
    буква в середине (имя собственное) или хотя бы два длинных слова. «Собери
    сводку по продажам за июнь» проходит, «я хочу чтобы ты» - нет. Это
    эвристика, и её придётся править по живым находкам: сюда стоит смотреть,
    когда предложения начнут раздражать.
    """
    if any(ch.isdigit() for ch in phrase) or "@" in phrase:
        return True
    words = _WORD.findall(phrase)
    # Заглавная не в первом слове - почти наверняка имя, название или город.
    if any(w[:1].isupper() for w in words[1:]):
        return True
    return sum(1 for w in words if len(w) >= 6) >= 2


def _norm(s: str) -> str:
    """Для сравнения: регистр и хвостовая пунктуация не должны делать из одной
    и той же фразы две разных."""
    return s.strip(" .,!?;:«»\"'").lower().replace("ё", "е")


def find(rows: list, snippets: dict | None = None, skip: list | None = None) -> list:
    """Что стоит предложить. [{value, count, kind}], самое частое первым.

    rows      - записи истории: словари с ключом «text»;
    snippets  - уже заведённые подстановки: их значения не предлагаем повторно;
    skip      - от чего человек отказался: не возвращаемся к этому никогда.
    """
    known = {_norm(v) for v in (snippets or {}).values()}
    known |= {_norm(v) for v in (skip or [])}
    texts = [str(r.get("text") or "") for r in rows if r.get("text")]
    if len(texts) < _MIN_EXACT:
        return []

    out: list[dict] = []

    # 1. Точные штуки. Считаем по числу диктовок, а не вхождений: адрес, дважды
    # названный в одной фразе, - это не привычка, а перечисление.
    for kind, rx in _EXACT:
        seen = Counter()
        for t in texts:
            for m in {m.group(0) for m in rx.finditer(t)}:
                seen[m] += 1
        for value, count in seen.items():
            if count >= _MIN_EXACT and _norm(value) not in known:
                out.append({"value": value, "count": count, "kind": kind})

    # 2. Повторяющиеся фразы. Только целыми словами и только те, что встретились
    # в разных диктовках: одна длинная фраза, повторённая внутри себя, повтором
    # не является.
    lo, hi = _PHRASE_WORDS
    phrase_docs: dict = {}
    for i, t in enumerate(texts):
        words = _WORD.findall(t)
        here = set()
        for n in range(lo, hi + 1):
            for j in range(len(words) - n + 1):
                here.add(" ".join(words[j:j + n]))
        for ph in here:
            phrase_docs.setdefault(_norm(ph), (ph, set()))[1].add(i)

    phrases = [(orig, len(docs)) for _k, (orig, docs) in phrase_docs.items()
               if len(docs) >= _MIN_PHRASE and _norm(orig) not in known
               and _worth_it(orig)]
    # Из вложенных и НАЕЗЖАЮЩИХ повторов берём один - самый длинный.
    #
    # Вложенность одна проверку не проходит, и это выяснилось на тесте. Одна
    # фраза в одиннадцать слов даёт три окна по девять, сдвинутых на слово:
    # «Собери сводку по продажам за июнь и пришли до», «сводку по продажам за
    # июнь и пришли до конца», «по продажам за июнь и пришли до конца дня». Ни
    # одно не содержит другое, так что проверка вложенности пропускала все три,
    # и человек увидел бы три почти одинаковых предложения подряд. Ровно то, от
    # чего он перестаёт их читать.
    #
    # Поэтому сравниваем по словам: если у кандидата больше половины слов общие
    # с уже выбранным, это та же находка, только сдвинутая.
    phrases.sort(key=lambda p: (-len(p[0]), -p[1]))
    chosen: list = []
    for text, count in phrases:
        words = set(_norm(w) for w in _WORD.findall(text))
        same = False
        for c in chosen:
            other = set(_norm(w) for w in _WORD.findall(c["value"]))
            if len(words & other) / max(1, len(words)) > 0.5:
                same = True
                break
        if same:
            continue
        chosen.append({"value": text, "count": count, "kind": "фраза"})
    out.extend(chosen)

    # Сначала самое частое, при равенстве - самое длинное: длинное экономит
    # больше.
    out.sort(key=lambda c: (-c["count"], -len(c["value"])))
    return out[:_MAX_OUT]