Граф v3: персоны, рекомендации, оценки, языки, русские названия

Добавлены связи из SkyHook: режиссёры и актёры (Credits), рекомендации
(Recommendations), оценки IMDb по корзинам, возрастной рейтинг, язык.
Русские названия из AlternativeTitles сохраняются как алиасы — поиск
«Дюна» находит Dune.

Итог: 359 карточек и 376 связей (было 182 и 193), 48 актёров, 6 режиссёров,
41 кандидат, 42 темы.

Новые команды бота Медиа: «тема <слово>» (подборка), «связи <название>»
(вся карточка со связями), «рекомендации» (что посмотреть из кандидатов).

Доработано в ядре: /entities с фильтром по виду и лимитом, поддержка
aliases при создании карточки.

Ловушки: кириллица в query требует urlencode; псевдоним «связи» перехватывался
командой link — переопределён ALIASES в MediaBot.
This commit is contained in:
buryan-agent committed 2026-10-20 10:49:09 +03:00
1 parent 63f02b4521
commit 3e680ab934
5 files changed
+1145 -95

No files matched your search

+61
View File
@@ -24,10 +24,68 @@ def _empty_hint():
class MediaBot(Bot):
ALIASES = dict(Bot.ALIASES, **{"связи": "связи", "тема": "тема",
"рекомендации": "рекомендации"})
name = "media"
title = "Медиа"
room_env = "MEDIA_ROOM"
def _theme_cmd(self, arg):
term = (arg or "").strip()
if not term:
return "Укажите тему: !тема artificial intelligence"
card, err = core_api.find_entity(term, kinds=["тема", "жанр"])
if err:
return "Ядро не ответило: " + str(err)
if not card:
return "Темы «" + term + "» в графе нет."
data, _ = core_api.links_of(card["id"])
links = (data or {}).get("links") or []
title = card.get("title") or term
if not links:
return "К теме «" + title + "» ничего не привязано."
lines = ["**" + title + "** — связей: " + str(len(links)), ""]
for l in links[:15]:
lines.append("• " + str(l.get("title")) + " (" + str(l.get("kind")) + ")")
return chr(10).join(lines)
def _recommend_cmd(self):
items, err = core_api.entities("кандидат", limit=200)
if err:
return "Ядро не ответило: " + str(err)
if not items:
return "Рекомендаций пока нет — нужен хотя бы один фильм в медиатеке."
lines = ["**Что посмотреть** (рекомендации по вашим фильмам)", ""]
for i in items[:15]:
lines.append("• " + str(i.get("title")))
lines.append("")
lines.append("_Это кандидаты: их нет в медиатеке, но они рекомендованы._")
return chr(10).join(lines)
def _graph_cmd(self, arg):
term = (arg or "").strip()
if not term:
return "Укажите название: !связи Дюна"
card, err = core_api.find_entity(term)
if err:
return "Ядро не ответило: " + str(err)
if not card:
return "«" + term + "» в графе нет."
data, _ = core_api.links_of(card["id"])
info = data or {}
links = info.get("links") or []
lines = ["**" + str(card.get("title")) + "** (" + str(card.get("kind")) + ")", ""]
by_rel = {}
for l in links:
by_rel.setdefault(l.get("relation") or "связь", []).append(str(l.get("title")))
for rel, titles in by_rel.items():
lines.append("• " + rel + ": " + ", ".join(titles[:8]))
if not links:
lines.append("_связей нет_")
return chr(10).join(lines)
def _media_hub_cmd(self):
"""Медиа Хаб: заявки, очередь, просмотр, нехватка, место."""
data, err = core_api.get_data("media", 1)
@@ -57,6 +115,9 @@ class MediaBot(Bot):
self.cmd("paths", "где лежат файлы и куда их класть")(lambda a: self._paths())
self.cmd("хаб", "медиа хаб: заявки, очередь, просмотр, место")(lambda a: self._media_hub_cmd())
self.cmd("тема", "подборка по теме: !тема artificial intelligence")(lambda a: self._theme_cmd(a))
self.cmd("рекомендации", "что посмотреть из рекомендаций")(lambda a: self._recommend_cmd())
self.cmd("связи", "все связи объекта: !связи Дюна")(lambda a: self._graph_cmd(a))
def _stats(self, jf):
c = jf.counts()
info, _ = jf.info()
+24
View File
@@ -80,3 +80,27 @@ def services():
def service_history(name, limit=30):
return _get(f"/service/{name}", {"limit": limit})
def find_entity(text, kinds=None):
data, err = _get("/search", {"q": text, "limit": 20})
if err:
return None, err
items = (data or {}).get("items") or []
if kinds:
items = [i for i in items if i.get("kind") in kinds]
return (items[0] if items else None), None
def links_of(entity_id):
return _get("/entity/%s" % entity_id)
def entities(kind=None, limit=200):
data, err = _get("/entities", {"limit": limit})
if err:
return [], err
items = (data or {}).get("items") or []
if kind:
items = [i for i in items if i.get("kind") == kind]
return items, None
+65 -47
View File
@@ -1,74 +1,92 @@
# Граф контента
Связи между фильмами, книгами, франшизами, жанрами, студиями, темами и
эпохами. Превращает список файлов в медиатеку, по которой можно
ориентироваться.
Связи между фильмами, книгами, франшизами, персонами, темами и эпохами.
## Что связывается
| Связь | Источник данных |
| Связь | Источник |
|---|---|
| фильм → коллекция «входит в» | `collection` из Radarr |
| фильм → жанр «жанр» | `genres` из Radarr |
| фильм → студия «снят студией» | `studio` из Radarr |
| фильм → тема «тема» | `keywords` из Radarr (до 5 на фильм) |
| фильм → коллекция «входит в» | `collection` Radarr (TMDB) |
| фильм → жанр «жанр» | `genres` Radarr |
| фильм → студия «снят студией» | `studio` Radarr |
| фильм → тема «тема» | `keywords` Radarr |
| фильм → эпоха «снят в» | год → десятилетие |
| фильм → фильм «продолжение» | коллекция, сортировка по году |
| **фильм → режиссёр «снял»** | `Credits.Crew` (Job=Director) из SkyHook |
| **фильм → актёр «снялся»** | `Credits.Cast` (до 5) из SkyHook |
| **фильм → оценка «оценка»** | `MovieRatings.Imdb` → 8+/7–8/<7 |
| **фильм → рейтинг «возрастной рейтинг»** | `Certifications` (US) |
| **фильм → язык «язык»** | `OriginalLanguage` |
| **фильм → кандидат «рекомендует»** | `Recommendations` TMDB |
| фильм → фильм «продолжение» | коллекция по годам |
| фильм ↔ фильм «похож» | ≥2 общих жанра |
| книга → автор «написал» | авторы Calibre |
| книга → серия «входит в серию» | серия Calibre |
| книга → жанр «жанр» | теги Calibre |
| книга ↔ фильм «экранизация» | совпадение нормализованного названия |
| коллекция ↔ книжная серия «общая вселенная» | название коллекции = название серии |
| книга ↔ фильм «экранизация» | совпадение названия |
| коллекция ↔ книжная серия «общая вселенная» | название коллекции = серия |
## Наполнение для проверки
## Как получаются детали
Метаданные без скачивания файлов:
Radarr — это **SkyHook-прокси**: `https://api.radarr.video/v1/movie/{tmdb}`
отдаёт `Credits` (30 человек), `Recommendations` (10), `MovieRatings`,
`Certifications`, `AlternativeTitles`, `OriginalLanguage`.
* **12 фильмов** (Radarr, через прокси к SkyHook): Matrix ×3, Dune ×2,
Blade Runner ×2, Arrival, Interstellar, The Fifth Element, Alien, Prometheus;
* **10 книг** (Calibre, созданы как минимальные EPUB с метаданными):
Dune ×3, Hainish ×2, Hyperion Cantos ×2, Foundation, I Robot, Neuromancer;
* теги книг: science fiction, space opera, cyberpunk, classic, robots.
Запросы идут через прокси узла (`http://192.168.1.10:8888`), потому что
домашний IP для SkyHook заблокирован Cloudflare.
## Русские названия
Из `AlternativeTitles` берутся варианты с `Language: ru` и сохраняются как
алиасы карточки (поле `search_text`). Поэтому `!связи Дюна` находит
`Dune (2021)` и `Dune: Part Two (2024)`.
## Результат
```
фильмов: 12, книг: 10
карточек: 182, связей: 193
персон связано: 75
карточек: 359, связей: 376
Связи:
тема: 60 (ключевые слова фильмов)
жанр: 49 (11 жанров)
похож: 22 (общие жанры)
снят в: 12 (6 эпох)
снят студией: 12 (8 студий)
написал: 10 (5 авторов)
входит в: 9 (5 коллекций)
входит в серию: 8 (4 серии)
продолжение: 4
экранизация: 1
общая вселенная: 1
По типам:
рекомендует: 72 тема: 60 снялся: 60
жанр: 49 похож: 22 снял: 15
снят в: 12 оценка: 12 язык: 12
снят студией: 12 возрастной: 12 написал: 10
входит в: 9 серия: 8 продолжение: 4
общая вселенная: 1 экранизация: 1
```
Примеры:
Карточки: 48 актёров, 42 темы, 41 кандидат, 12 фильмов, 11 жанров,
10 книг, 8 студий, 6 режиссёров, 6 эпох, 5 авторов, 5 коллекций,
4 книжные серии.
## Команды бота Медиа
```
Продолжения:
Blade Runner (1982) → Blade Runner 2049 (2017)
Dune (2021) → Dune: Part Two (2024)
The Matrix (1999) → The Matrix Reloaded (2003)
The Matrix Reloaded (2003) → The Matrix Revolutions (2003)
Экранизация: Dune ↔ Dune (2021)
Общая вселенная: Dune Collection ↔ Dune (книжная серия)
Топ жанров: science fiction 21, Adventure 4, classic 4, Drama 4, Action 4
тема artificial intelligence → 6 фильмов про ИИ
связи Дюна → вся карточка: актёры, язык, оценка, темы,
жанры, похожие, студия, эпоха, рекомендации
рекомендации → 15 кандидатов, которых нет в медиатеке
хаб → полный обзор медиатеки
```
## Где видно
Пример `связи Дюна`:
* `GET /links` — сводка по типам и список связей;
* Медиа Хаб — блок «Связи контента»;
* бот Медиа — команда `хаб`;
* расписание — ежедневно 04:45.
```
Dune: Part Two (2024) (фильм)
• снялся: Rebecca Ferguson, Timothée Chalamet, Zendaya, Javier Bardem
• язык: английский · оценка: высокая (8+) · снят в: 2020-е
• тема: based on novel or book, chosen one, ambiguous
• жанр: science fiction, Adventure
• похож: The Fifth Element, Dune (2021), Interstellar
• снят студией: Legendary Pictures
• рекомендует: Dune (2021), Avatar: Fire and Ash, …
```
## Ловушки
* Кириллица в query-строке должна быть закодирована: `curl -G --data-urlencode`.
Без кодирования сервер видит мусор и возвращает пустой список.
* `/entities` по умолчанию отдавал всё — добавлен фильтр `kind` и `limit`.
* Псевдоним «связи» в базовом классе указывал на команду `link`, которой у
Медиа-бота нет. Пришлось переопределить `ALIASES` в классе MediaBot.
+114 -48
View File
@@ -1,38 +1,44 @@
"""Граф контента v2: фильмы, книги, франшизы, жанры, студии, темы, эпохи.
"""Граф контента v3: персоны, рекомендации, рейтинги, языки, подборки.
Связи:
фильм → коллекция «входит в»
фильм → жанр «жанр»
фильм → студия «снят студией»
фильм → тема (ключевые слова) «тема»
фильм → фильм «продолжение» (внутри коллекции по годам)
фильм ↔ фильм «похож» (≥2 общих жанра)
фильм → эпоха «снят в»
книга → автор «написал»
книга → серия «входит в серию»
книга → жанр (тег) «жанр»
книга ↔ фильм «экранизация»
коллекция ↔ книжная серия «общая вселенная»
Дополнительно к v2 (жанры, студии, темы, эпохи, продолжения, похожие):
фильм → режиссёр «снял»
фильм → актёр «снялся»
фильм → кандидат «рекомендует» (из TMDB, если фильма нет в медиатеке)
фильм → рейтинг «возрастной рейтинг»
фильм → оценка «оценка»
фильм → язык «язык»
"""
import json
import os
import re
import subprocess
import sys
import urllib.error
import urllib.request
CORE = os.environ.get("CORE_URL", "http://127.0.0.1:9120")
RADARR = os.environ.get("RADARR_URL", "http://192.168.1.118:7878")
RADARR_KEY = os.environ.get("RADARR_KEY", "")
SKYHOOK = "https://api.radarr.video/v1/movie"
PROXY = "http://192.168.1.10:8888"
MAX_THEMES_PER_ITEM = 5
MAX_THEMES = 5
MAX_CAST = 5
MAX_RECOMMEND = 6
MAX_SIMILAR = 40
LANGS = {"en": "английский", "ru": "русский", "fr": "французский",
"de": "немецкий", "ja": "японский", "es": "испанский"}
def get(url, headers=None, timeout=25):
def get(url, headers=None, timeout=25, proxy=None):
handlers = []
if proxy:
handlers.append(urllib.request.ProxyHandler({"https": proxy, "http": proxy}))
opener = urllib.request.build_opener(*handlers)
req = urllib.request.Request(url, headers=headers or {})
try:
req = urllib.request.Request(url, headers=headers or {})
with urllib.request.urlopen(req, timeout=timeout) as r:
with opener.open(req, timeout=timeout) as r:
return json.loads(r.read() or b"{}"), None
except Exception as e:
return None, str(e)[:100]
@@ -67,11 +73,18 @@ def movies():
"title": m.get("title"), "year": m.get("year"), "tmdb": m.get("tmdbId"),
"collection": col.get("title"), "collection_tmdb": col.get("tmdbId"),
"genres": m.get("genres") or [], "studio": m.get("studio"),
"keywords": (m.get("keywords") or [])[:MAX_THEMES_PER_ITEM],
"keywords": (m.get("keywords") or [])[:MAX_THEMES],
})
return out
def skyhook(tmdb):
data, err = get(f"{SKYHOOK}/{tmdb}", proxy=PROXY, timeout=40)
if err:
return {}, err
return data or {}, None
def books():
script = '''
import json, sqlite3
@@ -96,7 +109,6 @@ print(json.dumps(rows, ensure_ascii=False))
try:
return json.loads(out.stdout or "[]")
except Exception:
print(" Calibre:", (out.stderr or "")[:80])
return []
@@ -113,13 +125,14 @@ def main():
bk = books()
print(f"фильмов: {len(mv)}, книг: {len(bk)}")
ids = {}
cards = 0
links = 0
ids, cards, links = {}, 0, 0
def card(kind, key, title, status=None):
def card(kind, key, title, status=None, aliases=None):
nonlocal cards
res, err = post("/entity", {"kind": kind, "key": key, "title": title, "status": status})
payload = {"kind": kind, "key": key, "title": title, "status": status}
if aliases:
payload["aliases"] = aliases
res, err = post("/entity", payload)
if err or not res:
return None
cards += 1
@@ -134,41 +147,95 @@ def main():
if not err:
links += 1
# фильмы и их метаданные
# ── фильмы и метаданные из Radarr ──
for m in mv:
mid = card("фильм", f"tmdb:{m['tmdb']}", f"{m['title']} ({m['year']})", "в медиатеке")
for g in m["genres"]:
gid = card("жанр", f"genre:{norm(g)}", g)
link(mid, gid, "жанр")
link(mid, card("жанр", f"genre:{norm(g)}", g), "жанр")
if m["studio"]:
sid = card("студия", f"studio:{norm(m['studio'])}", m["studio"])
link(mid, sid, "снят студией")
link(mid, card("студия", f"studio:{norm(m['studio'])}", m["studio"]), "снят студией")
for kw in m["keywords"]:
tid = card("тема", f"theme:{norm(kw)}", kw)
link(mid, tid, "тема")
link(mid, card("тема", f"theme:{norm(kw)}", kw), "тема")
dec = decade(m["year"])
if dec:
did = card("эпоха", f"decade:{dec}", dec)
link(mid, did, "снят в")
link(mid, card("эпоха", f"decade:{dec}", dec), "снят в")
if m["collection"]:
cid = card("коллекция", f"collection:{m['collection_tmdb'] or norm(m['collection'])}",
m["collection"], "франшиза")
link(mid, cid, "входит в")
# книги
# ── детали из SkyHook: персоны, рейтинги, рекомендации, язык ──
in_library = {m["tmdb"] for m in mv}
persons = 0
for m in mv:
det, err = skyhook(m["tmdb"])
if err:
print(f" skyhook {m['title']}: {err}")
continue
mid = ids.get(f"tmdb:{m['tmdb']}")
# русские названия — для поиска «Дюна» вместо «Dune»
alts = []
for a in det.get("AlternativeTitles") or []:
if (a.get("Language") or "").lower() in ("ru", "ru-ru"):
t = a.get("Title")
if t and t not in alts:
alts.append(t)
if alts:
card("фильм", "tmdb:%s" % m["tmdb"], "%s (%s)" % (m["title"], m["year"]),
"в медиатеке", aliases=alts[:3])
credits = det.get("Credits") or {}
for c in (credits.get("Crew") or []):
if c.get("Job") == "Director" and c.get("Name"):
pid = card("режиссёр", f"person:{norm(c['Name'])}", c["Name"])
link(mid, pid, "снял")
persons += 1
for c in (credits.get("Cast") or [])[:MAX_CAST]:
if c.get("Name"):
pid = card("актёр", f"person:{norm(c['Name'])}", c["Name"])
link(mid, pid, "снялся")
persons += 1
ratings = det.get("MovieRatings") or {}
imdb = (ratings.get("Imdb") or {}).get("Value") or 0
if imdb:
bucket = "высокая (8+)" if imdb >= 8 else ("хорошая (7–8)" if imdb >= 7 else "средняя (<7)")
link(mid, card("оценка", f"rating:{bucket}", bucket), "оценка")
certs = det.get("Certifications") or []
us = next((c.get("Certification") for c in certs if c.get("Country") == "US"), None)
if us:
link(mid, card("рейтинг", f"cert:{us}", us), "возрастной рейтинг")
lang = det.get("OriginalLanguage") or ""
if lang:
name = LANGS.get(lang, lang)
link(mid, card("язык", f"lang:{lang}", name), "язык")
for r in (det.get("Recommendations") or [])[:MAX_RECOMMEND]:
rt = r.get("TmdbId")
if not rt or rt == m["tmdb"]:
continue
if rt in in_library:
link(mid, ids.get(f"tmdb:{rt}"), "рекомендует")
else:
title = r.get("Title") or f"tmdb:{rt}"
rid = card("кандидат", f"candidate:{rt}", title, "не в медиатеке")
link(mid, rid, "рекомендует")
print(f" персон связано: {persons}")
# ── книги ──
for b in bk:
bid = card("книга", f"calibre:{b['id']}", b["title"], "в библиотеке")
for a in b.get("authors") or []:
aid = card("автор", f"author:{norm(a)}", a)
link(bid, aid, "написал")
link(bid, card("автор", f"author:{norm(a)}", a), "написал")
if b.get("series"):
sid = card("серия книг", f"series:{norm(b['series'])}", b["series"], "книжная серия")
link(bid, sid, "входит в серию")
link(bid, card("серия книг", f"series:{norm(b['series'])}", b["series"]), "входит в серию")
for t in b.get("tags") or []:
gid = card("жанр", f"genre:{norm(t)}", t)
link(bid, gid, "жанр")
link(bid, card("жанр", f"genre:{norm(t)}", t), "жанр")
# экранизации
# ── экранизации ──
by_title = {}
for m in mv:
by_title.setdefault(norm(m["title"]), []).append(m["tmdb"])
@@ -176,26 +243,25 @@ def main():
for tmdb in by_title.get(norm(b["title"]), []):
link(ids.get(f"calibre:{b['id']}"), ids.get(f"tmdb:{tmdb}"), "экранизация")
# продолжения внутри коллекции (по году)
# ── продолжения ──
by_col = {}
for m in mv:
if m["collection"]:
by_col.setdefault(norm(m["collection"]), []).append(m)
for col, items in by_col.items():
for _, items in by_col.items():
items.sort(key=lambda x: x.get("year") or 0)
for prev, nxt in zip(items, items[1:]):
link(ids.get(f"tmdb:{prev['tmdb']}"), ids.get(f"tmdb:{nxt['tmdb']}"), "продолжение")
# похожие: ≥2 общих жанра
# ── похожие по жанрам ──
made = 0
for i, a in enumerate(mv):
for b in mv[i + 1:]:
common = set(a["genres"]) & set(b["genres"])
if len(common) >= 2 and made < MAX_SIMILAR:
if len(set(a["genres"]) & set(b["genres"])) >= 2 and made < MAX_SIMILAR:
link(ids.get(f"tmdb:{a['tmdb']}"), ids.get(f"tmdb:{b['tmdb']}"), "похож")
made += 1
# общая вселенная: коллекция ↔ книжная серия
# ── общая вселенная ──
for m in mv:
if not m["collection"]:
continue
+881
View File
@@ -0,0 +1,881 @@
"""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, HTTPServer
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 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()]
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 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()
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 = []
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>"
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">аудит по понедельникам, команда !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("/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 = coalesce(excluded.status, entities.status),
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 = HTTPServer(("0.0.0.0", PORT), Handler)
print(f"hub-core слушает {PORT}", flush=True)
srv.serve_forever()
if __name__ == "__main__":
main()