Музыка разложена по /mnt/media/music/users/<user>/; в Navidrome создана отдельная библиотека на пользователя и настроен доступ через user_library (каждый видит свою + общую). Персональные токены: /root/.yandex-tokens/<user>.json, доступ по личным ссылкам yandex.html?k=<секрет>. Неверный ключ — 403. sync_users.py проходит по всем токенам и раскладывает лайки по папкам, затем полный скан Navidrome. Cron 05:30 по 3 новых трека на пользователя. roman: 463 трека, 2.3 ГБ. Изоляция проверена на двух тестовых пользователях через Subsonic API: с библиотекой roman поиск «ATL» дал 5 треков, с пустой библиотекой elena — 0. Ловушки: перенос файлов только на узле (uid контейнера); пароли Navidrome шифрует, вставка в БД не работает; CLI требует TTY (script + docker exec -it); library.path уникален; старые media_file чистятся по path.
2087 lines
88 KiB
Python
2087 lines
88 KiB
Python
"""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 {}
|
||
if not acc.get("uid"):
|
||
return {"has_token": False,
|
||
"error": "токен не принят: Яндекс вернул гостевой аккаунт"}
|
||
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 extract_token(raw):
|
||
"""Достаёт токен из строки: поддерживает URL с #access_token=..."""
|
||
import re as _re
|
||
raw = (raw or "").strip()
|
||
m = _re.search(r"access_token=([A-Za-z0-9._~+/=-]+)", raw)
|
||
if m:
|
||
return m.group(1)
|
||
m = _re.search(r"OAuth\s+([A-Za-z0-9._~+/=-]+)", raw)
|
||
if m:
|
||
return m.group(1)
|
||
return raw.split()[0] if raw else ""
|
||
|
||
|
||
def yandex_save(tok):
|
||
"""Сохраняет токен и сразу проверяет его."""
|
||
import os as _os
|
||
tok = extract_token(tok)
|
||
if not tok or len(tok) < 20:
|
||
return {"error": "токен слишком короткий — вставьте саму строку токена или ссылку"}
|
||
# сначала проверяем, потом сохраняем
|
||
import json as _j
|
||
import urllib.request as _r
|
||
req = _r.Request("https://api.music.yandex.net/account/status",
|
||
headers={"Authorization": "OAuth " + tok})
|
||
try:
|
||
with _r.urlopen(req, timeout=15) as resp:
|
||
d = _j.loads(resp.read() or b"{}")
|
||
except Exception as e:
|
||
return {"error": "Яндекс не принял токен: " + str(e)[:80]}
|
||
|
||
res = d.get("result") or {}
|
||
acc = res.get("account") or {}
|
||
if not acc.get("uid"):
|
||
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()
|
||
|
||
|
||
|
||
|
||
YANDEX_KEYS = "/root/.yandex-keys.json"
|
||
YANDEX_TOKENS_DIR = "/root/.yandex-tokens"
|
||
YANDEX_USERS = ["roman", "elena", "polina", "nikita", "daniil", "sergey", "alextest"]
|
||
|
||
|
||
def yandex_keys():
|
||
"""Ключи-ссылки для пользователей: имя → секрет."""
|
||
import os as _os
|
||
import secrets as _sec
|
||
if _os.path.exists(YANDEX_KEYS):
|
||
try:
|
||
return json.load(open(YANDEX_KEYS, encoding="utf-8"))
|
||
except Exception:
|
||
pass
|
||
keys = {u: _sec.token_urlsafe(16) for u in YANDEX_USERS}
|
||
with open(YANDEX_KEYS, "w", encoding="utf-8") as f:
|
||
json.dump(keys, f, ensure_ascii=False, indent=2)
|
||
_os.chmod(YANDEX_KEYS, 0o600)
|
||
return keys
|
||
|
||
|
||
def yandex_user_by_key(key):
|
||
if not key:
|
||
return None
|
||
for user, k in yandex_keys().items():
|
||
if k == key:
|
||
return user
|
||
return None
|
||
|
||
|
||
def yandex_token_path(user):
|
||
import os as _os
|
||
_os.makedirs(YANDEX_TOKENS_DIR, exist_ok=True)
|
||
return _os.path.join(YANDEX_TOKENS_DIR, user + ".json")
|
||
|
||
|
||
def yandex_user_status(user):
|
||
import os as _os
|
||
import urllib.request as _rq
|
||
path = yandex_token_path(user)
|
||
if not _os.path.exists(path):
|
||
return {"user": user, "has_token": False}
|
||
try:
|
||
data = json.load(open(path, encoding="utf-8"))
|
||
except Exception:
|
||
return {"user": user, "has_token": False}
|
||
tok = data.get("token") or ""
|
||
if not tok:
|
||
return {"user": user, "has_token": False}
|
||
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"{}")
|
||
except Exception as e:
|
||
return {"user": user, "has_token": True, "error": str(e)[:100]}
|
||
res = d.get("result") or {}
|
||
acc = res.get("account") or {}
|
||
return {"user": user, "has_token": bool(acc.get("uid")),
|
||
"login": acc.get("displayName") or acc.get("login"),
|
||
"plus": bool((res.get("plus") or {}).get("hasPlus"))}
|
||
|
||
|
||
def yandex_save_for(user, tok):
|
||
import os as _os
|
||
import urllib.request as _rq
|
||
tok = extract_token(tok)
|
||
if not tok or len(tok) < 20:
|
||
return {"error": "токен слишком короткий"}
|
||
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"{}")
|
||
except Exception as e:
|
||
return {"error": "Яндекс не принял токен: " + str(e)[:80]}
|
||
res = d.get("result") or {}
|
||
acc = res.get("account") or {}
|
||
if not acc.get("uid"):
|
||
return {"error": "Яндекс вернул гостевой аккаунт — токен не подходит"}
|
||
path = yandex_token_path(user)
|
||
payload = {"token": tok, "login": acc.get("displayName") or acc.get("login"),
|
||
"uid": acc.get("uid"),
|
||
"plus": bool((res.get("plus") or {}).get("hasPlus"))}
|
||
with open(path, "w", encoding="utf-8") as f:
|
||
json.dump(payload, f, ensure_ascii=False)
|
||
_os.chmod(path, 0o600)
|
||
return {"user": user, "has_token": True, "login": payload["login"],
|
||
"plus": payload["plus"]}
|
||
|
||
|
||
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("&", "&").replace("<", "<")
|
||
|
||
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/user-status"):
|
||
import urllib.parse as _uy
|
||
qs = _uy.parse_qs(self.path.split("?")[1]) if "?" in self.path else {}
|
||
user = yandex_user_by_key((qs.get("k") or [""])[0])
|
||
if not user:
|
||
return self._json(403, {"error": "неверная ссылка"})
|
||
try:
|
||
return self._json(200, yandex_user_status(user))
|
||
except Exception as e:
|
||
return self._json(500, {"error": str(e)[:200]})
|
||
if self.path.startswith("/yandex/users"):
|
||
out = {}
|
||
for u in YANDEX_USERS:
|
||
try:
|
||
out[u] = yandex_user_status(u)
|
||
except Exception as e:
|
||
out[u] = {"user": u, "error": str(e)[:60]}
|
||
return self._json(200, {"users": out})
|
||
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("/yandex/save"):
|
||
try:
|
||
key = data.get("key") or ""
|
||
user = yandex_user_by_key(key)
|
||
if user:
|
||
return self._json(200, yandex_save_for(user, data.get("token")))
|
||
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("/yandex/save"):
|
||
try:
|
||
key = data.get("key") or ""
|
||
user = yandex_user_by_key(key)
|
||
if user:
|
||
return self._json(200, yandex_save_for(user, data.get("token")))
|
||
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("/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 (from_id, to_id, relation) 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()
|