Files
buryan-infra/ops/bots/hub/bots.py
T
buryan-agent ea5a211d7e Сезоны и эпизоды в графе, график десятилетий на панели
Сериалы разложены до сезонов: сериал → сезон «содержит» с числом эпизодов,
сезон → эпоха. Данные из Sonarr (/api/v3/episode?seriesId), агрегация по
номеру сезона. 19 сезонных карточек, граф 486/530.

Команда «сезоны Foundation» и GET /seasons. На панели — график
«фантастика по десятилетиям» с полосками.

Ловушка: выходящие сериалы дают неполные сезоны (Foundation, сезон 4 —
1 эпизод), из-за чего счётчик сезонов завышен.
2026-10-20 12:45:11 +03:00

1303 lines
60 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 _seasons_cmd(self, arg):
name = (arg or "").strip()
if not name:
return "Укажите сериал: !сезоны Foundation"
data, err = core_api.seasons(name)
if err:
return "Ядро не ответило: " + str(err)
if not data:
return "Сериал не нашёл."
series = data.get("series") or {}
seasons = data.get("seasons") or []
lines = ["**" + str(series.get("title")) + "** — сезонов: " + str(len(seasons)), ""]
for s in seasons:
lines.append("• " + str(s.get("title")) + " — " + str(s.get("status")))
if not seasons:
lines.append("_сезонов нет_")
return chr(10).join(lines)
def _together_cmd(self, arg):
name = (arg or "").strip()
if not name:
return "Укажите имя: !вместе Zendaya"
data, err = core_api.coworkers(name)
if err:
return "Ядро не ответило: " + str(err)
if not data:
return "Не нашёл такую персону."
person = data.get("person") or {}
partners = data.get("partners") or []
lines = ["**" + str(person.get("title")) + "** — вместе работали: " + str(len(partners)), ""]
for x in partners[:12]:
films = (x.get("films") or "")[:50]
lines.append("• " + str(x.get("title")) + " (" + str(x.get("kind")) + ") — " +
str(x.get("together")) + " · " + films)
if not partners:
lines.append("_общих фильмов нет_")
return chr(10).join(lines)
def _fill_cmd(self, arg):
"""Пополнить медиатеку кандидатами (метаданные, без скачивания)."""
import json as _json
import urllib.request as _rq
import os as _os
try:
count = int((arg or "3").strip().split()[0])
except (ValueError, IndexError):
count = 3
count = max(1, min(count, 10))
data, err = core_api.candidates(limit=count)
if err:
return "Ядро не ответило: " + str(err)
items = (data or {}).get("items") or []
if not items:
return "Кандидатов нет: сначала нужны фильмы в медиатеке."
radarr = _os.environ.get("RADARR_URL", "http://192.168.1.118:7878")
key = _os.environ.get("RADARR_KEY", "")
if not key:
return "Нет ключа Radarr."
added, failed = [], []
for it in items:
tmdb = it.get("tmdb")
if not tmdb or not str(tmdb).isdigit():
failed.append(it.get("title"))
continue
title = (it.get("title") or "").split(" (")[0]
body = _json.dumps({
"tmdbId": int(tmdb), "title": title,
"qualityProfileId": 1, "rootFolderPath": "/data/movies",
"monitored": True, "addOptions": {"searchForMovie": False},
}).encode()
req = _rq.Request(radarr + "/api/v3/movie", data=body, method="POST",
headers={"X-Api-Key": key, "Content-Type": "application/json"})
try:
with _rq.urlopen(req, timeout=60):
added.append(title)
try:
core_api.post_entity({
"kind": "фильм", "key": "tmdb:" + str(tmdb),
"title": it.get("title"), "status": "добавлен в Radarr"})
except Exception:
pass
except Exception as e:
if "already" in str(e).lower() or "400" in str(e):
failed.append(title + " (уже есть)")
else:
failed.append(title)
lines = ["**Пополнение медиатеки**", ""]
if added:
lines.append("Добавлено в Radarr (без скачивания):")
for a in added:
lines.append("• " + a)
if failed:
lines.append("")
lines.append("Не добавлено: " + ", ".join(failed[:5]))
lines.append("")
lines.append("_Файлы не скачивались: только карточки. Поиск можно запустить отдельно._")
return chr(10).join(lines)
def _mood_cmd(self, arg):
word = (arg or "").strip()
if not word:
return ("Укажите настроение: !настроение мрачное, лёгкое, умное, "
"эпичное, страшное, доброе")
data, err = core_api.mood(word)
if err:
return "Ядро не ответило: " + str(err)
items = (data or {}).get("items") or []
if not items:
hints = (data or {}).get("hints") or []
return ("Под это настроение ничего не нашлось. Искал по темам: "
+ ", ".join(hints[:5]) if hints else "Не понял настроение.")
lines = ["**Настроение: " + word + "** — " + str(len(items)), ""]
for i in items:
parts = [str(i.get("title"))]
if i.get("rating"):
parts.append(str(i.get("rating")))
lines.append("• " + " — ".join(parts))
return chr(10).join(lines)
def _agent_cmd(self, arg):
"""Агент: понимает фразу и выполняет запрос по графу."""
from . import agent as graph_agent
text = (arg or "").strip()
if not text:
return ("Я агент по медиатеке. Спросите словами:\n"
"• найди фильмы Нолана про космос\n"
"• когда были фильмы про искусственный интеллект\n"
"• фильмография Кеану Ривза\n"
"• сравни «Дюна» и «Дюна»")
try:
answer, plan = graph_agent.run(text)
except Exception as e:
return "Агент сломался: " + str(e)[:120]
try:
steps = graph_agent.describe(plan)
except Exception:
steps = ""
if steps:
return answer + chr(10) + chr(10) + "_понял так: " + steps + "_"
return answer
def _timeline_cmd(self, arg):
term = (arg or "").strip()
if not term:
return "Укажите тему или жанр: !время science fiction"
for kind in ("тема", "жанр"):
data, err = core_api.timeline(term, kind)
if err or not data:
continue
node = data.get("node") or {}
decades = data.get("decades") or []
lines = ["**" + str(node.get("title")) + " по десятилетиям**", ""]
for d in decades:
lines.append("• " + str(d.get("decade")) + " — " + str(d.get("n")) +
": " + str(d.get("items"))[:120])
if not decades:
lines.append("_по десятилетиям не разложилось_")
return chr(10).join(lines)
return "«" + term + "» в графе нет."
def _cross_cmd(self):
data, err = core_api.cross_format()
if err:
return "Ядро не ответило: " + str(err)
books = (data or {}).get("books_with_film") or []
authors = (data or {}).get("authors_screened") or []
lines = ["**Книги и их экранизации в медиатеке**", ""]
if books:
for b in books[:10]:
lines.append("• " + str(b.get("book")) + " ↔ " + str(b.get("film")))
else:
lines.append("_совпадений по названию нет_")
if authors:
lines.append("")
lines.append("**Авторы, чьи книги экранизированы**")
for a in authors[:10]:
lines.append("• " + str(a.get("author")) + " → " + str(a.get("film")))
return chr(10).join(lines)
def _persons_cmd(self, arg):
kind = "режиссёр" if "реж" in (arg or "").lower() else "актёр"
data, err = core_api.top_persons(kind)
if err:
return "Ядро не ответило: " + str(err)
items = (data or {}).get("items") or []
if not items:
return "Персон пока нет в графе."
lines = ["**" + kind.capitalize() + "ы: у кого больше фильмов**", ""]
for i in items[:12]:
lines.append("• " + str(i.get("title")) + " — " + str(i.get("films")))
return chr(10).join(lines)
def _graph_cmd(self, arg):
token = (arg or "").strip().lower()
if token and token not in ("граф", "stats", "статистика"):
return self._graph_lookup(token)
data, err = core_api.graph_stats()
if err:
return "Ядро не ответило: " + str(err)
cards = (data or {}).get("cards") or []
rels = (data or {}).get("relations") or []
lines = ["**Граф контента: " + str((data or {}).get("total_cards")) + " карточек, " +
str((data or {}).get("total_links")) + " связей**", ""]
lines.append("Карточки:")
for c in cards[:10]:
if c.get("kind") in ("монитор", "устройство", "тревога", "бэкап", "аудит", "проверка"):
continue
lines.append("• " + str(c.get("kind")) + ": " + str(c.get("n")))
lines.append("")
lines.append("Связи:")
for r in rels[:10]:
lines.append("• " + str(r.get("relation")) + ": " + str(r.get("n")))
hist, _ = core_api.history(30)
growth = (hist or {}).get("growth")
if growth:
lines.append("")
lines.append("_рост за период: карточек " + str(growth.get("cards")) +
", связей " + str(growth.get("links")) + "_")
return chr(10).join(lines)
def _graph_lookup(self, term):
card, err = core_api.find_entity(term)
if err or not card:
return "«" + term + "» в графе нет. Просто !граф — общая статистика."
data, _ = core_api.links_of(card["id"])
links = (data or {}).get("links") or []
lines = ["**" + str(card.get("title")) + "** (" + str(card.get("kind")) + "), связей: " +
str(len(links)), ""]
for l in links[:15]:
lines.append("• " + str(l.get("relation")) + ": " + str(l.get("title")))
return chr(10).join(lines)
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()
kind = "сериал" if ("сериал" in text.lower()) else "фильм"
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, kind=kind, **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()
low = name.lower()
# «персоны режиссёры» — это запрос списка, а не имя
if any(w in low for w in ("режисс", "актёр", "актер", "композитор", "все ")):
return self._persons_cmd(name)
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()
term = term[3:] if term.lower().startswith("на ") else term
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 _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))
self.cmd("время", "тема по десятилетиям: !время science fiction")(lambda a: self._timeline_cmd(a))
self.cmd("кросс", "книги и их экранизации в медиатеке")(lambda a: self._cross_cmd())
self.cmd("персоны", "у кого больше фильмов: !персоны режиссёры")(lambda a: self._persons_cmd(a))
self.cmd("граф", "статистика графа: !граф")(lambda a: self._graph_cmd(a))
self.cmd("агент", "спросить агента словами: !агент найди фильмы Нолана")(lambda a: self._agent_cmd(a))
self.cmd("настроение", "подбор по настроению: !настроение мрачное")(lambda a: self._mood_cmd(a))
self.cmd("пополнить", "добавить кандидатов в медиатеку: !пополнить 3")(lambda a: self._fill_cmd(a))
self.cmd("вместе", "с кем снимался: !вместе Zendaya")(lambda a: self._together_cmd(a))
self.cmd("сезоны", "сезоны сериала: !сезоны Foundation")(lambda a: self._seasons_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:
try:
from . import agent as graph_agent
answer, plan = graph_agent.run(term)
low = (answer or "").lower()
if answer and "ничего нет" not in low and "не нашёл" not in low:
return (answer + chr(10) + chr(10) + "_в файлах нет, искал по графу: "
+ graph_agent.describe(plan) + "_")
except Exception:
pass
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 отвечает — уточните, что показать."