Files
buryan-infra/ops/bots/hub/bots.py
T
buryan-agent ba5e011d7a Композиторы, связи авторов и подбор из медиатеки (!посмотреть)
Граф: композиторы из Credits.Crew (10 связей «музыка») и автор → фильм
(«экранирован»: Frank Herbert → Dune 2021). Итого 369 карточек, 387 связей.

Ядро: GET /pick с фильтрами genre/theme/decade — подбор из имеющегося с
оценкой и жанрами. Композиторы добавлены в /person.

Бот: команда «посмотреть» разбирает эпоху (80-е, 1999, 2020-е) и подбирает
фильмы, пробуя комбинации жанр+эпоха, тема+эпоха, жанр, тема, эпоха.

Проверено: 80-е → Blade Runner, 1999 → Fifth Element и Matrix,
2020-е → оба Dune, science fiction → 5 фильмов с оценками.

Ловушка: двузначный год превращался в «800-е» — добавлено правило века.
2026-10-20 11:28:49 +03:00

1052 lines
48 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Флот ботов: у каждого свой домен и свои команды."""
import datetime
from . import catalog, core_api, index, local, sources, util
# кэши: тяжёлые проверки не нужно повторять каждую секунду
_GAPS_CACHE = {"at": 0.0, "value": None}
_GAPS_FULL = {"at": 0.0, "value": None}
_GAPS_TTL = 60.0
from .matrix import Bot
from .sources import CFG, RADARR, SONARR, Jellyfin, Prom, Seerr
def _fmt_item(it):
year = it.get("ProductionYear")
name = it.get("Name", "без названия")
kind = {"Movie": "фильм", "Series": "сериал", "Audio": "трек"}.get(it.get("Type"), it.get("Type", ""))
return f"{name}" + (f" ({year})" if year else "") + (f" — {kind}" if kind else "")
def _empty_hint():
return ("\n\n_Библиотека пуста._ Наполнить можно так: "
"положить файлы в папку сервиса и запустить сканирование.")
class MediaBot(Bot):
ALIASES = dict(Bot.ALIASES, **{"связи": "связи", "тема": "тема",
"рекомендации": "рекомендации"})
name = "media"
title = "Медиа"
room_env = "MEDIA_ROOM"
def _pick_cmd(self, arg):
import re as _re
text = (arg or "").strip()
decade = None
rest = text
m4 = _re.search(r"(19|20)\d{2}", text)
m2 = _re.search(r"\b(\d{2})\s*(?:-?е|-?х|ые|ых)?\b", text)
if m4:
y = int(m4.group(0))
decade = str((y // 10) * 10) + "-е"
rest = (text[:m4.start()] + " " + text[m4.end():]).strip()
elif m2:
two = int(m2.group(1))
year = (1900 + two) if two >= 30 else (2000 + two)
decade = str((year // 10) * 10) + "-е"
rest = (text[:m2.start()] + " " + text[m2.end():]).strip()
for junk in ("про", "фильм", "фильмы", "кино", "посмотреть", "покажи"):
rest = rest.replace(junk, " ")
rest = " ".join(rest.split()).strip(" ,")
attempts = []
if rest and decade:
attempts.append({"genre": rest, "decade": decade})
attempts.append({"theme": rest, "decade": decade})
if rest:
attempts.append({"genre": rest})
attempts.append({"theme": rest})
if decade:
attempts.append({"decade": decade})
if not attempts:
attempts.append({})
items, used = [], None
for params in attempts:
data, err = core_api.pick(limit=10, **params)
if err:
return "Ядро не ответило: " + str(err)
found = (data or {}).get("items") or []
if found:
items, used = found, params
break
if not items:
return "Ничего не нашлось. Попробуйте иначе: !посмотреть science fiction"
lines = ["**Что посмотреть**", ""]
for i in items[:10]:
parts = [str(i.get("title"))]
if i.get("rating"):
parts.append(str(i.get("rating")))
if i.get("genres"):
parts.append(str(i.get("genres")))
lines.append("• " + " — ".join(parts))
return chr(10).join(lines)
def _person_cmd(self, arg):
name = (arg or "").strip()
if not name:
return "Укажите имя: !персона Зендая или !персона Zendaya"
data, err = core_api.person(name)
if err:
return "Ядро не ответило: " + str(err)
if not data:
return "Не нашёл такую персону в графе."
person = data.get("person") or {}
films = data.get("films") or []
lines = ["**" + str(person.get("title")) + "** (" + str(person.get("kind")) + "), фильмов: " + str(len(films)), ""]
for f in films[:20]:
lines.append("• " + str(f.get("title")))
if not films:
lines.append("_фильмов пока нет_")
return chr(10).join(lines)
def _similar_cmd(self, arg):
term = (arg or "").strip()
if not term:
return "Укажите название: !похоже Дюна"
card, err = core_api.find_entity(term, kinds=["фильм", "книга"])
if err:
return "Ядро не ответило: " + str(err)
if not card:
return "«" + term + "» в графе нет."
data, err2 = core_api.similar(card["id"])
if err2 or not data:
return "Не удалось найти похожее."
items = data.get("similar") or []
direct = data.get("direct") or []
lines = ["**Похоже на " + str(card.get("title")) + "**", ""]
if direct:
lines.append("Прямо связаны:")
for d in direct[:5]:
lines.append("• " + str(d.get("title")))
lines.append("")
if items:
lines.append("Общие темы и жанры:")
for i in items[:10]:
via = i.get("via") or ""
lines.append("• " + str(i.get("title")) + " — общих: " + str(i.get("shared")) +
(" (" + via[:60] + ")" if via else ""))
if not items and not direct:
lines.append("_похожего не нашлось: мало связей_")
return chr(10).join(lines)
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)
if err:
return f"Ядро не ответило: {err}"
items = (data or {}).get("items") or []
if not items:
return "Медиа Хаб ещё не собирался. Он обновляется каждые 30 минут."
payload = items[0].get("payload") or {}
text = payload.get("markdown") or ""
if not text:
return "В снимке Медиа Хаба нет данных."
return text.replace("# Медиа Хаб\n\n", "")
def register(self):
jf = Jellyfin()
seerr = Seerr()
self.cmd("stats", "что есть в медиатеке: фильмы, сериалы, музыка")(lambda a: self._stats(jf))
self.cmd("new", "что добавилось последним")(lambda a: self._new(jf))
self.cmd("find", "поиск по медиатеке: `!find матрица`")(lambda a: self._find(jf, a))
self.cmd("now", "кто что смотрит прямо сейчас")(lambda a: self._now(jf))
self.cmd("queue", "очередь загрузок в Sonarr и Radarr")(lambda a: self._queue())
self.cmd("requests", "последние заявки в Seerr")(lambda a: self._requests(seerr))
self.cmd("disk", "место на дисках медиасервисов")(lambda a: self._disk())
self.cmd("wanted", "сколько ещё не найдено")(lambda a: self._wanted())
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))
self.cmd("персона", "фильмы персоны: !персона Zendaya")(lambda a: self._person_cmd(a))
self.cmd("похоже", "похожие по темам: !похоже Дюна")(lambda a: self._similar_cmd(a))
self.cmd("посмотреть", "подбор из медиатеки: !посмотреть 80-е")(lambda a: self._pick_cmd(a))
def _stats(self, jf):
c = jf.counts()
info, _ = jf.info()
names = {"Movie": "Фильмы", "Series": "Сериалы", "Episode": "Серии",
"Audio": "Треки", "MusicAlbum": "Альбомы"}
lines = ["**Медиатека**", ""]
total = 0
for k, v in c.items():
lines.append(f"• {names.get(k, k)}: {v}")
total += v or 0
if info:
lines.append(f"\nСервер: {info.get('ServerName')} {info.get('Version')}")
nav = local.Navidrome().counts()
if nav and not nav[1]:
lines.append(f"• Музыка (Navidrome): {nav[0]['albums']} альбомов, "
f"{nav[0]['tracks']} треков, {nav[0]['artists']} исполнителей")
total += nav[0]["tracks"]
if total == 0:
lines.append(_empty_hint())
return "\n".join(lines)
def _new(self, jf):
items, err = jf.recent(10)
if err:
return util.human_error(err, "Jellyfin")
if not items:
return "В медиатеке пока ничего нет." + _empty_hint()
lines = ["**Последние поступления**", ""]
for it in items:
lines.append(f"• {_fmt_item(it)}")
return "\n".join(lines)
def _find(self, jf, term):
if not term:
return "Напишите, что искать: `!find дюна`"
items, err = jf.search(term)
if err:
return util.human_error(err, "Jellyfin")
if not items:
return f"По запросу «{term}» ничего не нашлось."
lines = [f"**Найдено по «{term}»**", ""]
for it in items:
lines.append(f"• {_fmt_item(it)}")
return "\n".join(lines)
def _now(self, jf):
sess, err = jf.sessions()
if err:
return util.human_error(err, "Jellyfin")
if not sess:
return "Сейчас никто ничего не смотрит."
lines = ["**Смотрят сейчас**", ""]
for s in sess:
item = s.get("NowPlayingItem", {})
user = s.get("UserName", "?")
pos = s.get("PlayState", {}).get("PositionTicks", 0) / 10_000_000
lines.append(f"• {user}: {item.get('Name')} — {util.human_time(pos)}")
return "\n".join(lines)
def _queue(self):
lines = ["**Очередь загрузок**", ""]
for svc in (SONARR, RADARR):
total, err = svc.queue()
lines.append(f"• {svc.name}: {'—' if err else total}")
return "\n".join(lines)
def _requests(self, seerr):
reqs, err = seerr.requests(6)
if err:
return f"Seerr не ответил: {err}"
if not reqs:
return "Заявок пока нет. Заказать можно на https://ombi.buryans.ru"
lines = ["**Последние заявки**", ""]
for r in reqs:
media = r.get("media", {}) or {}
title = media.get("title") or media.get("name") or "?"
status = {1: "ожидает", 2: "одобрено", 3: "отклонено"}.get(r.get("status"), "?")
who = (r.get("requestedBy") or {}).get("displayName", "?")
lines.append(f"• {title} — {status} (просил {who})")
return "\n".join(lines)
def _disk(self):
lines = ["**Диски**", ""]
for svc in (SONARR, RADARR):
disks, err = svc.diskspace()
if err:
lines.append(f"• {svc.name}: ошибка")
continue
for d in disks:
free = d.get("freeSpace", 0)
total = d.get("totalSpace", 1)
pct = 100 * free / total if total else 0
lines.append(f"• {svc.name} {d.get('path','?')}: свободно "
f"{util.human_bytes(free)} ({pct:.0f}%)")
return "\n".join(lines)
def _wanted(self):
lines = ["**Чего не хватает**", ""]
for svc in (SONARR, RADARR):
n, err = svc.wanted()
lines.append(f"• {svc.name}: {'—' if err else f'{n} позиций'}")
return "\n".join(lines)
def _paths(self):
return ("**Куда класть файлы**\n\n"
"• Jellyfin: `/media/movies`, `/media/series`, `/media/music` (CT 103)\n"
"• Plex: `/opt/plex/media` (CT 116)\n"
"• Музыка: папка музыки (CT 125)\n\n"
"После копирования запустите в Jellyfin «Сканировать библиотеку».")
class PhotoBot(Bot):
name = "photo"
title = "Фото"
room_env = "PHOTO_ROOM"
def register(self):
self.cmd("stats", "сколько снимков, альбомов и людей в Immich")(lambda a: self._stats())
self.cmd("space", "сколько занимает база фото")(lambda a: self._space())
def _stats(self):
c, err = local.ImmichDb().counts()
if err:
return f"Не смог прочитать базу Immich: {err}"
lines = ["**Фотографии**", "",
f"• Снимков: {c['assets']}",
f"• Альбомов: {c['albums']}",
f"• Пользователей: {c['users']}",
"", "Адрес: https://immich.buryans.ru"]
if c["assets"] == 0:
lines.append("\n_Фотографий пока нет._ Загрузите с телефона через приложение Immich — "
"оно само синхронизирует снимки.")
return "\n".join(lines)
def _space(self):
out, err = local.pct_exec(151, ["su", "-", "postgres", "-c",
"psql -d immich_db -tAc \"select pg_size_pretty(pg_database_size('immich_db'))\""])
if err:
return f"Не удалось узнать размер: {err}"
return f"База Immich занимает {out}. Снимки лежат в хранилище рядом с базой."
class BookBot(Bot):
name = "book"
title = "Книги"
room_env = "BOOK_ROOM"
def register(self):
books = local.Books()
self.cmd("stats", "сколько книг в библиотеке")(lambda a: self._stats(books))
self.cmd("new", "последние поступления")(lambda a: self._new(books))
self.cmd("find", "поиск книги: `!find стругацкие`")(lambda a: self._find(books, a))
def _stats(self, books):
c, err = books.counts()
if err:
return f"Библиотека недоступна: {err}"
lines = [f"**Библиотека**\n\n• Книг: {c['books']}\n\nЧитать: https://books.buryans.ru"]
if c["books"] == 0:
lines.append("\n_Книг пока нет._ Добавить: https://books.buryans.ru → "
"«Загрузить книгу», либо положить файлы в каталог библиотеки.")
return "\n".join(lines)
def _new(self, books):
rows, err = books.recent(8)
if err:
return f"Не удалось получить список: {err}"
if not rows:
return "Библиотека пуста."
lines = ["**Новые книги**", ""]
for r in rows:
lines.append(f"• {r['title']} — {r['author']}")
return "\n".join(lines)
def _find(self, books, term):
if not term:
return "Что искать? `!find пелевин`"
rows, err = books.search(term)
if err:
return f"Поиск не сработал: {err}"
if not rows:
return f"По запросу «{term}» ничего нет."
lines = [f"**Книги по «{term}»**", ""]
for r in rows:
lines.append(f"• {r['title']} — {r['author']}")
return "\n".join(lines)
class HomeBot(Bot):
name = "home"
title = "Дом"
room_env = "HOME_ROOM"
def register(self):
self.cmd("stats", "сколько устройств и датчиков в Home Assistant")(lambda a: self._stats())
self.cmd("status", "кратко о состоянии дома")(lambda a: self._status())
def _stats(self):
data, err = local.HomeDb().entities()
if err:
return f"Не смог прочитать реестр HA: {err}"
lines = ["**Дом**", "", f"• Устройств и сущностей: {data['total']}"]
if data["kinds"]:
lines.append("• По типам: " + ", ".join(data["kinds"].split("|")))
lines.append("\nУправление: https://home.buryans.ru")
if data["total"] < 20:
lines.append("\n_Устройств мало._ Добавить: Home Assistant → Настройки → "
"Устройства и службы → «Добавить интеграцию».")
return "\n".join(lines)
def _status(self):
data, err = local.HomeDb().states()
if err:
return f"Не удалось прочитать состояние: {err}"
return (f"**Состояние дома**\n\n• Запомненных состояний: {data['restored']}\n\n"
"Полная картина — на панели: https://home.buryans.ru")
class InfraBot(Bot):
name = "infra"
title = "Инфраструктура"
room_env = "INFRA_ROOM"
def register(self):
prom = Prom()
self.cmd("status", "какие службы живы, а какие нет")(lambda a: self._status(prom))
self.cmd("alerts", "активные тревоги")(lambda a: self._alerts(prom))
self.cmd("disk", "место на дисках")(lambda a: self._disk(prom))
self.cmd("backups", "последние резервные копии")(lambda a: self._backups())
self.cmd("content", "что лежит в библиотеках")(lambda a: self._content())
self.cmd("services", "полный список служб и адресов")(lambda a: self._services())
self.cmd("gaps", "чего не хватает, чтобы всё заработало полностью")(lambda a: self._gaps())
self.cmd("inbox", "пожелания и просьбы, которые собрали боты")(lambda a: self._inbox())
self.cmd("sources", "источники событий и их активность")(lambda a: self._services_cmd(a))
self.cmd("history", "история по сервису: `!history kuma`")(lambda a: self._history_cmd(a))
self.cmd("users", "кто в каких сервисах есть: аудит доступов")(lambda a: self._users_cmd())
def _services_cmd(self, arg):
"""Источники событий: кто сколько присылает и когда последний раз."""
data, err = core_api.services()
if err:
return f"Ядро не ответило: {err}"
items = (data or {}).get("items") or []
if not items:
return "Пока нет ни одного источника событий."
lines = ["**Источники событий**", ""]
for i in items:
last = str(i.get("last_at") or "")[:16]
lines.append(f"• {i['source']}: {i['total']} (за сутки {i.get('last24', 0)}), "
f"последнее {last}")
lines.append("")
lines.append("_Подробнее: `!history <имя>`_")
return "\n".join(lines)
def _history_cmd(self, arg):
"""История по одному сервису."""
name = (arg or "").strip()
if not name:
return "Укажите сервис: `!history kuma`. Список — `!services`."
data, err = core_api.service_history(name, 15)
if err:
return f"Ядро не ответило: {err}"
items = (data or {}).get("items") or []
if not items:
return f"По сервису «{name}» событий нет."
lines = [f"**История: {name}**", ""]
for i in items[:15]:
title = i.get("title") or ""
lines.append(f"• {str(i.get('at'))[:16]} {i.get('type')}"
+ (f" — {title}" if title else ""))
return "\n".join(lines)
def _users_cmd(self):
"""Аудит пользователей: кто где заведён."""
data, err = core_api.get_data("identity", 1)
if err:
return f"Ядро не ответило: {err}"
items = (data or {}).get("items") or []
if not items:
return "Аудит ещё не запускался. Он идёт по понедельникам в 08:00."
payload = items[0].get("payload") or {}
table = payload.get("table") or "нет таблицы"
return ("**Доступы по сервисам**\n\n" + table
+ "\n\n_✓ — аккаунт есть, тире — нет. Обновляется по понедельникам._")
def _status(self, prom):
targets, err = prom.targets()
if err:
return util.human_error(err, "Prometheus")
up = [t for t in targets if t.get("health") == "up"]
down = [t for t in targets if t.get("health") != "up"]
lines = [f"**Службы**: {len(up)} в норме, {len(down)} проблемных", ""]
for t in down[:12]:
job = t["labels"].get("job", "?")
app = t["labels"].get("app", "")
lines.append(f"• ⚠ {job} {app} — {t.get('health')}")
return "\n".join(lines)
def _alerts(self, prom):
alerts, err = prom.alerts()
if err:
return f"Не смог получить тревоги: {err}"
if not alerts:
return "Активных тревог нет."
lines = ["**Тревоги**", ""]
for a in alerts:
lines.append(f"• {a.get('labels', {}).get('alertname')} — {a.get('state')}")
return "\n".join(lines)
def _disk(self, prom):
q = '(node_filesystem_avail_bytes{mountpoint="/"} * 100 / node_filesystem_size_bytes{mountpoint="/"})'
v, err = prom.query(q + " < 15")
if err:
return util.human_error(err, "Служба")
host = catalog.host_df()
lines = ["**Место**", ""]
if host:
lines.append(f"• Узел: {host.split()[3] if len(host.split()) > 3 else '—'} свободно "
f"({host.split()[4] if len(host.split()) > 4 else '—'})")
if v:
lines.append(f"• Узлов с запасом меньше 15%: {int(v)}")
else:
lines.append("• Все узлы имеют больше 15% запаса")
return "\n".join(lines)
def _backups(self):
out, err = local.pct_exec(10, ["sh", "-c", "ls -t /mnt/backups/dump/*.tar.zst 2>/dev/null | head -3"])
if err or not out:
try:
import subprocess
r = subprocess.run(["bash", "-c", "ls -t /mnt/backups/dump/*.tar.zst 2>/dev/null | head -3"],
capture_output=True, text=True, timeout=15)
out = r.stdout.strip()
except Exception:
out = ""
if not out:
return "Свежих архивов не нашёл в /mnt/backups."
lines = ["**Последние архивы**", ""]
for line in out.splitlines():
lines.append(f"• {line.split('/')[-1]}")
return "\n".join(lines)
def _content(self):
c = catalog.content_state()
jf = c.get("jellyfin") or {}
nav = c.get("navidrome") or {}
books = c.get("books") or {}
img = c.get("immich") or {}
ha = c.get("home") or {}
return ("**Что лежит в библиотеках**\n\n"
f"• Фильмы: {jf.get('Movie', 0)}\n"
f"• Сериалы: {jf.get('Series', 0)}\n"
f"• Музыка: {nav.get('tracks', 0)} треков / {nav.get('albums', 0)} альбомов\n"
f"• Книги: {books.get('books', 0)}\n"
f"• Фото: {img.get('assets', 0)}\n"
f"• Дом: {ha.get('total', 0)} сущностей")
def _services(self):
lines = ["**Все службы**", ""]
for name, addr, domain, holds, fill in catalog.SERVICES:
link = f"https://{domain}" if domain and domain != "—" else addr
lines.append(f"• **{name}** — {holds}\n {link} · {addr}")
return "\n".join(lines)
def _inbox(self):
from . import inbox as inbox_mod
s = inbox_mod.stats()
rows = inbox_mod.pending(10)
lines = ["**Входящие**", "",
f"• За сегодня: {s['today']}",
f"• Дней с записями: {s['days']}", ""]
if not rows:
lines.append("_Пожеланий пока нет._ Напишите любому боту в личку — "
"он передаст сюда.")
return "\n".join(lines)
for r in rows:
lines.append(f"• #{r['id']} от {r['from'].split(':')[0]} "
f"через {r['bot']} ({r['at'][11:16]}):\n {r['text'][:200]}")
return "\n".join(lines)
def _system_gaps(self):
"""Чего не хватает системе в целом. Кэш 60 с, проверки параллельно."""
import time as _time
if _GAPS_CACHE["value"] is not None and (_time.time() - _GAPS_CACHE["at"]) < _GAPS_TTL:
return list(_GAPS_CACHE["value"])
import subprocess
from concurrent.futures import ThreadPoolExecutor
def read_env(path, key):
try:
for line in open(path, encoding="utf-8"):
if line.startswith(key + "="):
return line.split("=", 1)[1].strip()
except OSError:
pass
return ""
def check_llm():
if not read_env("/etc/hub-core/llm.env", "LLM_API_KEY"):
return "LLM: нет ключа — боты не понимают свободные фразы"
return None
def check_tg():
if not read_env("/etc/hub-core/telegram.env", "TG_API_ID"):
return "Telegram: нет api_id/api_hash — каналы не читаются"
return None
def check_cams():
try:
data, err = util.get("http://192.168.1.126:5000/api/stats")
cams = len((data or {}).get("cameras") or {}) if not err else -1
if cams == 0:
return "камеры: Frigate работает, но камер нет — нужны RTSP-адреса"
if cams < 0:
return "камеры: Frigate не отвечает"
except Exception:
pass
return None
def check_mqtt():
try:
out = subprocess.run(
["pct", "exec", "106", "--", "docker", "exec", "homeassistant",
"sh", "-c", "grep -c mqtt /config/.storage/core.config_entries || true"],
capture_output=True, text=True, timeout=30)
if (out.stdout or "0").strip() in ("0", ""):
return "Home Assistant: нет интеграции MQTT — Frigate виден только через REST"
except Exception:
pass
return None
def check_storage():
found = []
try:
out = subprocess.run(["pvesm", "status"], capture_output=True, text=True, timeout=30)
for line in out.stdout.splitlines()[1:]:
parts = line.split()
if len(parts) >= 7 and parts[6].endswith("%"):
used = float(parts[6].rstrip("%"))
if used >= 80:
found.append(f"хранилище {parts[0]}: заполнено {used:.0f}%")
except Exception:
pass
return found or None
checks = [check_llm, check_tg, check_cams, check_mqtt, check_storage]
gaps = []
with ThreadPoolExecutor(max_workers=len(checks)) as ex:
for res in ex.map(lambda f: f(), checks):
if not res:
continue
if isinstance(res, list):
gaps.extend(res)
else:
gaps.append(res)
_GAPS_CACHE["at"] = _time.time()
_GAPS_CACHE["value"] = list(gaps)
return gaps
def _gaps(self):
"""Честный список того, что мешает системе работать целиком."""
import time as _t
if _GAPS_FULL["value"] is not None and (_t.time() - _GAPS_FULL["at"]) < _GAPS_TTL:
return _GAPS_FULL["value"]
result = self._gaps_build()
_GAPS_FULL["at"] = _t.time()
_GAPS_FULL["value"] = result
return result
def _gaps_build(self):
c = catalog.content_state()
jf = c.get("jellyfin") or {}
nav = c.get("navidrome") or {}
books = c.get("books") or {}
img = c.get("immich") or {}
ha = c.get("home") or {}
empty = []
problems = []
hints = []
sys_gaps = self._system_gaps()
if (jf.get("Movie", 0) + jf.get("Series", 0)) == 0:
empty.append("медиатека Jellyfin")
hints.append("медиа: положить файлы в `/media/{movies,series}` (CT 103) и запустить сканирование")
if nav.get("tracks", 0) == 0:
empty.append("музыка")
hints.append("музыка: залить альбомы в папку Navidrome (CT 125)")
if books.get("books", 0) == 0:
empty.append("книги")
hints.append("книги: загрузить через books.buryans.ru")
if img.get("assets", 0) == 0:
empty.append("фото Immich")
hints.append("фото: поставить приложение Immich на телефоны, включить автозагрузку")
if ha.get("total", 0) < 20:
hints.append("дом: добавить устройства в Home Assistant")
# загрузчик — без него заявки в Seerr не превращаются в файлы
try:
data, err = util.get(
f"{CFG.sonarr_url}/api/v3/downloadclient",
{"X-Api-Key": CFG.sonarr_key}, ttl=120)
if not err and not data:
problems.append("в Sonarr не настроен клиент загрузки")
hints.append("загрузчик: поставить qBittorrent и подключить его в Sonarr и Radarr")
except Exception:
pass
# Frigate уже развёрнут: реальное состояние проверяет _system_gaps
sys_gaps = self._system_gaps()
lines = ["**Что мешает работать целиком**", ""]
if sys_gaps:
lines.append("**Системные пробелы:**")
lines += [f"• {g}" for g in sys_gaps]
lines.append("")
if problems:
lines.append("**Блокирует:**")
lines += [f"• {p}" for p in problems]
if empty:
lines.append("\n**Пусто:**")
lines += [f"• {e}" for e in empty]
if hints:
lines.append("\n**Что нужно сделать:**")
lines += [f"• {h}" for h in hints]
if not (problems or empty):
lines.append("Всё на месте: блокирующих проблем нет.")
return "\n".join(lines)
class SearchBot(Bot):
name = "search"
title = "Поиск"
room_env = "SEARCH_ROOM"
def register(self):
self.cmd("s", "поиск по всему: `!s дюна`")(lambda a: self._search(a))
self.cmd("index", "что попало в общий индекс и когда он обновлён")(lambda a: self._index())
self.cmd("reindex", "перестроить индекс сейчас")(lambda a: self._reindex())
self.cmd("link", "связи: где встречается одно и то же название")(lambda a: self._link(a))
self.cmd("card", "карточка объекта с историей: `!card 74`")(lambda a: self._card(a))
self.cmd("feed", "последние события системы")(lambda a: self._feed())
def _card(self, eid):
if not eid.strip().isdigit():
return "Нужен номер карточки: `!card 74`. Найти номер — `!s <название>`."
data, err = core_api.card(int(eid))
if err:
return f"Ядро не ответило: {err}"
if not data:
return f"Карточка {eid} не найдена."
c = data.get("card", {})
lines = [f"**{c.get('title')}** ({c.get('kind')})", "",
f"• Ключ: {c.get('key')}",
f"• Статус: {c.get('status') or '—'}",
f"• Обновлено: {(c.get('updated_at') or '')[:16]}"]
links = data.get("links") or []
if links:
lines.append("• Связи: " + ", ".join(f"{l['title']} ({l['kind']})" for l in links))
hist = data.get("history") or []
if hist:
lines.append("")
lines.append("**История**")
for h in hist[:5]:
lines.append(f"• {(h.get('at') or '')[:16]} — {h.get('source')}: {h.get('type')}")
return "\n".join(lines)
def _feed(self):
data, err = core_api.events()
if err:
return f"Ядро не ответило: {err}"
items = (data or {}).get("items") or []
if not items:
return "Событий пока нет."
lines = ["**Последние события**", ""]
for e in items[:10]:
ent = e.get("entity") or {}
title = ent.get("title") if isinstance(ent, dict) else None
lines.append(f"• {(e.get('at') or '')[:16]} {e.get('source')}: {e.get('type')}"
+ (f" — {title}" if title else ""))
return "\n".join(lines)
def _search(self, term):
if not term:
return "Что искать? Например `!s дюна`"
out = [f"**Поиск «{term}»**", ""]
found = False
# сначала ядро — единый источник карточек
core, err = core_api.search(term)
if core and core.get("items"):
found = True
for r in core["items"][:12]:
sub = f" — {r['status']}" if r.get("status") else ""
out.append(f"• [{r['kind']}] {r['title']}{sub} `#{r['id']}`")
out.append("\n_Подробнее о карточке: `!card <номер>`_")
return "\n".join(out)
# затем общий индекс — он знает про все сервисы
rows = index.search(term, 12)
if rows:
found = True
for r in rows:
sub = f" — {r['subtitle']}" if r["subtitle"] else ""
out.append(f"• [{r['kind']}] {r['title']}{sub}\n {r['url']}")
else:
# индекс пуст или не обновлён — спрашиваем живые сервисы
items, err = Jellyfin().search(term, 5)
if items:
found = True
out.append("**Медиа (вживую)**")
for it in items:
out.append(f"• {_fmt_item(it)}")
books, berr = local.Books().search(term, 5)
if books:
found = True
out.append("\n**Книги (вживую)**")
for r in books:
out.append(f"• {r['title']} — {r['author']}")
docs, _ = util.get(
f"{CFG.paperless_url}/api/documents/?query={util.quote(term)}&page_size=5",
{"Authorization": f"Token {CFG.paperless_token}"}, ttl=60)
if docs and docs.get("results"):
found = True
out.append("\n**Документы**")
for d in docs["results"]:
out.append(f"• {d.get('title')}")
if not found:
out.append("Ничего не нашлось. Попробуйте другое слово.")
return "\n".join(out)
def _index(self):
s = index.stats()
lines = ["**Общий индекс**", "",
f"• Записей: {s['total']}",
f"• Обновлён: {s['built_at'] or 'ещё не строился'}"]
if s["kinds"]:
lines.append("• По видам: " + ", ".join(f"{k} — {n}" for k, n in s["kinds"]))
if s["sources"]:
lines.append("• По источникам: " + ", ".join(f"{k} — {n}" for k, n in s["sources"]))
else:
lines.append("\n_Индекс пуст: в сервисах пока нет контента._")
return "\n".join(lines)
def _reindex(self):
report = index.rebuild()
lines = ["**Индекс перестроен**", ""]
for name, r in report.items():
if r.get("error"):
lines.append(f"• {name}: ошибка — {r['error']}")
else:
lines.append(f"• {name}: {r['count']} записей")
return "\n".join(lines)
def _link(self, term):
if not term:
return "Что искать? `!link дюна`"
grouped = index.links(term)
if not grouped:
return f"Связей по «{term}» не нашлось."
lines = [f"**Где встречается «{term}»**", ""]
for kind, items in grouped.items():
lines.append(f"**{kind.capitalize()}**")
for it in items[:6]:
sub = f" — {it['subtitle']}" if it["subtitle"] else ""
lines.append(f"• {it['title']}{sub}")
lines.append("")
return "\n".join(lines)
class DigestBot(Bot):
name = "digest"
title = "Дайджест"
room_env = "DIGEST_ROOM"
def register(self):
self.cmd("digest", "сводка по всем сервисам прямо сейчас")(lambda a: self.build())
self.cmd("map", "карта платформы: что где живёт")(lambda a: self._map())
def build(self):
parts = [f"**Сводка · {datetime.date.today().strftime('%d.%m.%Y')}**", ""]
c = catalog.content_state()
jf = c.get("jellyfin") or {}
parts.append(f"**Медиа**: {jf.get('Movie', 0)} фильмов, {jf.get('Series', 0)} сериалов, "
f"{jf.get('MusicAlbum', 0)} альбомов")
nav = c.get("navidrome") or {}
parts.append(f"**Музыка**: {nav.get('albums', 0)} альбомов, {nav.get('tracks', 0)} треков")
img = c.get("immich") or {}
parts.append(f"**Фото**: {img.get('assets', 0)} снимков в {img.get('albums', 0)} альбомах")
books = c.get("books") or {}
parts.append(f"**Книги**: {books.get('books', 0)}")
ha = c.get("home") or {}
parts.append(f"**Дом**: {ha.get('total', 0)} сущностей")
prom = Prom()
targets, err = prom.targets()
if targets:
down = sum(1 for t in targets if t.get("health") != "up")
parts.append(f"**Службы**: {len(targets) - down} в норме, {down} проблемных")
alerts, _ = prom.alerts()
parts.append(f"**Тревоги**: {len(alerts)} активных")
# заявки в Seerr и состояние индекса
try:
counts, _ = Seerr().counts()
if counts:
parts.append(f"**Заявки**: {counts.get('pending', 0)} в ожидании, "
f"{counts.get('approved', 0)} одобрено, "
f"{counts.get('available', 0)} готово")
except Exception:
pass
try:
s = index.stats()
parts.append(f"**Индекс**: {s['total']} записей "
f"(обновлён {(s['built_at'] or '—')[11:16]})")
except Exception:
pass
return "\n".join(parts)
def _map(self):
lines = ["**Карта платформы**", "", "Один вход: Authentik. Внутри — домены, боты, мониторинг.", ""]
groups = {
"Медиа": ["Jellyfin", "Plex", "Sonarr", "Radarr", "Prowlarr", "Bazarr", "Seerr"],
"Контент": ["Immich", "Calibre-Web", "Paperless", "Home Assistant"],
"Сервисы": ["Nextcloud", "Vaultwarden", "Gitea", "Matrix"],
"Наблюдение": ["Prometheus", "Grafana", "Loki", "Uptime Kuma"],
"Автоматизация": ["n8n", "Node-RED"],
}
by_name = {s[0]: s for s in catalog.SERVICES}
for group, names in groups.items():
lines.append(f"**{group}**")
for n in names:
s = by_name.get(n)
if s:
lines.append(f"• {s[0]} — {s[3]} ({s[2] if s[2] != '—' else s[1]})")
lines.append("")
lines.append("Подробности: `!services` у бота инфраструктуры, состав библиотек — `!content`.")
return "\n".join(lines)
class CamBot(Bot):
name = "cam"
title = "Камеры"
room_env = "CAM_ROOM"
def _cam_scan(self):
"""Найти камеры в сети (порт 554 и другие)."""
import subprocess
try:
out = subprocess.run(['/usr/bin/python3', '/opt/hub-core/camera_discover.py'],
capture_output=True, text=True, timeout=120)
text = (out.stdout or '').strip()
except Exception as e:
return f'Поиск не удался: {str(e)[:100]}'
if not text:
return 'Поиск ничего не вернул.'
lines = text.splitlines()
head = [l for l in lines if l.startswith(('соседей', 'похоже', 'с открытыми'))]
found = [l for l in lines if l.startswith(' ') and 'порты' in l]
res = ['**Поиск камер в сети**', ''] + head
if found:
res += [''] + found[:10]
return '\n'.join(res)
def _cam_status(self):
"""Что известно про камеры: Frigate и последний поиск."""
lines = []
try:
data, err = util.get('http://192.168.1.126:5000/api/stats')
cams = (data or {}).get('cameras') or {}
lines.append(f'**Frigate:** работает, камер {len(cams)}')
for name in list(cams)[:10]:
lines.append(f'• {name}')
except Exception:
lines.append('**Frigate:** не отвечает')
try:
doc, _ = core_api.get_data('cameras', 1)
items = (doc or {}).get('items') or []
if items:
p = items[0].get('payload') or {}
lines.append('')
lines.append(f"**Поиск в сети:** хостов {p.get('hosts')}, "
f"камер {len(p.get('cameras') or [])}")
except Exception:
pass
lines.append('')
lines.append('_Добавить камеру: пришлите rtsp:// адрес и название._')
return '\n'.join(lines)
def register(self):
self.cmd("status", "есть ли подключённый сервер наблюдения")(lambda a: self._status())
self.cmd("scan", "найти камеры в сети")(lambda a: self._cam_scan())
self.cmd("камеры", "что известно про камеры")(lambda a: self._cam_status())
def _status(self):
if not CFG.frigate_url:
return ("**Камеры**\n\n"
"Frigate пока не развёрнут — сервер наблюдения не найден ни в одном контейнере.\n\n"
"Чтобы я начал показывать события, нужно:\n"
"1. Развернуть Frigate (нужны RTSP-адреса камер).\n"
"2. Дать адрес Frigate и его ключ.\n\n"
"После этого здесь появятся: список камер, события движения, "
"детекция людей и машин, ссылки на записи.")
return "Frigate отвечает — уточните, что показать."