agent.py разбирает фразу в план (намерение, персона, жанр, тема, эпоха, оценка) и выполняет запрос. Словарь берётся из графа, поэтому агент знает только то, что есть в медиатеке. Понимает русские синонимы (фантастика → science fiction, искусственный интеллект → artificial intelligence, робот → robot) и транслитерацию имён («фильмы Нолана» → Christopher Nolan). Эпохи в любом виде, оценки по словам. Пять намерений: подбор, фильмография, по десятилетиям, похожее, сравнение. При пустом результате ослабляет условия по одному и сообщает об этом. Показывает, как понял запрос. Вызовы: команда «агент», свободный текст Медиа-бота, и «найди» с падением в граф, когда в Jellyfin пусто. Проверено: Нолан → Interstellar; ИИ по десятилетиям (1980-е 1, 1990-е 1, 2000-е 2, 2010-е 2); похоже на Дюну → 8 фильмов; высокорейтинговые 80-х → Blade Runner; «найди про роботов с рейтингом» → 7 фильмов. Попутно: /pick получил фильтры по персоне и оценке; /compare сравнивает книгу и фильм (общие и разные жанры, автор, связь экранизации); поиск ядра понимает русские окончания (Дюну → Dune). Ловушки: явная команда первым словом (иначе «похоже» перехватывало запрос), порог основы для коротких слов, и восстановление аналитических функций, случайно срезанных при замене do_pick.
335 lines
13 KiB
Python
335 lines
13 KiB
Python
"""Агент по графу: понимает фразу, строит план и выполняет запросы.
|
||
|
||
Работает без LLM: словарь берётся из самого графа (персоны, жанры, темы,
|
||
десятилетия), поэтому агент знает ровно то, что есть в медиатеке.
|
||
"""
|
||
import json
|
||
import re
|
||
import time
|
||
import urllib.error
|
||
import urllib.parse
|
||
import urllib.request
|
||
|
||
CORE = "http://127.0.0.1:9120"
|
||
CACHE = {"at": 0, "vocab": None}
|
||
TTL = 300
|
||
|
||
|
||
def _get(path, params=None, timeout=15):
|
||
url = CORE + path
|
||
if params:
|
||
url += "?" + urllib.parse.urlencode(params)
|
||
try:
|
||
with urllib.request.urlopen(url, timeout=timeout) as r:
|
||
return json.loads(r.read() or b"{}"), None
|
||
except Exception as e:
|
||
return None, str(e)[:120]
|
||
|
||
|
||
def vocab():
|
||
"""Словарь графа: персоны, жанры, темы, эпохи."""
|
||
if CACHE["vocab"] and time.time() - CACHE["at"] < TTL:
|
||
return CACHE["vocab"]
|
||
v = {"persons": [], "genres": [], "themes": [], "decades": []}
|
||
for kind, key in (("актёр", "persons"), ("режиссёр", "persons"),
|
||
("композитор", "persons"), ("жанр", "genres"),
|
||
("тема", "themes"), ("эпоха", "decades")):
|
||
data, _ = _get("/entities", {"kind": kind, "limit": 500})
|
||
for it in (data or {}).get("items") or []:
|
||
v[key].append(it.get("title"))
|
||
v["persons"] = sorted(set(v["persons"]))
|
||
v["genres"] = sorted(set(v["genres"]))
|
||
v["themes"] = sorted(set(v["themes"]))
|
||
v["decades"] = sorted(set(v["decades"]))
|
||
CACHE.update({"at": time.time(), "vocab": v})
|
||
return v
|
||
|
||
|
||
|
||
|
||
# ── русские синонимы тем и жанров графа ──
|
||
RU_THEMES = {
|
||
"искусственн": "artificial intelligence",
|
||
"интеллект": "artificial intelligence",
|
||
"робот": "robot",
|
||
"андроид": "android",
|
||
"космос": "space",
|
||
"космическ": "space",
|
||
"будущ": "future",
|
||
"антиутоп": "dystopia",
|
||
"постапокал": "post-apocalyptic",
|
||
"время": "time travel",
|
||
"путешеств": "time travel",
|
||
"инопланет": "alien",
|
||
"чужой": "alien",
|
||
"монстр": "monster",
|
||
"катастроф": "disaster",
|
||
"война": "war",
|
||
"супергеро": "superhero",
|
||
"магия": "magic",
|
||
"детектив": "detective",
|
||
"любов": "love",
|
||
"месть": "revenge",
|
||
"школ": "school",
|
||
"зомби": "zombie",
|
||
"вампир": "vampire",
|
||
"дракон": "dragon",
|
||
"рыцар": "knight",
|
||
"пират": "pirate",
|
||
}
|
||
|
||
RU_GENRES = {
|
||
"фантастик": "science fiction",
|
||
"фэнтези": "fantasy",
|
||
"фентези": "fantasy",
|
||
"ужас": "horror",
|
||
"хоррор": "horror",
|
||
"комеди": "comedy",
|
||
"драм": "drama",
|
||
"боевик": "action",
|
||
"триллер": "thriller",
|
||
"детектив": "mystery",
|
||
"приключен": "adventure",
|
||
"мелодрам": "romance",
|
||
"документальн": "documentary",
|
||
"анимаци": "animation",
|
||
}
|
||
|
||
TRANSLIT = {
|
||
"а": "a", "б": "b", "в": "v", "г": "g", "д": "d", "е": "e", "ё": "e",
|
||
"ж": "zh", "з": "z", "и": "i", "й": "y", "к": "k", "л": "l", "м": "m",
|
||
"н": "n", "о": "o", "п": "p", "р": "r", "с": "s", "т": "t", "у": "u",
|
||
"ф": "f", "х": "h", "ц": "ts", "ч": "ch", "ш": "sh", "щ": "sch",
|
||
"ъ": "", "ы": "y", "ь": "", "э": "e", "ю": "yu", "я": "ya",
|
||
}
|
||
|
||
|
||
def translit(text):
|
||
return "".join(TRANSLIT.get(ch, ch) for ch in (text or "").lower())
|
||
|
||
|
||
def match_person(text, persons):
|
||
"""Ищем персону: латиницей напрямую или через транслитерацию."""
|
||
low = text.lower()
|
||
for p in persons:
|
||
if p and p.lower() in low:
|
||
return p
|
||
tr = translit(text)
|
||
best = None
|
||
for p in persons:
|
||
for token in (p or "").lower().split():
|
||
if len(token) < 4:
|
||
continue
|
||
stem = token[:5]
|
||
if stem and stem in tr:
|
||
best = p
|
||
break
|
||
if best:
|
||
break
|
||
return best
|
||
|
||
|
||
def match_by_dict(text, mapping, vocabulary):
|
||
"""Русское слово → английское значение из словаря графа."""
|
||
low = text.lower()
|
||
for ru, en in mapping.items():
|
||
if ru in low:
|
||
for v in vocabulary:
|
||
if v and en.lower() in v.lower():
|
||
return v
|
||
return None
|
||
|
||
|
||
def _contains_any(text, words):
|
||
low = text.lower()
|
||
return any(w in low for w in words)
|
||
|
||
|
||
def parse(text, v=None):
|
||
"""План: что понял агент."""
|
||
v = v or vocab()
|
||
low = text.lower()
|
||
plan = {"raw": text, "intent": None, "person": None, "genre": None,
|
||
"theme": None, "decade": None, "rating": None, "targets": []}
|
||
|
||
# интент
|
||
if _contains_any(low, ("сравн", "общего", "отлича")):
|
||
plan["intent"] = "compare"
|
||
elif _contains_any(low, ("когда", "динамик", "по годам", "десятилет")):
|
||
plan["intent"] = "timeline"
|
||
elif _contains_any(low, ("кто снимал", "кто снял", "с кем", "фильмы с", "фильмография")):
|
||
plan["intent"] = "person"
|
||
elif _contains_any(low, ("похож", "как ", "вроде")):
|
||
plan["intent"] = "similar"
|
||
else:
|
||
plan["intent"] = "pick"
|
||
|
||
# персона: латиница или транслитерация
|
||
plan["person"] = match_person(text, v["persons"])
|
||
|
||
# эпоха
|
||
m = re.search(r"(19|20)\d{2}", text)
|
||
if m:
|
||
plan["decade"] = str((int(m.group(0)) // 10) * 10) + "-е"
|
||
else:
|
||
m2 = re.search(r"\b(\d{2})\s*(?:-?е|-?х|ые|ых)\b", text)
|
||
if m2:
|
||
two = int(m2.group(1))
|
||
year = (1900 + two) if two >= 30 else (2000 + two)
|
||
plan["decade"] = str((year // 10) * 10) + "-е"
|
||
|
||
# жанр: прямое совпадение или русский синоним
|
||
genre = None
|
||
for g in v["genres"]:
|
||
if g and g.lower() in low:
|
||
genre = g
|
||
break
|
||
if not genre:
|
||
genre = match_by_dict(text, RU_GENRES, v["genres"])
|
||
plan["genre"] = genre
|
||
|
||
# тема: прямое совпадение или русский синоним
|
||
theme = None
|
||
for t in sorted(v["themes"], key=len, reverse=True):
|
||
if len(t) > 4 and t.lower() in low:
|
||
theme = t
|
||
break
|
||
if not theme:
|
||
theme = match_by_dict(text, RU_THEMES, v["themes"])
|
||
plan["theme"] = theme
|
||
|
||
# оценка
|
||
if _contains_any(low, ("высок", "отличн", "8+", "лучш", "топ")):
|
||
plan["rating"] = "высокая"
|
||
elif _contains_any(low, ("неплох", "хорош", "7+")):
|
||
plan["rating"] = "хорошая"
|
||
|
||
# цели для сравнения/похожего: всё, что похоже на название
|
||
for token in re.findall(r"«([^»]+)»|\"([^\"]+)\"", text):
|
||
t = token[0] or token[1]
|
||
if t:
|
||
plan["targets"].append(t)
|
||
|
||
if not plan["targets"]:
|
||
m3 = re.search(r"(?:похож\w*\s+на|вроде|как)\s+(.+)", text, re.IGNORECASE)
|
||
if m3:
|
||
plan["targets"].append(m3.group(1).strip().strip(".,!?"))
|
||
return plan
|
||
|
||
|
||
def describe(plan):
|
||
parts = []
|
||
names = {"pick": "подбор", "person": "фильмография", "timeline": "по десятилетиям",
|
||
"similar": "похожее", "compare": "сравнение"}
|
||
parts.append("намерение: " + names.get(plan["intent"], plan["intent"]))
|
||
for key, label in (("person", "персона"), ("genre", "жанр"), ("theme", "тема"),
|
||
("decade", "эпоха"), ("rating", "оценка")):
|
||
if plan.get(key):
|
||
parts.append(label + ": " + str(plan[key]))
|
||
return ", ".join(parts)
|
||
|
||
|
||
def run(text):
|
||
"""Выполнить запрос. Возвращает (ответ, план)."""
|
||
v = vocab()
|
||
plan = parse(text, v)
|
||
intent = plan["intent"]
|
||
|
||
if intent == "pick":
|
||
params = {"limit": 10}
|
||
for key in ("genre", "theme", "decade", "rating", "person"):
|
||
if plan.get(key):
|
||
params[key] = plan[key]
|
||
data, err = _get("/pick", params)
|
||
if err:
|
||
return "Не смог получить данные: " + err, plan
|
||
items = (data or {}).get("items") or []
|
||
relaxed = []
|
||
for key in ("rating", "theme", "genre", "decade", "person"):
|
||
if items or key not in params:
|
||
continue
|
||
del params[key]
|
||
relaxed.append(key)
|
||
data, err = _get("/pick", params)
|
||
if err:
|
||
break
|
||
items = (data or {}).get("items") or []
|
||
if not items:
|
||
return "По таким условиям в медиатеке ничего нет.", plan
|
||
plan["relaxed"] = relaxed
|
||
lines = ["Нашёл " + str(len(items)) + ":", ""]
|
||
if plan.get("relaxed"):
|
||
lines.insert(0, "_условия ослаблены: убрал " + ", ".join(plan["relaxed"]) + "_")
|
||
for i in items:
|
||
parts = [str(i.get("title"))]
|
||
if i.get("rating"):
|
||
parts.append(str(i.get("rating")))
|
||
if i.get("genres"):
|
||
parts.append(str(i.get("genres")))
|
||
lines.append("• " + " — ".join(parts))
|
||
return "\n".join(lines), plan
|
||
|
||
if intent == "person":
|
||
if not plan["person"]:
|
||
return "Не понял, кто имеется в виду. Назовите имя.", plan
|
||
data, err = _get("/person", {"q": plan["person"]})
|
||
if err or not data:
|
||
return "Персону не нашёл.", plan
|
||
films = data.get("films") or []
|
||
lines = ["**" + str(plan["person"]) + "**, фильмов: " + str(len(films)), ""]
|
||
for f in films[:15]:
|
||
lines.append("• " + str(f.get("title")))
|
||
return "\n".join(lines), plan
|
||
|
||
if intent == "timeline":
|
||
node = plan.get("theme") or plan.get("genre")
|
||
if not node:
|
||
return "Укажите тему или жанр: например «когда были фильмы про искусственный интеллект».", plan
|
||
kind = "тема" if plan.get("theme") else "жанр"
|
||
data, err = _get("/timeline", {"q": node, "kind": kind})
|
||
if err or not data:
|
||
return "Не нашёл такую тему.", plan
|
||
lines = ["**" + str(node) + " по десятилетиям**", ""]
|
||
for d in data.get("decades") or []:
|
||
lines.append("• " + str(d.get("decade")) + " — " + str(d.get("n")))
|
||
return "\n".join(lines), plan
|
||
|
||
if intent == "similar":
|
||
target = plan["targets"][0] if plan["targets"] else None
|
||
if not target:
|
||
return "Скажите, похоже на что: «похоже на Дюну».", plan
|
||
card, _ = _get("/search", {"q": target})
|
||
items = (card or {}).get("items") or []
|
||
film = next((i for i in items if i.get("kind") in ("фильм", "книга")), None)
|
||
if not film:
|
||
return "Не нашёл «" + target + "» в графе.", plan
|
||
data, err = _get("/similar", {"id": film["id"]})
|
||
if err or not data:
|
||
return "Похожего нет.", plan
|
||
lines = ["**Похоже на " + str(film.get("title")) + "**", ""]
|
||
for s in (data.get("similar") or [])[:8]:
|
||
lines.append("• " + str(s.get("title")) + " — общих: " + str(s.get("shared")))
|
||
return "\n".join(lines), plan
|
||
|
||
if intent == "compare":
|
||
targets = plan["targets"]
|
||
if len(targets) < 2:
|
||
return "Для сравнения назовите два объекта в кавычках: «Дюна» и «Дюна».", plan
|
||
data, err = _get("/compare", {"book": targets[0], "film": targets[1]})
|
||
if err or not data:
|
||
return "Не нашёл пару для сравнения (нужны книга и фильм).", plan
|
||
b, f = data["book"]["title"], data["film"]["title"]
|
||
lines = ["**" + b + "** и **" + f + "**", ""]
|
||
lines.append("• Связаны экранизацией: " + ("да" if data.get("linked") else "нет"))
|
||
if data.get("common_genres"):
|
||
lines.append("• Общие жанры: " + ", ".join(data["common_genres"]))
|
||
if data.get("only_book_genres"):
|
||
lines.append("• Только в книге: " + ", ".join(data["only_book_genres"]))
|
||
if data.get("only_film_genres"):
|
||
lines.append("• Только в фильме: " + ", ".join(data["only_film_genres"]))
|
||
if data.get("authors"):
|
||
lines.append("• Автор: " + ", ".join(data["authors"]))
|
||
return "\n".join(lines), plan
|
||
|
||
return "Не понял запрос.", plan
|