Files
buryan-infra/ops/media/core.py
T
buryan-agent b9e1bf26b8 Страница токена Яндекса и музыкальные инструменты
GET /yandex.html — получение токена в один клик: кнопка ведёт на oauth.yandex.ru
с клиентом Яндекс Музыки, токен ловится из адреса, сохраняется через
POST /yandex/save в /root/.yandex-token (600) и сразу проверяется.
GET /yandex/status — состояние и наличие Плюса.

Установлены: beets 2.14.1 (venv), yt-dlp, mutagen, musicbrainzngs,
ffmpeg 7.1.5, fpcalc. Системный pip не подошёл из-за externally-managed —
пакеты в /opt/music-tools/venv, обёртка /usr/local/bin/beet.
2026-10-20 13:23:53 +03:00

1924 lines
82 KiB
Python
Raw 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.
"""Buryan Hub Core: шина событий и граф сущностей.
Один процесс, три задачи:
1) принимать события от сервисов и складывать в общую базу;
2) хранить карточки сущностей и связи между ними;
3) публиковать значимое в Matrix (личка владельцу).
Запуск: python3 core.py (HTTP на порту 9120)
"""
import json
import os
import threading
import time
import urllib.request
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import psycopg2
import psycopg2.extras
DSN = os.environ.get("CORE_DSN", "dbname=hub_core user=hub_core password=hub_core host=127.0.0.1")
PORT = int(os.environ.get("CORE_PORT", "9120"))
MATRIX_HS = os.environ.get("MATRIX_HS", "https://matrix.buryans.ru")
NOTIFY_TOKEN = os.environ.get("NOTIFY_TOKEN", "")
NOTIFY_ROOM = os.environ.get("NOTIFY_ROOM", "")
# какие события стоит показывать человеку сразу
LOUD = {
"media.imported", "media.requested", "media.failed",
"backup.done", "backup.failed", "service.down", "service.up",
"monitor.down", "monitor.up", "camera.detection",
"photo.imported", "book.added", "document.added",
}
def db():
con = psycopg2.connect(DSN, connect_timeout=10)
con.autocommit = True
return con
def ensure_schema():
sql = open(os.path.join(os.path.dirname(__file__), "schema.sql"), encoding="utf-8").read()
with db() as con, con.cursor() as cur:
cur.execute(sql)
ROUTES_FILE = "/etc/hub-core/routes.json"
_ROUTES = None
def load_routes():
"""Куда какое событие отправлять: тип → бот."""
global _ROUTES
if _ROUTES is not None:
return _ROUTES
try:
_ROUTES = json.load(open(ROUTES_FILE, encoding="utf-8"))
except Exception:
_ROUTES = {}
return _ROUTES
def route_for(etype):
"""Выбрать получателя по типу события."""
routes = load_routes()
for prefix in sorted(routes, key=len, reverse=True):
if etype.startswith(prefix):
return routes[prefix]
return {"token": NOTIFY_TOKEN, "room": NOTIFY_ROOM}
def publish(text, etype=""):
"""Короткое уведомление в личку владельцу."""
target = route_for(etype) if etype else {"token": NOTIFY_TOKEN, "room": NOTIFY_ROOM}
token, room = target.get("token") or NOTIFY_TOKEN, target.get("room") or NOTIFY_ROOM
if not (token and room):
return
txn = int(datetime.now().timestamp() * 1000)
import urllib.parse
rid = urllib.parse.quote(room, safe="")
body = json.dumps({"msgtype": "m.text", "body": text,
"format": "org.matrix.custom.html",
"formatted_body": text.replace("\n", "<br>")}).encode()
req = urllib.request.Request(
f"{MATRIX_HS}/_matrix/client/v3/rooms/{rid}/send/m.room.message/{txn}",
data=body, method="PUT",
headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"})
try:
urllib.request.urlopen(req, timeout=10)
except Exception:
pass
def human_event(ev):
e = ev.get("entity") or {}
title = e.get("title") or e.get("key") or "объект"
t = ev.get("type", "")
icons = {"media.imported": "🎬", "media.requested": "🕓", "media.failed": "⚠️",
"backup.done": "💾", "backup.failed": "⚠️",
"service.down": "🔴", "service.up": "✅",
"photo.imported": "📷", "book.added": "📚", "document.added": "📄"}
icon = icons.get(t, "•")
src = ev.get("source", "?")
extra = ev.get("payload") or {}
line = f"{icon} **{title}** — {t} ({src})"
if extra.get("detail"):
line += f"\n{extra['detail']}"
return line
def stem_ru(text):
"""Грубая основа русского слова: «Дюну» → «дюн»."""
t = (text or "").lower().strip()
for suf in ("ами", "ями", "ого", "его", "ому", "ему", "ыми", "ими",
"ая", "яя", "ое", "ее", "ые", "ие", "ой", "ый", "ий",
"ах", "ях", "ам", "ям", "ом", "ем", "ов", "ев", "ии",
"у", "ю", "а", "я", "ы", "и", "е", "о", "ь"):
if len(t) >= len(suf) + 3 and t.endswith(suf):
return t[:-len(suf)]
return t
def do_search(q, limit=20):
"""Поиск по карточкам: название и внешние ключи."""
like = f"%{q.strip().lower()}%"
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select id, kind, title, status, external_ids, updated_at
from entities where search_text like %s
order by updated_at desc limit %s""", (like, limit))
items = [dict(r) for r in cur.fetchall()]
if not items:
stem = stem_ru(q)
if stem and len(stem) >= 3:
cur.execute("""select id, kind, title, status from entities
where search_text like %s order by length(title) limit %s""",
(f"%{stem}%", limit))
items = [dict(r) for r in cur.fetchall()]
con.close()
return {"query": q, "count": len(items), "items": items}
def do_entity(eid):
"""Карточка: сама сущность, её связи и история событий."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("select * from entities where id = %s", (eid,))
row = cur.fetchone()
if not row:
con.close()
return None
card = dict(row)
cur.execute("""select e.id, e.kind, e.title, l.relation
from entity_links l
join entities e on e.id = case when l.from_id = %s then l.to_id else l.from_id end
where l.from_id = %s or l.to_id = %s""", (eid, eid, eid))
links = [dict(r) for r in cur.fetchall()]
cur.execute("""select at, source, type, payload from events
where entity_id = %s order by id desc limit 50""", (eid,))
history = [dict(r) for r in cur.fetchall()]
con.close()
return {"card": card, "links": links, "history": history}
DATA_DIR = os.environ.get("PROJECT_DATA", "/root/buryan-infra/data")
def _ensure_doc_table():
con = db()
with con.cursor() as cur:
cur.execute("""
create table if not exists data_docs (
id bigserial primary key,
collection text not null,
key text not null,
payload jsonb not null,
tags text[] not null default '{}',
created_at timestamptz not null default now(),
updated_at timestamptz not null default now(),
unique (collection, key)
)""")
cur.execute("create index if not exists idx_docs_collection on data_docs (collection)")
con.close()
def do_data_put(collection, data):
"""Сохранить документ: {key, payload, tags}."""
_ensure_doc_table()
key = str(data.get("key") or "").strip()
if not key:
return None, "нужен key"
payload = data.get("payload") or {}
tags = data.get("tags") or []
con = db()
cur = con.cursor()
cur.execute("""insert into data_docs (collection, key, payload, tags)
values (%s, %s, %s, %s)
on conflict (collection, key) do update
set payload = excluded.payload,
tags = excluded.tags,
updated_at = now()
returning id, updated_at""",
(collection, key, json.dumps(payload, ensure_ascii=False), tags))
row = cur.fetchone()
con.close()
return {"id": row[0], "updated_at": str(row[1])}, None
def do_data_list(collection, limit=100, tag=None):
_ensure_doc_table()
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
if tag:
cur.execute("""select id, key, payload, tags, updated_at from data_docs
where collection=%s and %s = any(tags)
order by updated_at desc limit %s""", (collection, tag, limit))
else:
cur.execute("""select id, key, payload, tags, updated_at from data_docs
where collection=%s order by updated_at desc limit %s""",
(collection, limit))
items = [dict(r) for r in cur.fetchall()]
con.close()
return {"collection": collection, "count": len(items), "items": items}, None
def _jsonable(obj):
if isinstance(obj, dict):
return {k: _jsonable(v) for k, v in obj.items()}
if isinstance(obj, list):
return [_jsonable(v) for v in obj]
return str(obj) if hasattr(obj, "isoformat") else obj
def do_export(collection, fmt="json", filename=None, limit=500):
"""Выгрузить коллекцию в папку проекта."""
data, err = do_data_list(collection, limit=limit)
if err:
return None, err
items = _jsonable(data["items"])
folder = os.path.join(DATA_DIR, collection)
os.makedirs(folder, exist_ok=True)
stamp = datetime.now().strftime("%Y-%m-%d")
if fmt == "md":
name = filename or f"{collection}-{stamp}.md"
lines = [f"# {collection}", "", f"записей: {len(items)}", ""]
for it in items:
lines.append(f"## {it.get('key')}")
lines.append(f"обновлено: {it.get('updated_at')}")
payload = it.get("payload") or {}
for k, v in payload.items():
lines.append(f"* **{k}**: {v}")
lines.append("")
open(os.path.join(folder, name), "w", encoding="utf-8").write("\n".join(lines))
else:
name = filename or f"{collection}-{stamp}.json"
with open(os.path.join(folder, name), "w", encoding="utf-8") as f:
json.dump({"collection": collection, "exported_at": str(datetime.now()),
"count": len(items), "items": items},
f, ensure_ascii=False, indent=1, default=str)
path = os.path.join(folder, name)
return {"path": path, "count": len(items), "format": fmt}, None
def do_services():
"""Источники событий: сколько, когда последнее."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select source, count(*) as total,
max(at) as last_at,
count(*) filter (where at > now() - interval '24 hours') as last24
from events group by source order by total desc""")
rows = [dict(r) for r in cur.fetchall()]
con.close()
return {"count": len(rows), "items": rows}
def do_service_history(source, limit=50):
"""История по одному сервису."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select e.id, e.at, e.type, e.entity->>'title' as title, e.payload
from events e where e.source = %s order by e.id desc limit %s""",
(source, limit))
rows = [dict(r) for r in cur.fetchall()]
con.close()
return {"source": source, "count": len(rows), "items": rows}
def do_metrics():
"""Метрики в формате Prometheus."""
lines = []
con = db()
cur = con.cursor()
cur.execute("select source, count(*) from events group by source")
lines.append("# HELP hub_events_total События по источникам")
lines.append("# TYPE hub_events_total counter")
for src, n in cur.fetchall():
lines.append(f'hub_events_total{{source="{src}"}} {n}')
cur.execute("select count(*) from events where at > now() - interval '24 hours'")
lines.append("# HELP hub_events_24h События за сутки")
lines.append("# TYPE hub_events_24h gauge")
lines.append(f"hub_events_24h {cur.fetchone()[0]}")
cur.execute("select kind, count(*) from entities group by kind")
lines.append("# HELP hub_entities Карточки по видам")
lines.append("# TYPE hub_entities gauge")
for kind, n in cur.fetchall():
safe = (kind or "unknown").replace('"', "")
lines.append(f'hub_entities{{kind="{safe}"}} {n}')
cur.execute("select count(*) from problems where resolved_at is null")
lines.append("# HELP hub_problems_open Открытые проблемы")
lines.append("# TYPE hub_problems_open gauge")
lines.append(f"hub_problems_open {cur.fetchone()[0]}")
cur.execute("select kind, status, count(*) from actions group by kind, status")
lines.append("# HELP hub_actions Действия автоматики")
lines.append("# TYPE hub_actions counter")
for kind, status, n in cur.fetchall():
lines.append(f'hub_actions{{kind="{kind}",status="{status}"}} {n}')
cur.execute("select count(*) from entity_links")
lines.append("# HELP hub_links Связи между карточками")
lines.append("# TYPE hub_links gauge")
lines.append(f"hub_links {cur.fetchone()[0]}")
con.close()
# хранилища
try:
import subprocess
out = subprocess.run(["pvesm", "status"], capture_output=True, text=True, timeout=15)
lines.append("# HELP hub_storage_percent Заполненность хранилищ")
lines.append("# TYPE hub_storage_percent gauge")
for line in out.stdout.splitlines()[1:]:
parts = line.split()
if len(parts) >= 7 and parts[6].endswith("%"):
try:
lines.append(f'hub_storage_percent{{name="{parts[0]}",type="{parts[1]}"}} '
f'{float(parts[6].rstrip("%"))}')
except ValueError:
pass
except Exception:
pass
# возраст бэкапов
try:
import time
lines.append("# HELP hub_backup_age_hours Возраст последнего бэкапа")
lines.append("# TYPE hub_backup_age_hours gauge")
checks = {
"postgresql": "/var/log/hub-pg-verify.log",
"matrix": "/var/log/hub-matrix-backup.log",
"bots": "/var/log/hub-bots-verify.log",
"offsite": "/var/log/hub-offsite-verify.log",
"core": "/mnt/backups/hub-core",
}
for name, path in checks.items():
try:
if os.path.isdir(path):
files = [os.path.join(path, f) for f in os.listdir(path)]
mtime = max(os.path.getmtime(f) for f in files) if files else 0
else:
mtime = os.path.getmtime(path)
lines.append(f'hub_backup_age_hours{{name="{name}"}} '
f'{round((time.time() - mtime) / 3600, 1)}')
except OSError:
pass
except Exception:
pass
return "\n".join(lines) + "\n"
JOBS = {
"коннекторы": ("/var/log/hub-connectors.log", 1),
"сверка": ("/var/log/hub-reconcile.log", 30),
"связка карточек": ("/var/log/hub-linker.log", 30),
"дайджест": ("/var/log/hub-digest.log", 30),
"инвентаризация": ("/var/log/hub-inventory.log", 30),
"каталог": ("/var/log/hub-catalog.log", 30),
"экспорт": ("/var/log/hub-export.log", 30),
"бэкап базы": ("/var/log/hub-backup.log", 30),
"проверка бэкапа PG": ("/var/log/hub-pg-verify.log", 30),
"проверка бэкапа ботов": ("/var/log/hub-bots-verify.log", 30),
"бэкап Matrix": ("/var/log/hub-matrix-backup.log", 30),
"офсайт": ("/var/log/hub-offsite-verify.log", 24 * 8),
"просмотр": ("/var/log/hub-resume.log", 30),
"недельный отчёт": ("/var/log/hub-weekly-core.log", 24 * 8),
"аудит доступов": ("/var/log/hub-identity.log", 24 * 8),
"восстановление CT": ("/var/log/hub-lxc-verify.log", 24 * 8),
}
def jobs_status():
"""Состояние задач: когда последний раз отработали."""
now = time.time()
rows = []
for name, (path, limit_h) in JOBS.items():
try:
age_h = (now - os.path.getmtime(path)) / 3600
state = "ок" if age_h <= limit_h else "просрочено"
except OSError:
age_h, state = None, "не запускалась"
rows.append((name, age_h, limit_h, state))
return rows
def do_links(limit=200):
"""Связи контента: список и сводка по типам."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("select relation, count(*) as n from entity_links group by relation order by n desc")
summary = {r["relation"]: r["n"] for r in cur.fetchall()}
cur.execute("""select a.title as from_title, a.kind as from_kind,
b.title as to_title, b.kind as to_kind, l.relation
from entity_links l
join entities a on a.id = l.from_id
join entities b on b.id = l.to_id
order by l.relation, a.title limit %s""", (limit,))
items = [dict(r) for r in cur.fetchall()]
con.close()
return {"total": sum(summary.values()), "by_relation": summary, "items": items}
def do_entities(kind=None, limit=200, q=None):
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
sql = "select id, kind, title, status, updated_at from entities where 1=1"
args = []
if kind:
sql += " and kind = %s"
args.append(kind)
if q:
sql += " and search_text like %s"
args.append(f"%{q.lower()}%")
sql += " order by updated_at desc limit %s"
args.append(limit)
cur.execute(sql, args)
items = [dict(r) for r in cur.fetchall()]
con.close()
return {"count": len(items), "items": items}
def do_similar(eid, limit=10):
"""Похожие карточки: общие темы, жанры и прямые связи «похож»."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("select id, kind, title from entities where id = %s", (eid,))
root = cur.fetchone()
if not root:
con.close()
return None
# два шага: фильм → темы/жанры → другие фильмы с теми же темами
cur.execute("""
with mine as (
select l.to_id as node
from entity_links l
where l.from_id = %s and l.relation in ('тема', 'жанр')
union
select l.from_id as node
from entity_links l
where l.to_id = %s and l.relation in ('тема', 'жанр')
),
hits as (
select l.from_id as film_id, count(*) as shared
from entity_links l
where l.to_id in (select node from mine)
and l.relation in ('тема', 'жанр')
and l.from_id <> %s
group by l.from_id
)
select e.id, e.kind, e.title, h.shared
from hits h join entities e on e.id = h.film_id
where e.kind in ('фильм', 'книга')
order by h.shared desc, e.title
limit %s
""", (eid, eid, eid, limit))
items = [dict(r) for r in cur.fetchall()]
# прямые связи «похож»
cur.execute("""
select e.id, e.kind, e.title
from entity_links l
join entities e on e.id = case when l.from_id = %s then l.to_id else l.from_id end
where (l.from_id = %s or l.to_id = %s) and l.relation = 'похож'
""", (eid, eid, eid))
direct = [dict(r) for r in cur.fetchall()]
con.close()
return {"root": dict(root), "similar": items, "direct": direct}
def do_person(query, limit=20):
"""Персона и её фильмы."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select id, kind, title from entities
where kind in ('актёр','режиссёр','композитор') and search_text like %s
order by length(title) limit 1""", (f"%{query.lower()}%",))
person = cur.fetchone()
if not person:
con.close()
return None
cur.execute("""
select e.title, e.kind, l.relation
from entity_links l
join entities e on e.id = case when l.from_id = %s then l.to_id else l.from_id end
where (l.from_id = %s or l.to_id = %s)
order by e.title
""", (person["id"], person["id"], person["id"]))
films = [dict(r) for r in cur.fetchall()]
con.close()
return {"person": dict(person), "films": films, "count": len(films)}
def do_pick2(genre=None, theme=None, decade=None, kind="фильм", person=None,
rating=None, limit=10):
"""Подбор из медиатеки с любыми фильтрами графа."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
conds = ["e.kind = %s"]
args = [kind]
def add_relation(rel, value):
conds.append("""exists (
select 1 from entity_links li
join entities ni on ni.id = li.to_id
where li.from_id = e.id and li.relation = %s
and ni.search_text like %s)""")
args.extend([rel, f"%{value.lower()}%"])
if genre:
add_relation("жанр", genre)
if theme:
add_relation("тема", theme)
if decade:
add_relation("снят в", decade)
if rating:
add_relation("оценка", rating)
if person:
conds.append("""exists (
select 1 from entity_links lp
join entities np on np.id = lp.to_id
where lp.from_id = e.id and np.kind in ('актёр','режиссёр','композитор')
and np.search_text like %s)""")
args.append(f"%{person.lower()}%")
sql = ("select e.id, e.title, e.kind, e.status from entities e where "
+ " and ".join(conds) + " order by e.title limit %s")
args.append(limit)
cur.execute(sql, args)
items = [dict(r) for r in cur.fetchall()]
for it in items:
cur.execute("""select n.title from entity_links l join entities n on n.id = l.to_id
where l.from_id = %s and l.relation = 'оценка' limit 1""", (it["id"],))
row = cur.fetchone()
it["rating"] = row["title"] if row else None
cur.execute("""select string_agg(n.title, ', ') from entity_links l
join entities n on n.id = l.to_id
where l.from_id = %s and l.relation = 'жанр'""", (it["id"],))
it["genres"] = cur.fetchone()["string_agg"]
con.close()
return {"count": len(items), "items": items}
def do_compare(book_query, film_query):
"""Сравнение книги и фильма: что общего."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
def find(kind, q):
cur.execute("""select id, kind, title from entities
where kind = %s and search_text like %s
order by length(title) limit 1""", (kind, f"%{q.lower()}%"))
return cur.fetchone()
book = find("книга", book_query)
film = find("фильм", film_query)
if not book or not film:
con.close()
return None
def related(eid, rel):
cur.execute("""select n.title from entity_links l join entities n on n.id = l.to_id
where l.from_id = %s and l.relation = %s""", (eid, rel))
return {r["title"] for r in cur.fetchall()}
b_genres, b_themes = related(book["id"], "жанр"), related(book["id"], "тема")
f_genres, f_themes = related(film["id"], "жанр"), related(film["id"], "тема")
b_authors = related(book["id"], "написал")
cur.execute("""select 1 from entity_links l
where l.from_id = %s and l.to_id = %s and l.relation = 'экранизация'""",
(book["id"], film["id"]))
linked = cur.fetchone() is not None
con.close()
return {
"book": dict(book), "film": dict(film), "linked": linked,
"common_genres": sorted(b_genres & f_genres),
"only_book_genres": sorted(b_genres - f_genres),
"only_film_genres": sorted(f_genres - b_genres),
"common_themes": sorted(b_themes & f_themes),
"authors": sorted(b_authors),
}
def do_timeline(node_query, kind="тема"):
"""Тема или жанр по десятилетиям."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select id, title from entities
where kind = %s and search_text like %s
order by length(title) limit 1""", (kind, f"%{node_query.lower()}%"))
node = cur.fetchone()
if not node:
con.close()
return None
cur.execute("""
with items as (
select case when l.from_id = %s then l.to_id else l.from_id end as item_id
from entity_links l
where (l.from_id = %s or l.to_id = %s) and l.relation = %s
)
select d.title as decade, count(*) as n,
string_agg(e.title, ',' order by e.title) as items
from items i
join entity_links l
on (l.from_id = i.item_id and l.relation = 'снят в')
join entities d on d.id = l.to_id
join entities e on e.id = i.item_id
group by d.title
order by d.title
""", (node["id"], node["id"], node["id"], kind))
rows = [dict(r) for r in cur.fetchall()]
con.close()
return {"node": dict(node), "decades": rows}
def do_cross(limit=50):
"""Книги с экранизацией и авторы, чьи книги экранизированы."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""
select b.title as book, f.title as film
from entity_links l
join entities b on b.id = l.from_id and b.kind = 'книга'
join entities f on f.id = l.to_id and f.kind = 'фильм'
where l.relation = 'экранизация'
order by b.title limit %s
""", (limit,))
books_with_film = [dict(r) for r in cur.fetchall()]
cur.execute("""
select a.title as author, f.title as film
from entity_links l
join entities a on a.id = l.from_id and a.kind = 'автор'
join entities f on f.id = l.to_id and f.kind = 'фильм'
where l.relation = 'экранирован'
order by a.title limit %s
""", (limit,))
authors_screened = [dict(r) for r in cur.fetchall()]
con.close()
return {"books_with_film": books_with_film, "authors_screened": authors_screened}
def do_top_persons(kind="актёр", limit=10):
"""Персоны с наибольшим числом фильмов."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""
select e.id, e.title, count(*) as films
from entity_links l
join entities e on e.id = case when l.from_id = e.id then e.id else l.to_id end
where e.kind = %s and l.relation in ('снялся','снял','музыка')
group by e.id, e.title
order by films desc, e.title
limit %s
""", (kind, limit))
items = [dict(r) for r in cur.fetchall()]
con.close()
return {"kind": kind, "items": items}
def do_graph_stats():
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("select kind, count(*) as n from entities group by kind order by n desc")
cards = [dict(r) for r in cur.fetchall()]
cur.execute("select relation, count(*) as n from entity_links group by relation order by n desc")
relations = [dict(r) for r in cur.fetchall()]
con.close()
return {"cards": cards, "relations": relations,
"total_cards": sum(c["n"] for c in cards),
"total_links": sum(r["n"] for r in relations)}
def do_graph_json(limit=150):
"""Узлы и рёбра для визуализации."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""
select e.id, e.kind, e.title, count(l.id) as degree
from entities e left join entity_links l on l.from_id = e.id or l.to_id = e.id
group by e.id, e.kind, e.title
order by degree desc limit %s
""", (limit,))
nodes = [dict(r) for r in cur.fetchall()]
ids = [n["id"] for n in nodes]
edges = []
if ids:
cur.execute("""
select l.from_id as source, l.to_id as target, l.relation
from entity_links l
where l.from_id = any(%s) and l.to_id = any(%s)
limit 500
""", (ids, ids))
edges = [dict(r) for r in cur.fetchall()]
con.close()
return {"nodes": nodes, "edges": edges}
MOODS = {
"мрачн": ["dystopia", "noir", "dark", "survival", "horror", "thriller", "drama"],
"мрач": ["dystopia", "noir", "dark", "survival", "horror", "thriller", "drama"],
"тяжёл": ["drama", "war", "thriller", "mystery"],
"лёгк": ["comedy", "family", "adventure", "romance"],
"легк": ["comedy", "family", "adventure", "romance"],
"добр": ["family", "friendship", "adventure", "comedy"],
"умн": ["artificial intelligence", "based on novel", "mystery", "science fiction"],
"эпичн": ["epic", "space opera", "adventure", "science fiction", "war"],
"страшн": ["horror", "monster", "thriller", "mystery"],
"смешн": ["comedy"],
"романтич": ["romance", "drama"],
"детектив": ["detective", "mystery", "crime", "thriller"],
}
def do_mood(mood, limit=10):
"""Подбор по настроению: темы и жанры из словаря MOODS."""
low = (mood or "").lower()
hints = []
for key, words in MOODS.items():
if key in low:
hints = words
break
if not hints:
return {"mood": mood, "count": 0, "items": [], "hints": []}
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
like = ["%" + h.lower() + "%" for h in hints]
cur.execute("""
select e.id, e.title, count(distinct n.id) as score
from entities e
join entity_links l on l.from_id = e.id
join entities n on n.id = l.to_id
where e.kind = 'фильм' and n.search_text like any(%s)
and l.relation in ('тема', 'жанр')
group by e.id, e.title
order by score desc, e.title
limit %s
""", (like, limit))
items = [dict(r) for r in cur.fetchall()]
for it in items:
cur.execute("""select n.title from entity_links l join entities n on n.id = l.to_id
where l.from_id = %s and l.relation = 'оценка' limit 1""", (it["id"],))
row = cur.fetchone()
it["rating"] = row["title"] if row else None
con.close()
return {"mood": mood, "count": len(items), "items": items, "hints": hints}
def do_candidates(limit=20):
"""Кандидаты из рекомендаций: чего нет в медиатеке."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select e.id, e.title, e.key, e.status,
count(l.id) as votes
from entities e
left join entity_links l on l.to_id = e.id and l.relation = 'рекомендует'
where e.kind = 'кандидат'
group by e.id, e.title, e.key, e.status
order by votes desc, e.title
limit %s""", (limit,))
items = [dict(r) for r in cur.fetchall()]
for it in items:
it["tmdb"] = (it.get("key") or "").replace("candidate:", "")
con.close()
return {"count": len(items), "items": items}
def do_coworkers(query, limit=12):
"""С кем вместе снимался: партнёры по фильмам."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select id, title from entities
where kind in ('актёр','режиссёр','композитор') and search_text like %s
order by length(title) limit 1""", (f"%{query.lower()}%",))
person = cur.fetchone()
if not person:
con.close()
return None
cur.execute("""
with films as (
select case when l.from_id = %s then l.to_id else l.from_id end as fid
from entity_links l
where (l.from_id = %s or l.to_id = %s)
)
select p.id, p.title, p.kind, count(*) as together,
string_agg(f.title, ', ' order by f.title) as films
from films x
join entity_links l on (l.from_id = x.fid)
join entities p on p.id = l.to_id and p.kind in ('актёр','режиссёр','композитор')
join entities f on f.id = x.fid
where l.relation in ('снялся','снял','музыка') and p.id <> %s
group by p.id, p.title, p.kind
order by together desc, p.title
limit %s
""", (person["id"], person["id"], person["id"], person["id"], limit))
partners = [dict(r) for r in cur.fetchall()]
con.close()
return {"person": dict(person), "partners": partners}
def do_suggest(q, limit=8):
"""Подсказки по началу названия: для автодополнения."""
if not q or len(q.strip()) < 2:
return {"query": q, "items": []}
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select id, kind, title from entities
where search_text like %s
order by length(title) limit %s""", (f"%{q.strip().lower()}%", limit))
items = [dict(r) for r in cur.fetchall()]
con.close()
return {"query": q, "items": items}
def snapshot_graph(day=None):
"""Снимок размеров графа за день."""
from datetime import date
day = day or date.today().isoformat()
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""create table if not exists graph_history (
day date primary key, cards integer, links integer, persons integer)""")
cur.execute("select count(*) as n from entities")
cards = cur.fetchone()["n"]
cur.execute("select count(*) as n from entity_links")
links = cur.fetchone()["n"]
cur.execute("select count(*) as n from entities where kind in ('актёр','режиссёр','композитор')")
persons = cur.fetchone()["n"]
cur.execute("""insert into graph_history (day, cards, links, persons) values (%s, %s, %s, %s)
on conflict (day) do update set cards = %s, links = %s, persons = %s""",
(day, cards, links, persons, cards, links, persons))
con.commit()
con.close()
return {"day": str(day), "cards": cards, "links": links, "persons": persons}
def do_history(days=30):
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select day, cards, links, persons from graph_history
order by day desc limit %s""", (days,))
rows = [dict(r) for r in cur.fetchall()]
con.close()
rows.reverse()
growth = None
if len(rows) >= 2:
growth = {"cards": rows[-1]["cards"] - rows[0]["cards"],
"links": rows[-1]["links"] - rows[0]["links"]}
return {"items": rows, "growth": growth}
def do_seasons(query):
"""Сериал и его сезоны с числом эпизодов."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select id, title from entities
where kind = 'сериал' and search_text like %s
order by length(title) limit 1""", (f"%{query.lower()}%",))
series = cur.fetchone()
if not series:
con.close()
return None
cur.execute("""select b.title, b.status, l.relation
from entity_links l
join entities b on b.id = l.to_id
where l.from_id = %s and b.kind = 'сезон'
order by b.title""", (series["id"],))
seasons = [dict(r) for r in cur.fetchall()]
con.close()
return {"series": dict(series), "seasons": seasons, "count": len(seasons)}
def do_watchlist(mark=None, note=None):
"""Список «хочу посмотреть»: карточки со статусом."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
if mark:
cur.execute("""select id, kind, title from entities
where search_text like %s order by length(title) limit 1""",
(f"%{mark.lower()}%",))
row = cur.fetchone()
if not row:
con.close()
return None
cur.execute("""update entities set status = %s, updated_at = now() where id = %s""",
("хочу посмотреть", row["id"]))
con.commit()
con.close()
return {"marked": dict(row), "status": "хочу посмотреть"}
cur.execute("""select id, kind, title, updated_at from entities
where status in ('хочу посмотреть', 'смотрю')
order by updated_at desc limit 50""")
items = [dict(r) for r in cur.fetchall()]
con.close()
return {"count": len(items), "items": items}
def do_rate(title, score):
"""Личная оценка карточки (1–10)."""
try:
score = max(1, min(10, int(score)))
except (TypeError, ValueError):
return None
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""create table if not exists user_ratings (
entity_id integer, score integer, updated_at timestamptz default now(),
primary key (entity_id))""")
cur.execute("""select id, kind, title from entities
where search_text like %s order by length(title) limit 1""",
(f"%{title.lower()}%",))
row = cur.fetchone()
if not row:
con.close()
return None
cur.execute("""insert into user_ratings (entity_id, score, updated_at) values (%s, %s, now())
on conflict (entity_id) do update set score = %s, updated_at = now()""",
(row["id"], score, score))
con.commit()
con.close()
return {"rated": dict(row), "score": score}
def do_rated(limit=30):
"""Мои оценки: от высокой к низкой."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cur.execute("""select e.id, e.kind, e.title, r.score
from user_ratings r join entities e on e.id = r.entity_id
order by r.score desc, e.title limit %s""", (limit,))
items = [dict(r) for r in cur.fetchall()]
con.close()
avg = round(sum(i["score"] for i in items) / len(items), 2) if items else None
return {"count": len(items), "average": avg, "items": items}
def do_for_me(limit=10):
"""Рекомендации на основе высоких личных оценок."""
con = db()
cur = con.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
# что я оценил высоко
cur.execute("""select e.id, e.title, r.score
from user_ratings r join entities e on e.id = r.entity_id
where r.score >= 8 order by r.score desc limit 10""")
liked = cur.fetchall()
if not liked:
con.close()
return {"liked": [], "items": [], "reason": "нет высоких оценок"}
liked_ids = [r["id"] for r in liked]
rated_ids = set()
cur.execute("select entity_id from user_ratings")
for r in cur.fetchall():
rated_ids.add(r["entity_id"])
# темы и жанры любимых
cur.execute("""select distinct l.to_id as node
from entity_links l
where l.from_id = any(%s) and l.relation in ('тема','жанр')""", (liked_ids,))
nodes = [r["node"] for r in cur.fetchall()]
items = []
if nodes:
cur.execute("""
select e.id, e.title, e.kind, count(*) as score
from entity_links l
join entities e on e.id = l.from_id
where l.to_id = any(%s) and l.relation in ('тема','жанр')
and e.kind in ('фильм','сериал')
group by e.id, e.title, e.kind
order by score desc, e.title
limit %s
""", (nodes, limit * 3))
for r in cur.fetchall():
if r["id"] not in rated_ids and r["id"] not in liked_ids:
items.append(dict(r))
# добить кандидатами, которых нет в медиатеке
if len(items) < limit:
cur.execute("""select e.id, e.title, count(l.id) as votes
from entities e
left join entity_links l on l.to_id = e.id and l.relation = 'рекомендует'
where e.kind = 'кандидат'
group by e.id, e.title
order by votes desc limit %s""", (limit,))
for r in cur.fetchall():
cand = {"id": r["id"], "title": r["title"], "kind": "кандидат",
"score": r["votes"]}
if not any(i["id"] == cand["id"] for i in items):
items.append(cand)
con.close()
return {"liked": [dict(r) for r in liked], "items": items[:limit],
"reason": "по темам и жанрам любимых"}
def yandex_status():
"""Есть ли токен Яндекс Музыки и что он даёт."""
import os as _os
import json as _json
import urllib.request as _rq
path = "/root/.yandex-token"
if not _os.path.exists(path):
return {"has_token": False}
tok = open(path, encoding="utf-8").read().strip()
req = _rq.Request("https://api.music.yandex.net/account/status",
headers={"Authorization": "OAuth " + tok})
try:
with _rq.urlopen(req, timeout=15) as r:
d = _json.loads(r.read() or b"{}")
res = d.get("result") or {}
acc = res.get("account") or {}
return {"has_token": True,
"login": acc.get("displayName") or acc.get("login"),
"uid": acc.get("uid"),
"plus": bool((res.get("plus") or {}).get("hasPlus"))}
except Exception as e:
return {"has_token": True, "error": str(e)[:120]}
def yandex_save(tok):
"""Сохраняет токен и сразу проверяет его."""
import os as _os
tok = (tok or "").strip()
if not tok or len(tok) < 20:
return {"error": "токен слишком короткий"}
path = "/root/.yandex-token"
with open(path, "w", encoding="utf-8") as f:
f.write(tok)
_os.chmod(path, 0o600)
return yandex_status()
def render_panel():
"""HTML-страница: состояние системы в одном месте."""
try:
con = db()
cur = con.cursor()
cur.execute("select count(*) from entities")
entities = cur.fetchone()[0]
cur.execute("select count(*) from events")
events = cur.fetchone()[0]
cur.execute("select count(*) from events where at > now() - interval '24 hours'")
events24 = cur.fetchone()[0]
cur.execute("select count(*) from problems where resolved_at is null")
open_problems = cur.fetchone()[0]
cur.execute("""select check_name, detail, at from problems
where resolved_at is null order by at desc limit 10""")
problems = cur.fetchall()
cur.execute("""select at, source, type, entity->>'title'
from events order by id desc limit 25""")
recent = cur.fetchall()
cur.execute("""select source, count(*) as total,
count(*) filter (where at > now() - interval '24 hours') as last24,
max(at) as last_at
from events group by source order by total desc""")
by_source = cur.fetchall()
try:
cur.execute("""select payload from data_docs where collection='inventory'
order by updated_at desc limit 1""")
invrow = cur.fetchone()
inventory = invrow[0] if invrow else None
except Exception:
inventory = None
try:
cur.execute("""select payload from data_docs where collection='identity'
order by updated_at desc limit 1""")
idrow = cur.fetchone()
identity = idrow[0] if idrow else None
except Exception:
identity = None
jobs = jobs_status()
try:
gstats = do_graph_stats()
except Exception:
gstats = {"cards": [], "relations": [], "total_cards": 0, "total_links": 0}
try:
tl = do_timeline("science fiction", "жанр")
except Exception:
tl = None
try:
hist = do_history(30)
growth = hist.get("growth")
except Exception:
growth = None
try:
personal = {"watch": do_watchlist().get("items") or [],
"rated": do_rated(5).get("items") or [],
"forme": do_for_me(5).get("items") or []}
except Exception:
personal = {"watch": [], "rated": [], "forme": []}
try:
cross = do_cross(limit=10)
except Exception:
cross = {"books_with_film": [], "authors_screened": []}
try:
top_genres = do_pick(limit=100) if False else []
except Exception:
top_genres = []
cur.execute("select count(*) from entity_links")
links = cur.fetchone()[0]
cur.execute("""select at, kind, target, detail, status from actions
order by id desc limit 10""")
actions = cur.fetchall()
con.close()
err = None
except Exception as e:
entities = events = events24 = open_problems = 0
problems, recent, by_source, actions, links, inventory, identity = [], [], [], [], 0, None, None
jobs = []
gstats = {"cards": [], "relations": [], "total_cards": 0, "total_links": 0}
cross = {"books_with_film": [], "authors_screened": []}
err = str(e)[:200]
def esc(x):
return (str(x) if x is not None else "—").replace("&", "&amp;").replace("<", "&lt;")
rows = "".join(
f"<tr><td>{esc(at.strftime('%d.%m %H:%M'))}</td><td>{esc(src)}</td>"
f"<td>{esc(typ)}</td><td>{esc(title)}</td></tr>"
for at, src, typ, title in recent) or "<tr><td colspan=4>событий пока нет</td></tr>"
media_kinds = {"фильм", "книга", "жанр", "тема", "актёр", "режиссёр",
"композитор", "студия", "коллекция", "серия книг", "автор",
"эпоха", "кандидат", "оценка", "язык", "рейтинг"}
g_cards = sum(c["n"] for c in gstats.get("cards") or [] if c["kind"] in media_kinds)
g_links = gstats.get("total_links") or 0
max_rel = max([r["n"] for r in gstats.get("relations") or []] or [1])
g_rel_rows = "".join(
f"<tr><td>{esc(r['relation'])}</td><td>{r['n']}</td>"
f"<td><div style='background:#2d6cdf;height:8px;width:{int(180 * r['n'] / max_rel)}px;border-radius:4px'></div></td></tr>"
for r in (gstats.get("relations") or [])[:12]) or "<tr><td colspan=3>пусто</td></tr>"
cross_rows = []
for b in (cross.get("books_with_film") or [])[:6]:
cross_rows.append(f"<tr><td>📖 {esc(b['book'])}</td><td>↔</td><td>🎬 {esc(b['film'])}</td></tr>")
for a in (cross.get("authors_screened") or [])[:6]:
cross_rows.append(f"<tr><td>✍️ {esc(a['author'])}</td><td>→</td><td>🎬 {esc(a['film'])}</td></tr>")
rows = []
for w in personal.get("watch") or []:
rows.append(f"<tr><td>🎯</td><td>{esc(w['title'])}</td><td>хочу посмотреть</td></tr>")
for r in personal.get("rated") or []:
rows.append(f"<tr><td>⭐</td><td>{esc(r['title'])}</td><td>{r['score']}/10</td></tr>")
for f in personal.get("forme") or []:
rows.append(f"<tr><td>💡</td><td>{esc(f['title'])}</td><td>{esc(str(f.get('kind') or ''))}</td></tr>")
g_personal = "".join(rows) or "<tr><td colspan=3>пока пусто: !хочу и !оценка</td></tr>"
g_timeline = "<div class='muted'>нет данных</div>"
if tl and tl.get("decades"):
mx = max(d["n"] for d in tl["decades"]) or 1
bars = []
for d in tl["decades"]:
w = int(220 * d["n"] / mx)
bars.append(
f"<div style='display:flex;align-items:center;gap:8px;margin:3px 0'>"
f"<span style='width:64px;color:#8fb4d9;font-size:12px'>{esc(d['decade'])}</span>"
f"<div style='background:#2d6cdf;height:14px;width:{w}px;border-radius:3px'></div>"
f"<span style='font-size:12px'>{d['n']}</span></div>")
g_timeline = "".join(bars)
g_growth = ""
if growth:
g_growth = (" · рост за период: карточек " + str(growth.get("cards")) +
", связей " + str(growth.get("links")))
g_cross_rows = "".join(cross_rows) or "<tr><td colspan=3>пока нет совпадений</td></tr>"
job_rows = "".join(
f"<tr><td>{esc(n)}</td><td>{(str(round(a, 1)) + ' ч') if a is not None else '—'}</td>"
f"<td>{lim} ч</td><td class=\"{'bad' if st != 'ок' else ''}\">{esc(st)}</td></tr>"
for n, a, lim, st in jobs) or "<tr><td colspan=4>нет данных</td></tr>"
identity_text = "аудит ещё не запускался"
if isinstance(identity, dict) and identity.get("table"):
identity_text = identity["table"]
inv_rows = ""
if isinstance(inventory, dict):
jf = inventory.get("jellyfin") or {}
nv = inventory.get("navidrome") or {}
cb = inventory.get("calibre") or {}
im = inventory.get("immich") or {}
pl = inventory.get("paperless") or {}
fr = inventory.get("frigate") or {}
inv_rows = (
f"<tr><td>Jellyfin</td><td>{jf.get('Movie')} фильмов, {jf.get('Series')} сериалов, "
f"{jf.get('Episode')} серий</td></tr>"
f"<tr><td>Navidrome</td><td>{nv.get('albums')} альбомов, {nv.get('tracks')} треков</td></tr>"
f"<tr><td>Calibre</td><td>{cb.get('books')} книг</td></tr>"
f"<tr><td>Immich</td><td>{im.get('assets')} снимков, {im.get('albums')} альбомов</td></tr>"
f"<tr><td>Paperless</td><td>{pl.get('documents')} документов</td></tr>"
f"<tr><td>Frigate</td><td>{fr.get('cameras')} камер</td></tr>")
if not inv_rows:
inv_rows = '<tr><td colspan=2>инвентаризация ещё не собиралась</td></tr>'
arows = "".join(
f"<tr><td>{esc(at.strftime('%d.%m %H:%M'))}</td><td>{esc(kind)}</td>"
f"<td>{esc(target)}</td><td>{esc(detail)}</td>"
f"<td class=\"{'bad' if st != 'done' else ''}\">{esc(st)}</td></tr>"
for at, kind, target, detail, st in actions) or "<tr><td colspan=5>действий не было</td></tr>"
prow = "".join(
f"<tr><td>{esc(name)}</td><td>{esc(detail)}</td></tr>"
for name, detail, _ in problems) or "<tr><td colspan=2>открытых проблем нет</td></tr>"
src_rows = "".join(
f"<tr><td>{esc(src)}</td><td>{total}</td><td>{last24}</td><td>{esc(str(last_at)[:16])}</td></tr>"
for src, total, last24, last_at in by_source) or "<tr><td colspan=4>событий пока нет</td></tr>"
return f"""<!doctype html><html lang="ru"><meta charset="utf-8"><meta http-equiv="refresh" content="60">
<title>Buryan Hub</title>
<style>
body{{font-family:system-ui,sans-serif;background:#101418;color:#d8e0e8;margin:0;padding:24px}}
h1{{font-size:20px;margin:0 0 4px}} h2{{font-size:15px;margin:28px 0 8px;color:#8fb4d9}}
.cards{{display:flex;gap:12px;flex-wrap:wrap;margin-top:16px}}
.card{{background:#182027;border-radius:10px;padding:14px 18px;min-width:120px}}
.card b{{display:block;font-size:24px}} .card span{{color:#7d8b99;font-size:12px}}
table{{width:100%;border-collapse:collapse;font-size:13px}}
td,th{{text-align:left;padding:6px 8px;border-bottom:1px solid #223}}
th{{color:#7d8b99;font-weight:500}}
.bad{{color:#ff8a80}} .muted{{color:#7d8b99;font-size:12px}}
</style>
<h1>Buryan Hub</h1>
<div class="muted">ядро событий и карточек · обновлено сейчас</div>
{'<p class="bad">Ошибка базы: ' + esc(err) + '</p>' if err else ''}
<div class="cards">
<div class="card"><b>{entities}</b><span>карточек</span></div>
<div class="card"><b>{events}</b><span>событий всего</span></div>
<div class="card"><b>{events24}</b><span>за 24 часа</span></div>
<div class="card"><b class="{'bad' if open_problems else ''}">{open_problems}</b><span>проблем</span></div>
<div class="card"><b>{links}</b><span>связей</span></div>
</div>
<h2>Задачи</h2>
<table><tr><th>задача</th><th>последний запуск</th><th>предел</th><th>состояние</th></tr>{job_rows}</table>
<h2>Проблемы</h2><table><tr><th>проверка</th><th>что не так</th></tr>{prow}</table>
<h2>Графики</h2>
<div>Дашборд: <a href="http://192.168.1.113:3000/d/buryan-hub">Grafana — Buryan Hub</a>
· <a href="/metrics">метрики Prometheus</a></div>
<h2>Медиа: граф контента</h2>
<div class="muted" style="margin-bottom:8px">
<a href="graph.html">интерактивный граф</a> ·
<a href="ask.html">спросить агента</a>
</div>
<div class="muted">карточек {g_cards} · связей {g_links}{g_growth}</div>
<table><tr><th>связь</th><th>сколько</th><th></th></tr>{g_rel_rows}</table>
<h3 style="font-size:14px;color:#8fb4d9;margin:18px 0 6px">Фантастика по десятилетиям</h3>
{g_timeline}
<h3 style="font-size:14px;color:#8fb4d9;margin:18px 0 6px">Книги и экранизации</h3>
<table>{g_cross_rows}</table>
<h2>Личное</h2>
<div class="muted">хочу посмотреть · мои оценки · для вас</div>
<table>{g_personal}</table>
<h2>Доступы по сервисам</h2>
<div class="muted">аудит по понедельникам, команда !users у бота Инфраструктура</div>
<pre>{identity_text}</pre>
<h2>Что есть в сервисах</h2>
<table><tr><th>сервис</th><th>что есть</th></tr>{inv_rows}</table>
<h2>Действия сверки и автоисправлений</h2>
<table><tr><th>когда</th><th>что</th><th>цель</th><th>результат</th><th>статус</th></tr>{arows}</table>
<h2>Последние события</h2>
<table><tr><th>когда</th><th>источник</th><th>тип</th><th>объект</th></tr>{rows}</table>
<h2>Источники событий</h2>
<table><tr><th>источник</th><th>всего</th><th>за сутки</th><th>последнее</th></tr>{src_rows}</table>
"""
JELLYFIN_URL = os.environ.get("JELLYFIN_URL", "http://192.168.1.103:8096")
JELLYFIN_KEY = os.environ.get("JELLYFIN_KEY", "")
def _jellyfin_scan():
"""Просим Jellyfin пересканировать библиотеку."""
if not JELLYFIN_KEY:
return False, "нет ключа Jellyfin"
req = urllib.request.Request(
f"{JELLYFIN_URL}/Library/Refresh", data=b"", method="POST",
headers={"Authorization": f'MediaBrowser Token="{JELLYFIN_KEY}"'})
try:
with urllib.request.urlopen(req, timeout=20) as r:
return r.status in (200, 204), f"HTTP {r.status}"
except urllib.error.HTTPError as e:
return False, f"HTTP {e.code}"
except Exception as e:
return False, str(e)[:100]
def _journal(kind, target, detail, status="done", rollback=None):
try:
con = db()
with con.cursor() as cur:
cur.execute("""insert into actions (kind, target, detail, status, rollback)
values (%s,%s,%s,%s,%s)""", (kind, target, detail, status, rollback))
con.close()
except Exception:
pass
def auto_actions(ev, etype):
"""Что сделать сразу после события."""
ent = ev.get("entity") or {}
title = ent.get("title") or ent.get("key") or "объект"
if etype == "media.imported":
ok, detail = _jellyfin_scan()
_journal("scan", "jellyfin", f"после импорта «{title}»: {detail}",
"done" if ok else "failed", None)
return ok
if etype == "media.requested":
# заявку просто фиксируем: одобрение — решение человека
_journal("note", "seerr", f"заявка «{title}» принята", "done", None)
return True
return False
class Handler(BaseHTTPRequestHandler):
def log_message(self, *a):
pass
def _json(self, code, obj):
body = json.dumps(obj, ensure_ascii=False, default=str).encode()
self.send_response(code)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_GET(self):
if self.path == "/" or self.path.startswith("/panel"):
body = render_panel().encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
if self.path.startswith("/data/"):
import urllib.parse as up
parts = self.path.split("?")[0].split("/data/")
coll = parts[1] if len(parts) > 1 else ""
qs = up.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
tag = (qs.get("tag") or [None])[0]
limit = int((qs.get("limit") or ["100"])[0])
try:
res, err = do_data_list(coll, limit, tag)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(200 if not err else 500, res or {"error": err})
if self.path.startswith("/health"):
try:
with db() as con, con.cursor() as cur:
cur.execute("select count(*) from events")
n = cur.fetchone()[0]
return self._json(200, {"ok": True, "events": n})
except Exception as e:
return self._json(500, {"ok": False, "error": str(e)[:200]})
if self.path.startswith("/metrics"):
try:
body = do_metrics().encode("utf-8")
except Exception as e:
body = f"# error: {e}".encode()
self.send_response(200)
self.send_header("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
if self.path.startswith("/compare"):
import urllib.parse as _uc
qs = _uc.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
b = (qs.get("book") or [""])[0]
f = (qs.get("film") or [""])[0]
if not b or not f:
return self._json(400, {"error": "нужны book и film"})
try:
data = do_compare(b, f)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(200 if data else 404, data or {"error": "не найдено"})
if self.path.startswith("/timeline"):
import urllib.parse as _u1
qs = _u1.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
q = (qs.get("q") or [""])[0]
k = (qs.get("kind") or ["тема"])[0]
if not q:
return self._json(400, {"error": "нужен q"})
try:
data = do_timeline(q, k)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(200 if data else 404, data or {"error": "не найдено"})
if self.path.startswith("/cross"):
try:
return self._json(200, do_cross())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/persons"):
import urllib.parse as _u2
qs = _u2.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
k = (qs.get("kind") or ["актёр"])[0]
try:
return self._json(200, do_top_persons(k))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/yandex.html"):
try:
with open("/opt/hub-core/yandex.html", encoding="utf-8") as f:
body = f.read().encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/yandex/status"):
try:
return self._json(200, yandex_status())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/yandex/save"):
length = int(self.headers.get("Content-Length") or 0)
raw = self.rfile.read(length) if length else b"{}"
try:
data = json.loads(raw or b"{}")
except Exception:
return self._json(400, {"error": "плохой json"})
try:
return self._json(200, yandex_save(data.get("token")))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/ask.html"):
try:
with open("/opt/hub-core/ask.html", encoding="utf-8") as f:
body = f.read().encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/ask"):
import urllib.parse as _ua
qs = _ua.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
q = (qs.get("q") or [""])[0]
if not q:
return self._json(400, {"error": "нужен q"})
try:
import sys as _sys
if "/opt/hub-bots" not in _sys.path:
_sys.path.insert(0, "/opt/hub-bots")
from hub import agent as _agent
answer, plan = _agent.run(q)
return self._json(200, {"answer": answer,
"plan": _agent.describe(plan)})
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/graph.html"):
try:
with open("/opt/hub-core/graph.html", encoding="utf-8") as f:
body = f.read().encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/graph"):
try:
if "json" in self.path:
return self._json(200, do_graph_json())
return self._json(200, do_graph_stats())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/person.html"):
try:
with open("/opt/hub-core/person.html", encoding="utf-8") as f:
body = f.read().encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/coworkers"):
import urllib.parse as _ucw
qs = _ucw.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
q = (qs.get("q") or [""])[0]
if not q:
return self._json(400, {"error": "нужен q"})
try:
data = do_coworkers(q)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(200 if data else 404, data or {"error": "не найдено"})
if self.path.startswith("/history"):
import urllib.parse as _uh
qs = _uh.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
try:
days = int((qs.get("days") or ["30"])[0])
except ValueError:
days = 30
try:
return self._json(200, do_history(days))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/snapshot"):
try:
return self._json(200, snapshot_graph())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/for-me"):
import urllib.parse as _ufm
qs = _ufm.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
try:
lim = int((qs.get("limit") or ["10"])[0])
except ValueError:
lim = 10
try:
return self._json(200, do_for_me(lim))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/watchlist"):
import urllib.parse as _uw
qs = _uw.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
mark = (qs.get("mark") or [None])[0]
if mark:
try:
data = do_watchlist(mark=mark)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(200 if data else 404, data or {"error": "не найдено"})
try:
return self._json(200, do_watchlist())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path == "/rate" or self.path.startswith("/rate?"):
import urllib.parse as _ur
qs = _ur.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
t = (qs.get("title") or [""])[0]
sc = (qs.get("score") or ["0"])[0]
if not t:
return self._json(400, {"error": "нужен title"})
try:
data = do_rate(t, sc)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(200 if data else 404, data or {"error": "не найдено"})
if self.path.startswith("/rated"):
try:
return self._json(200, do_rated())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/seasons"):
import urllib.parse as _use
qs = _use.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
q = (qs.get("q") or [""])[0]
if not q:
return self._json(400, {"error": "нужен q"})
try:
data = do_seasons(q)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(200 if data else 404, data or {"error": "не найдено"})
if self.path.startswith("/suggest"):
import urllib.parse as _usg
qs = _usg.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
q = (qs.get("q") or [""])[0]
try:
lim = int((qs.get("limit") or ["8"])[0])
except ValueError:
lim = 8
try:
return self._json(200, do_suggest(q, lim))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/candidates"):
import urllib.parse as _ucd
qs = _ucd.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
try:
lim = int((qs.get("limit") or ["20"])[0])
except ValueError:
lim = 20
try:
return self._json(200, do_candidates(lim))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/mood"):
import urllib.parse as _um
qs = _um.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
m = (qs.get("mood") or [""])[0]
if not m:
return self._json(400, {"error": "нужен mood"})
try:
return self._json(200, do_mood(m))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/pick"):
import urllib.parse as _upp
qs = _upp.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
g = (qs.get("genre") or [None])[0]
t = (qs.get("theme") or [None])[0]
d = (qs.get("decade") or [None])[0]
k = (qs.get("kind") or ["фильм"])[0]
per = (qs.get("person") or [None])[0]
rat = (qs.get("rating") or [None])[0]
try:
lim = int((qs.get("limit") or ["10"])[0])
except ValueError:
lim = 10
try:
return self._json(200, do_pick2(g, t, d, k, per, rat, lim))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/similar"):
import urllib.parse as _up2
qs = _up2.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
try:
eid = int((qs.get("id") or ["0"])[0])
except ValueError:
eid = 0
if not eid:
return self._json(400, {"error": "нужен id"})
try:
data = do_similar(eid)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if not data:
return self._json(404, {"error": "карточка не найдена"})
return self._json(200, data)
if self.path == "/person" or self.path.startswith("/person?"):
import urllib.parse as _up3
qs = _up3.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
q = (qs.get("q") or [""])[0]
if not q:
return self._json(400, {"error": "нужен q"})
try:
data = do_person(q)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if not data:
return self._json(404, {"error": "персона не найдена"})
return self._json(200, data)
if self.path.startswith("/links"):
try:
return self._json(200, do_links())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path == "/services":
try:
return self._json(200, do_services())
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/service/"):
src = self.path.split("/service/")[1].split("?")[0]
if not src:
return self._json(400, {"error": "нужно имя сервиса"})
try:
return self._json(200, do_service_history(src))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/search"):
import urllib.parse as up
q = (up.parse_qs(self.path.split("?", 1)[1]).get("q") or [""])[0] if "?" in self.path else ""
if not q:
return self._json(400, {"error": "нужен параметр q"})
try:
return self._json(200, do_search(q))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/entity/"):
try:
eid = int(self.path.split("/entity/")[1].split("?")[0])
except ValueError:
return self._json(400, {"error": "нужен числовой id"})
try:
data = do_entity(eid)
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if data is None:
return self._json(404, {"error": "карточка не найдена"})
return self._json(200, data)
if self.path.startswith("/entities"):
import urllib.parse as _up
qs = _up.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
kind = (qs.get("kind") or [None])[0]
q = (qs.get("q") or [None])[0]
try:
limit = int((qs.get("limit") or ["200"])[0])
except ValueError:
limit = 200
try:
return self._json(200, do_entities(kind, limit, q))
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
if self.path.startswith("/events"):
try:
with db() as con, con.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
cur.execute("""select id, at, source, type, entity, payload
from events order by id desc limit 30""")
return self._json(200, {"items": [dict(r) for r in cur.fetchall()]})
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
return self._json(404, {"error": "нет такого пути"})
def do_POST(self):
length = int(self.headers.get("Content-Length", 0))
raw = self.rfile.read(length) if length else b"{}"
try:
data = json.loads(raw or b"{}")
except json.JSONDecodeError:
return self._json(400, {"error": "не JSON"})
if self.path.startswith("/event"):
return self._event(data)
if self.path.startswith("/entity"):
return self._entity(data)
if self.path.startswith("/link"):
return self._link(data)
if self.path.startswith("/data/"):
coll = self.path.split("/data/")[1].split("?")[0]
if not coll:
return self._json(400, {"error": "нужна коллекция"})
res, err = do_data_put(coll, data)
return self._json(201 if not err else 500, res or {"error": err})
if self.path.startswith("/export"):
coll = data.get("collection") or ""
if not coll:
return self._json(400, {"error": "нужна collection"})
res, err = do_export(coll, data.get("format") or "json", data.get("filename"))
return self._json(200 if not err else 500, res or {"error": err})
return self._json(404, {"error": "нет такого пути"})
# ── события ──
def _event(self, ev):
src = (ev.get("source") or "").strip()
typ = (ev.get("type") or "").strip()
if not (src and typ):
return self._json(400, {"error": "нужны source и type"})
now = datetime.now(timezone.utc)
ent = ev.get("entity") or {}
payload = ev.get("payload") or {}
try:
with db() as con, con.cursor() as cur:
cur.execute(
"""insert into events (at, source, type, entity, payload, actor)
values (%s, %s, %s, %s, %s, %s) returning id""",
(now, src, typ, json.dumps(ent, ensure_ascii=False),
json.dumps(payload, ensure_ascii=False), ev.get("actor") or "system"))
eid = cur.fetchone()[0]
# событие, связанное с сущностью, обновляет её статус
if ent.get("kind") and ent.get("key"):
cur.execute(
"""insert into entities (kind, key, title, status, external_ids, search_text, updated_at)
values (%s, %s, %s, %s, %s, %s, %s)
on conflict (kind, key) do update
set status = excluded.status,
title = coalesce(excluded.title, entities.title),
updated_at = excluded.updated_at
returning id""",
(ent["kind"], ent["key"], ent.get("title") or ent["key"],
typ, json.dumps({src: ent.get("key")}, ensure_ascii=False),
f"{ent.get('title') or ''} {ent.get('key')}".lower(), now))
ent_id = cur.fetchone()[0]
cur.execute("update events set entity_id = %s where id = %s", (ent_id, eid))
threading.Thread(target=auto_actions, args=(ev, typ), daemon=True).start()
if typ in LOUD:
threading.Thread(target=publish, args=(human_event(ev), typ), daemon=True).start()
return self._json(201, {"ok": True, "id": eid})
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
# ── сущности ──
def _entity(self, data):
kind = (data.get("kind") or "").strip()
key = (data.get("key") or "").strip()
if not (kind and key):
return self._json(400, {"error": "нужны kind и key"})
now = datetime.now(timezone.utc)
title = data.get("title") or key
aliases = " ".join(str(a) for a in (data.get("aliases") or []) if a)
try:
with db() as con, con.cursor() as cur:
cur.execute(
"""insert into entities (kind, key, title, status, external_ids, search_text, updated_at)
values (%s, %s, %s, %s, %s, %s, %s)
on conflict (kind, key) do update
set title = excluded.title,
status = case
when entities.status in ('хочу посмотреть', 'смотрю')
and coalesce(excluded.status, '') in ('', 'в медиатеке', 'не в медиатеке')
then entities.status
else coalesce(excluded.status, entities.status)
end,
external_ids = entities.external_ids || excluded.external_ids,
search_text = excluded.search_text,
updated_at = excluded.updated_at
returning id""",
(kind, key, title, data.get("status"),
json.dumps(data.get("external_ids") or {}, ensure_ascii=False),
f"{title} {key} {aliases}".lower(), now))
rid = cur.fetchone()[0]
return self._json(201, {"ok": True, "id": rid})
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
def _link(self, data):
a, b = data.get("from"), data.get("to")
rel = data.get("relation") or "related"
if not (a and b):
return self._json(400, {"error": "нужны from и to (id)"})
try:
with db() as con, con.cursor() as cur:
cur.execute(
"""insert into entity_links (from_id, to_id, relation)
values (%s, %s, %s) on conflict do nothing returning id""",
(a, b, rel))
row = cur.fetchone()
return self._json(201, {"ok": True, "id": row[0] if row else None})
except Exception as e:
return self._json(500, {"error": str(e)[:200]})
def main():
ensure_schema()
srv = ThreadingHTTPServer(("0.0.0.0", PORT), Handler)
print(f"hub-core слушает {PORT}", flush=True)
srv.serve_forever()
if __name__ == "__main__":
main()