Files
buryan-infra/ops/bots/hub/agent.py
buryan-agent 893a66a4e8 Сериалы в графе: жанры, сети, эпохи, похожесть и экранизации
Добавлены 5 сериалов через Sonarr (The Expanse, Dark, Foundation, Westworld,
Severance) — метаданные без скачивания. Новый вид карточки «сеть» (Netflix,
HBO, Apple TV, Prime Video).

Связи: сериал → жанр, сериал → сеть, сериал → эпоха, сериал ↔ сериал
«похож», книга ↔ сериал «экранизация» (Foundation), серия книг ↔ сериал
«общая вселенная». Итог: 449 карточек, 493 связи.

Подбор и Агент понимают сериалы: «посмотреть сериалы», «агент найди сериалы
про будущее».

Ловушки: Sonarr хранит год в названии (Foundation (2021) → карточка
Foundation (2021) (2021), связь с книгой не строилась); поиск по названию
даёт не тот сериал — нужен tvdb:<id>; api.sonarr.tv недоступен, поэтому
состава съёмочной группы у сериалов нет; «посмотреть сериалы» ломалось
из-за порядка вырезания слов.
2026-10-20 12:08:28 +03:00

336 lines
13 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Агент по графу: понимает фразу, строит план и выполняет запросы.
Работает без 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": [],
"kind": "сериал" if "сериал" in text.lower() else "фильм"}
# интент
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, "kind": plan.get("kind") or "фильм"}
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