명단 말고 대화에서 뽑는 힌트

import math
import re
from collections import Counter

RECENT_TURNS = 30          # the last turns read, newest first
TOPIC_TERMS_MAX = 20       # topic words sent
RARE_SHARE = 0.003         # rare: held by at most this share of background turns
RARE_FLOOR = 3.0           # ...or by this many, whichever is larger
JOSA = sorted("에서는 이랑 에서 까지 부터 처럼 으로 이야 이다 은 는 이 가 을 를 에 도 만 의 와 과 랑 로 야 다".split(),
              key=len, reverse=True)
HANGUL = re.compile(r"[가-힣]{2,}")
# A predicate's ending, never a word Dad names (왔어, 유명하대, 맛있게).
PREDICATE = re.compile(r"(어|대|게|요|해|하|다|니까|는데)$")


def stem(word: str) -> str:
    """크로켓은 -> 크로켓, 입구야 -> 입구; a stem keeps two syllables."""
    for josa in JOSA:
        if word.endswith(josa) and len(word) - len(josa) >= 2:
            return word[: -len(josa)]
    return word


def noun_like(word: str) -> str | None:
    """A noun with its particle off, or None for a predicate or a stub (바에).
    The engine also asks for noun evidence (a particle only nouns take, or the
    bare word standing alone twice); this sketch leaves that rule out."""
    base = stem(word)
    if base == word and any(word.endswith(j) for j in JOSA):
        return None                      # too short to cut, still ends in a particle
    if PREDICATE.search(base):
        return None                      # 왔어, 유명하대, 걷다: a verb, not a topic
    return base


def words(text: str) -> set[str]:
    return {w for w in map(noun_like, HANGUL.findall(text)) if w}


def topic_terms(recent: list[tuple[str, str]], background: list[str]) -> list[str]:
    """recent: (role, text), newest first. Rare in the history, used here now."""
    seen = Counter(w for turn in background for w in words(turn))
    n = len(background)
    rare_line = max(RARE_FLOOR, n * RARE_SHARE)
    score: Counter = Counter()
    turns = recent[:RECENT_TURNS]
    for age, (role, text) in enumerate(turns):
        weight = 1.0 - 0.5 * age / max(1, len(turns) - 1)   # 1.0 newest -> 0.5 oldest
        if role == "dad":
            weight *= 2                                       # his own words count double
        for w in words(text):
            if seen[w] <= rare_line:
                score[w] += weight * (1 + math.log((n + 1) / (seen[w] + 1)))
    return [w for w, _ in score.most_common(TOPIC_TERMS_MAX)]


def keyterms(spoken_to: str, souls: dict[str, str], recent, background) -> list[str]:
    """The soul spoken to always; another soul only when the talk just named it."""
    named = [k for k in souls.values() if any(k in text for _, text in recent)]
    terms = [souls[spoken_to]] + [k for k in named if k != souls[spoken_to]]
    return terms + [t for t in topic_terms(recent, background) if t not in terms]


# A history of 4,000 turns: hotels and dinners everywhere, croquettes almost never.
background = (["호텔 체크인 끝났어"] * 111 + ["크로켓 맛있었어"] * 11
              + ["오늘 저녁 메뉴 뭐야"] * 600 + ["여기 근처 최고 맛집 알려줘"] * 400
              + ["내일 일정 알려줘"] * 2878)
souls = {"pippa": "피파", "buffett": "버핏", "feynman": "파인만"}
recent = [("dad", "크로켓은 여기가 최고다"),
          ("pippa", "그 집 크로켓이랑 하몬 둘 다 유명하대"),
          ("dad", "호텔 근처 타파스 바에 왔어")]

print("every soul's name :", list(souls.values()))
print("the new hint      :", keyterms("pippa", souls, recent, background))


# Output:
# every soul's name : ['피파', '버핏', '파인만']
# the new hint      : ['피파', '크로켓', '타파스', '하몬']
#   (호텔 is in 111 of 4,000 turns: too common to be this talk's word)