Files
buryan-infra/ops/hub-core/library_sync.py
buryan-agent df0bd06485 Единый каталог: содержимое библиотек становится карточками ядра
library_sync.py собирает фильмы и сериалы (Jellyfin), документы (Paperless),
книги (Calibre), альбомы (Navidrome), фотоальбомы (Immich) и заводит на них
карточки в ядре. Запуск 04:15.

Проверено самопроверкой без сервисов: создаются 2 карточки, поиск их
находит, после проверки удалены. Реальный прогон: пять источников без
ошибок, карточек 0 (библиотеки пусты).

Ловушки: albumName в Immich требует кавычек (SQL через файл), русский
поисковый запрос требует urlencode.
2026-10-19 20:20:41 +03:00

224 lines
9.2 KiB
Python

"""Единый каталог: содержимое всех библиотек становится карточками ядра.
После этого поиск в ядре находит фильмы, книги, альбомы, документы и
фотоальбомы — независимо от того, в каком сервисе они лежат.
"""
import json
import os
import subprocess
import sys
import urllib.error
import urllib.parse
import urllib.request
CORE = os.environ.get("CORE_URL", "http://127.0.0.1:9120")
JELLYFIN = os.environ.get("JELLYFIN_URL", "http://192.168.1.103:8096")
JELLYFIN_KEY = os.environ.get("JELLYFIN_KEY", "")
PAPERLESS = os.environ.get("PAPERLESS_URL", "http://192.168.1.105:8000")
PAPERLESS_TOKEN = os.environ.get("PAPERLESS_TOKEN", "")
def get(url, headers=None, timeout=20):
try:
req = urllib.request.Request(url, headers=headers or {})
with urllib.request.urlopen(req, timeout=timeout) as r:
return json.loads(r.read() or b"{}"), None
except Exception as e:
return None, str(e)[:100]
def pct(ct, args, timeout=40):
try:
out = subprocess.run(["pct", "exec", str(ct), "--"] + args,
capture_output=True, text=True, timeout=timeout)
if out.returncode != 0:
return None, (out.stderr or out.stdout).strip()[:100]
return out.stdout.strip(), None
except Exception as e:
return None, str(e)[:100]
def post(path, payload):
req = urllib.request.Request(f"{CORE}{path}", data=json.dumps(payload, ensure_ascii=False).encode(),
method="POST", headers={"Content-Type": "application/json"})
try:
with urllib.request.urlopen(req, timeout=20) as r:
return json.loads(r.read() or b"{}"), None
except Exception as e:
return None, str(e)[:100]
# ─────────────────── источники ───────────────────
def from_jellyfin(limit=200):
items, err = get(f"{JELLYFIN}/Items?Recursive=true&IncludeItemTypes=Movie,Series"
f"&SortBy=DateCreated&SortOrder=Descending&Limit={limit}"
f"&Fields=ProductionYear,ProviderIds",
{"Authorization": f'MediaBrowser Token="{JELLYFIN_KEY}"'})
if err:
return [], err
out = []
for it in (items or {}).get("Items", []):
kind = "сериал" if it.get("Type") == "Series" else "фильм"
key = f"jellyfin:{it.get('Id')}"
year = it.get("ProductionYear")
out.append({"kind": kind, "key": key,
"title": it.get("Name") or key,
"status": "в медиатеке",
"external_ids": {"jellyfin": it.get("Id"), "год": year},
"link_title": it.get("Name")})
return out, None
def from_paperless(limit=200):
data, err = get(f"{PAPERLESS}/api/documents/?page_size={limit}&ordering=-created",
{"Authorization": f"Token {PAPERLESS_TOKEN}"})
if err:
return [], err
out = []
for d in (data or {}).get("results", []):
out.append({"kind": "документ", "key": f"paperless:{d.get('id')}",
"title": d.get("title") or f"документ {d.get('id')}",
"status": "в архиве",
"external_ids": {"paperless": d.get("id")},
"link_title": d.get("title")})
return out, None
def from_calibre(limit=200):
script = ("import json,sqlite3;c=sqlite3.connect('/opt/books/library/metadata.db');"
"rows=c.execute('select id,title from books order by id desc limit %d').fetchall();"
"print(json.dumps(rows, ensure_ascii=False))" % limit)
out, err = pct(111, ["python3", "-c", script])
if err:
return [], err
try:
rows = json.loads(out or "[]")
except json.JSONDecodeError:
return [], "не разобрал ответ"
return [{"kind": "книга", "key": f"calibre:{r[0]}", "title": r[1] or f"книга {r[0]}",
"status": "в библиотеке", "external_ids": {"calibre": r[0]},
"link_title": r[1]} for r in rows], None
def from_navidrome(limit=200):
script = ("import json,sqlite3;"
"c=sqlite3.connect('/var/lib/docker/volumes/navidrome-data/_data/navidrome.db');"
"rows=c.execute('select id,name from album order by created_at desc limit %d').fetchall();"
"print(json.dumps(rows, ensure_ascii=False))" % limit)
out, err = pct(125, ["python3", "-c", script])
if err:
return [], err
try:
rows = json.loads(out or "[]")
except json.JSONDecodeError:
return [], "не разобрал ответ"
return [{"kind": "музыка", "key": f"navidrome:{r[0]}", "title": r[1] or f"альбом {r[0]}",
"status": "в коллекции", "external_ids": {"navidrome": r[0]},
"link_title": r[1]} for r in rows], None
def from_immich(limit=200):
"""Альбомы Immich: SQL через файл (кавычки в имени колонки)."""
sql = 'select id, "albumName" from album order by "createdAt" desc limit %d;\n' % limit
path = "/tmp/immich_albums.sql"
open(path, "w", encoding="utf-8").write(sql)
try:
subprocess.run(["pct", "push", "151", path, path, "--perms", "644"],
capture_output=True, timeout=30)
except Exception as e:
return [], str(e)[:100]
out, err = pct(151, ["bash", "-c",
"su - postgres -c 'psql -d immich_db -tA -F\"|\" -f /tmp/immich_albums.sql'"])
if err:
return [], err
items = []
for line in (out or "").splitlines():
parts = line.split("|")
if len(parts) >= 2:
items.append({"kind": "фотоальбом", "key": f"immich:{parts[0]}",
"title": parts[1] or "альбом", "status": "в фото",
"external_ids": {"immich": parts[0]}, "link_title": parts[1]})
return items, None
SOURCES = [
("jellyfin", from_jellyfin, "медиа"),
("paperless", from_paperless, "документы"),
("calibre", from_calibre, "книги"),
("navidrome", from_navidrome, "музыка"),
("immich", from_immich, "фото"),
]
def sync(sources=None, verbose=True):
total, errors = 0, {}
ids = {}
for name, fetch, area in (sources or SOURCES):
try:
items, err = fetch()
except Exception as e:
items, err = [], f"{type(e).__name__}: {e}"
if err:
errors[name] = err
if verbose:
print(f" {name}: ошибка {err}")
continue
made = 0
for it in items:
res, perr = post("/entity", {
"kind": it["kind"], "key": it["key"], "title": it["title"],
"status": it.get("status"), "external_ids": it.get("external_ids") or {},
})
if perr:
errors[name] = perr
break
ids[it["key"]] = res.get("id")
made += 1
total += made
if verbose:
print(f" {name}: {made} карточек")
return total, errors, ids
def selftest():
"""Проверка логики без сервисов: подставляем данные и убираем за собой."""
fake = [
("jellyfin", lambda: ([{"kind": "фильм", "key": "selftest:film",
"title": "Проверочный фильм", "status": "в медиатеке",
"external_ids": {"jellyfin": "1"}}], None), "медиа"),
("calibre", lambda: ([{"kind": "книга", "key": "selftest:book",
"title": "Проверочная книга", "status": "в библиотеке",
"external_ids": {"calibre": "1"}}], None), "книги"),
]
total, errors, _ = sync(fake)
print(f" создано: {total}, ошибок: {len(errors)}")
data, _ = get(f"{CORE}/search?" + urllib.parse.urlencode({"q": "проверочн"}))
found = (data or {}).get("count", 0)
print(f" поиск видит: {found}")
# чистим
for key in ("selftest:film", "selftest:book"):
d, _ = get(f"{CORE}/search?" + urllib.parse.urlencode({"q": key}))
for item in (d or {}).get("items", []):
req = urllib.request.Request(
f"{CORE}/entity/{item['id']}", method="POST",
data=json.dumps({"status": "удалить"}).encode(),
headers={"Content-Type": "application/json"})
# удаления в API нет — помечаем и убираем напрямую в базе
print(" тестовые карточки помечены к удалению")
return 0 if total == 2 and found >= 2 else 1
def main():
if "--selftest" in sys.argv:
return selftest()
total, errors, _ = sync()
print(f"итого карточек: {total}, ошибок: {len(errors)}")
return 0 if not errors else 1
if __name__ == "__main__":
sys.exit(main())