Files
buryan-agent 3af6737511 Telegram userbot на втором номере: сервис, CLI и связка с книжным ботом
Второй аккаунт (+79105469668, id 6922233999) авторизован через Telethon
по api_id от mautrix. Работает через прокси CT161 (прямого интернета нет).

Что есть: CLI (whoami/dialogs/find/join/files/save) и HTTP-сервис на 9122
(/health, /files, /save), который скачивает файлы в /opt/books/ingest —
дальше Calibre-Web импортирует сам. В книжном боте появились /tg <запрос>
и /tg скачать N.

Выяснилось: публичные книжные каналы — витрины со ссылками на ботов, файлов
там нет. Нужны каналы, где книги выкладывают файлами, или книжный бот,
которому userbot будет писать запрос.

Ловушка: PowerShell добавляет BOM в файлы — Python падает на U+FEFF.
2026-10-21 11:53:56 +03:00

866 lines
42 KiB
Python
Raw Permalink 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.
#!/usr/bin/env python3
"""
book_bot.py — книжный бот в Matrix.
ЧТО УМЕЕТ:
/find <название> — искать книгу во всех источниках (магазин, каталоги,
архивы, библиотеки) и прислать что нашлось;
/lib <запрос> — поиск по своей библиотеке (что уже есть);
/wanted — список книг, которые ещё не найдены;
/tg <название> — поиск постов в добавленных Telegram-каналах
(через веб-предпросмотр, без аккаунта);
/tgadd <канал> — добавить канал в список для поиска;
/tglist — какие каналы добавлены;
/tgdel <канал> — убрать канал;
/help — помощь.
Работает через long-polling /sync, без внешних библиотек.
"""
import json
import os
import re
import sqlite3
import sys
import time
import urllib.parse
import urllib.request
from datetime import datetime
HS = os.environ.get("MATRIX_HS", "http://192.168.1.155:8008")
TOKEN = os.environ.get("MATRIX_TOKEN", "")
CFG = os.environ.get("BOT_CONFIG", "/app/config.json")
VPN = os.environ.get("VPN_PROXY", "http://192.168.1.161:7890")
LIB_DB = os.environ.get("CALIBRE_DB", "/calibre/metadata.db")
CATALOG_JSON = os.environ.get("CATALOG_JSON", "/app/catalog/polina-library.json")
INGEST = os.environ.get("INGEST_DIR", "/ingest")
UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/155"
ALLOWED = set()
def log(msg):
line = f"[{datetime.now():%Y-%m-%d %H:%M:%S}] {msg}"
print(line, flush=True)
def load_cfg():
try:
with open(CFG, encoding="utf-8") as f:
return json.load(f)
except Exception:
return {"users": [], "tg_channels": []}
def save_cfg(cfg):
with open(CFG, "w", encoding="utf-8") as f:
json.dump(cfg, f, ensure_ascii=False, indent=2)
def api(method, path, body=None):
url = f"{HS}{path}"
sep = "&" if "?" in url else "?"
url += f"{sep}access_token={TOKEN}"
data = json.dumps(body).encode() if body is not None else None
req = urllib.request.Request(url, data=data, method=method,
headers={"Content-Type": "application/json"})
with urllib.request.urlopen(req, timeout=40) as r:
raw = r.read().decode()
return json.loads(raw) if raw else {}
def send(room, text):
tx = str(int(time.time() * 1000))
try:
api("PUT", f"/_matrix/client/v3/rooms/{urllib.parse.quote(room)}"
f"/send/m.room.message/{tx}",
{"msgtype": "m.text", "body": text})
return True
except Exception as e:
log(f"не отправить в {room}: {e}")
return False
def fetch(url, via_vpn=False):
req = urllib.request.Request(url, headers={"User-Agent": UA, "Accept-Language": "ru,en;q=0.8"})
opener = (urllib.request.build_opener(
urllib.request.ProxyHandler({"http": VPN, "https": VPN})) if via_vpn
else urllib.request.build_opener())
try:
with opener.open(req, timeout=30) as r:
return r.read().decode("utf-8", "replace")
except Exception:
return ""
def norm(s):
return re.sub(r"\s+", " ", (s or "").lower()).strip()
# ---------- каталог Полины ----------
def load_catalog():
"""Читает личный каталог: что прочитано, что ждёт, какие серии."""
try:
with open(CATALOG_JSON, encoding="utf-8") as f:
return json.load(f)
except Exception as e:
log(f"каталог не читается: {e}")
return {}
def catalog_books():
return (load_catalog().get("books") or [])
def catalog_series():
return (load_catalog().get("series") or [])
def book_title(b):
return (b.get("title") or "").strip()
def book_author(b):
return (b.get("author") or "").strip()
def is_pending(b):
"""Книга ещё не прочитана — интересна для скачивания."""
status = (b.get("reading_status") or "").lower()
return status not in ("read", "completed_read", "not_interested", "main_line_completed")
def series_for_title(title):
"""Находит серию, в которой прочитана эта книга."""
t = norm(title)
for s in catalog_series():
for rt in (s.get("read_titles") or []):
if norm(rt) and (norm(rt) in t or t in norm(rt)):
return s
return None
def next_of(series):
"""Следующая книга серии (dict или None)."""
n = series.get("next")
return n if isinstance(n, dict) else None
def availability_label(av):
return {
"ru_available": "🇷🇺 есть на русском",
"original_available": "🇬🇧 только оригинал",
"available": "↪ доступно",
"not_available": "❌ пока нет",
}.get((av or "").lower(), av or "")
PENDING_GROUPS = [
("available_unread", "🟡 Доступно, но не прочитано"),
("other_line_available", "↪ Другие линии/пары"),
("waiting_ru", "🇷🇺 Ждём русский перевод"),
("waiting_ru_or_copy", "🇷🇺 Нужна проверка перевода"),
("waiting_release", "🟠 Ждём выхода"),
("caught_up_waiting", "🔴 Прочитано всё, продолжения нет"),
]
def cmd_polina():
data = load_catalog()
if not data:
return "Каталог Полины недоступен."
books = data.get("books") or []
series = data.get("series") or []
summary = data.get("summary") or {}
lines = ["📚 **Каталог Полины**", ""]
lines.append(f"• Прочитано книг: **{len(books)}**")
lines.append(f"• Серий: **{len(series)}**")
if summary.get("read_books_with_series_mapping"):
lines.append(f"• Привязано к сериям: {summary['read_books_with_series_mapping']}")
for status, header in PENDING_GROUPS:
group = [s for s in series if (s.get("personal_status") or "") == status]
if not group:
continue
lines.append("")
lines.append(f"**{header}** ({len(group)}):")
for s in group[:8]:
n = next_of(s)
if n and n.get("title"):
av = availability_label(n.get("availability"))
lines.append(f"• «{s['name']}» → {n['title']}"
+ (f" ({av})" if av else ""))
else:
lines.append(f"• «{s['name']}»")
lines.append("")
lines.append("Скачать: `/скачать название` · похожее: `/похожие название`")
return "\n".join(lines)
def _match_books(query):
"""Ищет книгу в каталоге по названию или автору."""
q = norm(query)
if not q:
return []
exact = [b for b in catalog_books() if q in norm(book_title(b))]
if exact:
return exact
return [b for b in catalog_books() if q in norm(book_author(b))]
def cmd_similar(query):
"""Похожие книги: та же серия, тот же автор, что дальше читать."""
title_hit = [b for b in catalog_books() if norm(query) in norm(book_title(b))]
series = series_for_title(query)
if not series and title_hit:
series = series_for_title(book_title(title_hit[0]))
if not series and not title_hit:
ext = search_openlibrary(query)
if ext:
out = [f"В личном каталоге «{query}» нет.", "",
"🌍 **Похожее из Open Library:**"]
for t, year, url in ext[:5]:
out.append(f"• [{t}]({url})" + (f" — {year}" if year else ""))
return "\n".join(out)
return f"В каталоге Полины нет «{query}» и внешние каталоги молчат."
author = ""
series_name = ""
if series:
series_name = series.get("name") or ""
author = ", ".join(series.get("authors") or [])
elif title_hit:
author = book_author(title_hit[0])
out = [f"📚 **Похожее на «{query}»**" + (f" — {author}" if author else ""), ""]
if series:
read_titles = series.get("read_titles") or []
if read_titles:
out.append(f"✅ **Прочитано в серии «{series_name}»:**")
for t in read_titles[:10]:
out.append(f"• {t}")
out.append("")
n = next_of(series)
if n and n.get("title"):
out.append(f"➡️ **Следующая:** {n['title']} "
f"({availability_label(n.get('availability'))})")
n2 = n.get("next_after")
if isinstance(n2, str):
out.append(f" затем: {n2}")
elif isinstance(n2, dict) and n2.get("title"):
out.append(f" затем: {n2['title']}"
+ (f" — {n2.get('release_date')}" if n2.get("release_date") else ""))
out.append("")
out.append(f"`/скачать {n['title']}`")
out.append("")
if author:
same = [s for s in catalog_series()
if norm(", ".join(s.get("authors") or "")) == norm(author)
and (s.get("name") or "") != series_name]
if same:
out.append(f"✍️ **Другие серии автора ({len(same)}):**")
for s in same[:6]:
n = next_of(s)
tail = f" в†’ {n['title']}" if n and n.get("title") else ""
out.append(f"• «{s['name']}»{tail}")
out.append("")
return "\n".join(out)
# ---------- РїРѕРёСЃРє ----------
def search_library(query):
"""Что уже есть в библиотеке."""
try:
con = sqlite3.connect(f"file:{LIB_DB}?mode=ro", uri=True)
rows = con.execute(
"select b.title, group_concat(a.name, ', ') from books b "
"left join books_authors_link l on l.book=b.id "
"left join authors a on a.id=l.author "
"where lower(b.title) like ? group by b.id limit 8",
(f"%{norm(query)}%",),
).fetchall()
con.close()
return rows
except Exception as e:
log(f"библиотека не читается: {e}")
return []
def search_litres(title):
html = fetch("https://www.litres.ru/search/?q=" + urllib.parse.quote(title))
if not html:
return []
html = html.replace('\\"', '"')
out = []
pat = re.compile(
r'"id":\d+,"uuid":"[^"]*","cover_url":"[^"]*","url":"(/book/[^"]+)","title":"((?:[^"\\]|\\.){1,150})"')
for m in pat.finditer(html):
tail = html[m.end(): m.end() + 900]
price = re.search(r'"final_price":(\d+)', tail)
out.append((m.group(2).strip(), int(price.group(1)) if price else None,
"https://www.litres.ru" + m.group(1)))
if len(out) >= 3:
break
return out
def search_openlibrary(title):
url = "https://openlibrary.org/search.json?" + urllib.parse.urlencode({"title": title, "limit": 3})
raw = fetch(url)
if not raw:
return []
try:
d = json.loads(raw)
except Exception:
return []
out = []
for doc in (d.get("docs") or [])[:3]:
out.append((doc.get("title"), doc.get("first_publish_year"),
"https://openlibrary.org" + (doc.get("key") or "")))
return out
def search_archive(title):
q = f'title:("{title}")'
url = ("https://archive.org/advancedsearch.php?" +
urllib.parse.urlencode({"q": q, "rows": 3, "output": "json",
"fl[]": ["identifier", "title", "year"]}, doseq=True))
raw = fetch(url, via_vpn=True)
if not raw:
return []
try:
d = json.loads(raw)
except Exception:
return []
out = []
for doc in (d.get("response", {}).get("docs") or [])[:3]:
if doc.get("identifier"):
out.append((doc.get("title"), doc.get("year"),
f"https://archive.org/details/{doc['identifier']}"))
return out
def fetch_bytes(url, via_vpn=True, timeout=60):
"""Скачивает файл байтами (для книг, а не страниц)."""
req = urllib.request.Request(url, headers={"User-Agent": UA,
"Accept-Language": "ru,en;q=0.8"})
opener = (urllib.request.build_opener(
urllib.request.ProxyHandler({"http": VPN, "https": VPN})) if via_vpn
else urllib.request.build_opener())
try:
with opener.open(req, timeout=timeout) as r:
data = r.read()
ctype = r.headers.get("Content-Type", "")
return data, ctype
except Exception as e:
log(f"не скачать {url}: {e}")
return b"", ""
def save_to_ingest(data, filename):
"""Кладёт файл в папку автоимпорта Calibre-Web."""
safe = re.sub(r"[^\w\s.\-()Рђ-РЇР°-СЏРЃС‘]", "_", filename).strip()
safe = re.sub(r"\s+", " ", safe)[:120]
if not safe.lower().endswith((".fb2", ".epub", ".pdf", ".mobi")):
safe += ".fb2"
path = os.path.join(INGEST, safe)
try:
os.makedirs(INGEST, exist_ok=True)
with open(path, "wb") as f:
f.write(data)
return path
except Exception as e:
log(f"не сохранить {path}: {e}")
return ""
def title_matches(query, title):
"""Проверяет, что найденная книга действительно та, что искали."""
q = norm(query)
t = norm(title)
if not q or not t:
return False
if q in t or t in q:
return True
tokens = [w for w in re.split(r"[^\wРђ-РЇР°-СЏРЃС‘]+", q) if len(w) > 3]
if not tokens:
return False
hits = sum(1 for w in tokens if w in t)
return hits >= max(1, len(tokens) // 2)
def dl_flibusta(query):
"""Скачивает с зеркала Флибусты (fb2 или epub), проверяя название."""
for host in ("flibusta.site", "flibusta.club"):
html = fetch(f"https://{host}/booksearch?ask=" + urllib.parse.quote(query),
via_vpn=True)
if not html:
continue
candidates = re.findall(r'href="(/b/\d+)"[^>]*>([^<]{2,120})</a>', html)
for path, found_title in candidates[:4]:
page = fetch(f"https://{host}{path}", via_vpn=True)
if not page:
continue
tm = re.search(r'<h1 class="title">([^<]+)</h1>', page)
title = (tm.group(1) if tm else found_title).strip()
title = re.sub(r"\s*\((fb2|epub|mobi)\)\s*$", "", title, flags=re.I)
if not title_matches(query, title):
log(f"флибуста: пропускаю «{title}» — не совпало с «{query}»")
continue
for ext in ("fb2", "epub"):
if f'href="{path}/{ext}"' in page:
data, _ = fetch_bytes(f"https://{host}{path}/{ext}")
if data and len(data) > 2048:
saved = save_to_ingest(data, f"{title}.{ext}")
if saved:
return title, host, ext, saved
return None
def dl_libgen(query):
"""Скачивает с libgen.li: поиск → ads → get.php с ключом."""
html = fetch("https://libgen.li/index.php?req=" + urllib.parse.quote(query),
via_vpn=True)
if not html:
return None
found_titles = re.findall(r'<a href="edition\.php\?id=\d+"[^>]*>([^<]{2,150})</a>', html)
md5s = re.findall(r"md5=([a-f0-9]{32})", html)
if not md5s:
return None
good_title = next((t.strip() for t in found_titles if title_matches(query, t)), None)
if found_titles and not good_title:
log(f"libgen: ни одно название не совпало с «{query}»")
return None
title = good_title or query
for md5 in dict.fromkeys(md5s[:3]):
ads = fetch(f"https://libgen.li/ads.php?md5={md5}", via_vpn=True)
if not ads:
continue
link_m = re.search(r'href="(get\.php\?md5=[a-f0-9]{32}&key=[A-Z0-9]+)"', ads)
if not link_m:
continue
data, ctype = fetch_bytes("https://libgen.li/" + link_m.group(1), timeout=120)
if data and len(data) > 2048:
ext = "fb2"
if "epub" in ctype.lower() or data[:2] == b"PK":
ext = "epub"
elif "pdf" in ctype.lower() or data[:4] == b"%PDF":
ext = "pdf"
saved = save_to_ingest(data, f"{title}.{ext}")
if saved:
return title, "libgen.li", ext, saved
return None
def cmd_download(query):
"""Скачивает книгу в библиотеку (папка автоимпорта)."""
if not query:
return "Что скачать? `/скачать Дюна`"
out = [f"⬇️ Ищу и качаю: **{query}**", ""]
for fn in (dl_flibusta, dl_libgen):
try:
res = fn(query)
except Exception as e:
log(f"скачивание через {fn.__name__}: {e}")
res = None
if res:
title, source, ext, path = res
out.append(f"вњ… **{title}**")
out.append(f"• источник: {source} ({ext})")
out.append(f"• файл: `{os.path.basename(path)}`")
out.append("")
out.append("Книга попала в папку автоимпорта — Calibre-Web "
"добавит её в библиотеку в течение пары минут.")
return "\n".join(out)
out.append("Не удалось скачать автоматически.")
out.append("")
out.append("Попробуйте найти вручную: `/find " + query + "`")
return "\n".join(out)
def search_flibusta(title):
for host in ("flibusta.site", "flibusta.club"):
html = fetch(f"https://{host}/booksearch?ask=" + urllib.parse.quote(title),
via_vpn=True)
if not html:
continue
out = []
for m in re.finditer(r'href="(/b/\d+)"[^>]*>([^<]{2,120})</a>', html):
out.append((m.group(2).strip(), None, f"https://{host}" + m.group(1)))
if len(out) >= 3:
break
if out:
return out
return []
def search_libgen(title):
html = fetch("https://libgen.li/index.php?req=" + urllib.parse.quote(title), via_vpn=True)
if not html:
return []
out = []
for m in re.finditer(r'href="edition\.php\?id=(\d+)"[^>]*>(.{0,300}?)</a>', html, re.S):
raw = re.sub(r"<[^>]+>", " ", m.group(2))
raw = re.sub(r"\s+", " ", raw).strip()
if raw:
out.append((raw[:80], None, f"https://libgen.li/edition.php?id={m.group(1)}"))
if len(out) >= 3:
break
return out
def search_telegram_channels(query, channels):
"""Ищет посты в публичных каналах через веб-предпросмотр."""
out = []
for ch in channels[:5]:
name = ch.lstrip("@").replace("https://t.me/", "").strip("/")
html = fetch(f"https://t.me/s/{name}?q={urllib.parse.quote(query)}", via_vpn=True)
if not html:
continue
posts = re.findall(r'class="tgme_widget_message_text[^"]*"[^>]*>(.*?)</div>', html, re.S)
for p in posts[:2]:
text = re.sub(r"<[^>]+>", " ", p)
text = re.sub(r"\s+", " ", text).strip()
if text:
out.append((name, text[:200], f"https://t.me/{name}"))
if out:
break
return out
def search_all(query, cfg, budget=45):
"""Ищет везде параллельно с общим ограничением по времени."""
from concurrent.futures import ThreadPoolExecutor, as_completed, TimeoutError as FTimeout
jobs = {
"ЛитРес": (search_litres, "цена"),
"Open Library": (search_openlibrary, ""),
"archive.org": (search_archive, "VPN"),
"Флибуста": (search_flibusta, "VPN"),
"libgen": (search_libgen, "VPN"),
}
results = {}
ex = ThreadPoolExecutor(max_workers=5)
futs = {ex.submit(fn, query): name for name, (fn, _) in jobs.items()}
try:
for fut in as_completed(futs, timeout=budget):
name = futs[fut]
try:
results[name] = (fut.result() or [], jobs[name][1])
except Exception:
results[name] = ([], jobs[name][1])
except FTimeout:
for fut, name in futs.items():
if name not in results:
results[name] = ([], jobs[name][1])
finally:
ex.shutdown(wait=False, cancel_futures=True)
return results
def cmd_find(query, cfg):
lines = [f"🔎 Ищу: **{query}**", ""]
lib = search_library(query)
if lib:
lines.append("✅ **Уже есть в вашей библиотеке:**")
for t, a in lib[:5]:
lines.append(f"• {t}" + (f" — {a}" if a else ""))
lines.append("")
found = False
all_res = search_all(query, cfg)
for name, note in (("ЛитРес", "цена"), ("Open Library", ""),
("archive.org", "VPN"), ("Флибуста", "VPN"), ("libgen", "VPN")):
res = all_res.get(name, ([], note))[0]
if res:
found = True
lines.append(f"рџ“љ **{name}**" + (f" ({note})" if note else ""))
for item in res[:3]:
t, extra, url = item
suffix = ""
if name == "ЛитРес" and isinstance(extra, int):
suffix = f" — {extra} ₽"
elif name == "Open Library" and extra:
suffix = f" — {extra} г."
elif extra:
suffix = f" — {extra}"
lines.append(f"• [{t}]({url}){suffix}")
lines.append("")
chans = cfg.get("tg_channels") or []
if chans:
tg = search_telegram_channels(query, chans)
if tg:
found = True
lines.append("📨 **В Telegram-каналах:**")
for ch, text, url in tg[:3]:
lines.append(f"• @{ch}: {text}")
lines.append("")
if not found and not lib:
lines.append("Ничего не нашлось. Попробуйте другое название или "
"добавьте Telegram-канал: `/tgadd @имя`.")
return "\n".join(lines)
def cmd_wanted():
"""Что можно читать дальше — по данным серий."""
series = catalog_series()
if not series:
return "Каталог недоступен."
ready = [s for s in series if (s.get("personal_status") or "") in
("available_unread", "other_line_available")]
out = ["📋 **Можно читать дальше:**", ""]
if not ready:
out.append("Нет доступных непрочитанных книг.")
for s in ready[:20]:
n = next_of(s)
if n and n.get("title"):
out.append(f"• «{s['name']}» → {n['title']} "
f"({availability_label(n.get('availability'))})")
else:
out.append(f"• «{s['name']}»")
out.append("")
out.append("Скачать: `/скачать название`")
return "\n".join(out)
def cmd_tg_add(arg, cfg):
name = arg.lstrip("@").replace("https://t.me/", "").strip("/").strip()
if not name:
return "Укажите канал: `/tgadd @имя_канала`"
chans = cfg.setdefault("tg_channels", [])
if name in chans:
return f"Канал @{name} уже в списке."
chans.append(name)
save_cfg(cfg)
# проверяю, читается ли
ok = bool(fetch(f"https://t.me/s/{name}", via_vpn=True))
return (f"✅ Добавил @{name}." + ("" if ok else "\n⚠️ Не удалось прочитать — проверьте имя."))
# ---------- Telegram через userbot ----------
USERBOT = os.environ.get("USERBOT_URL", "http://192.168.1.10:9122")
TG_LAST = "/tmp/bookbot_tg_last.json"
def tg_files(query):
"""Поиск файлов в Telegram через userbot-сервис."""
raw = fetch(f"{USERBOT}/files?q=" + urllib.parse.quote(query))
if not raw:
return []
try:
d = json.loads(raw)
except Exception:
return []
files = d.get("files") or []
json.dump(files, open(TG_LAST, "w"), ensure_ascii=False)
return files
def cmd_tg_search(query):
if not query:
return "Что искать в Telegram? `/tg название`"
files = tg_files(query)
if not files:
return ("В Telegram ничего не нашлось.\n"
"Добавьте каналы с книгами: `/tgadd` работает только для публичных, "
"а файлы ищутся в чатах, где состоит аккаунт userbot.")
out = [f"📨 **Telegram: {query}**", ""]
for i, f in enumerate(files[:10], start=1):
size = f.get("size") or 0
mb = f"{size / 1024 / 1024:.1f} МБ" if size else ""
out.append(f"{i}. {f['name']} — {f.get('chat_name') or f.get('chat')} {mb}")
out.append("")
out.append("Скачать: `/tg скачать 1`")
return "\n".join(out)
def cmd_tg_save(arg):
try:
n = int((arg or "").strip()) - 1
except ValueError:
return "Укажите номер: `/tg скачать 1`"
try:
files = json.load(open(TG_LAST, encoding="utf-8"))
except Exception:
return "Сначала найдите файл: `/tg название`"
if n < 0 or n >= len(files):
return "Нет такого номера."
f = files[n]
body = json.dumps({"chat": f["chat"], "msg": f["msg"]}).encode()
req = urllib.request.Request(USERBOT + "/save", data=body, method="POST",
headers={"Content-Type": "application/json"})
try:
with urllib.request.urlopen(req, timeout=180) as r:
d = json.loads(r.read() or b"{}")
except Exception as e:
return f"Не удалось скачать: {str(e)[:120]}"
if d.get("saved"):
return (f"✅ Скачано: **{d['saved']}**\n\n"
"Файл в автоимпорте Calibre-Web — появится в библиотеке через пару минут.")
return f"Не удалось: {d.get('error', 'неизвестно')}"
def main():
cfg = load_cfg()
allowed = set(cfg.get("users") or [])
log(f"бот запущен, разрешённых пользователей: {len(allowed)}")
since = None
me = None
try:
me = api("GET", "/_matrix/client/v3/account/whoami")["user_id"]
log(f"я — {me}")
except Exception as e:
log(f"не смог определить себя: {e}")
while True:
try:
params = {"timeout": 25000}
if since:
params["since"] = since
res = api("GET", "/_matrix/client/v3/sync?" + urllib.parse.urlencode(params))
since = res.get("next_batch") or since
log("цикл sync ок")
# приглашения в комнаты — вступаем сразу
for room in (res.get("rooms", {}).get("invite", {}) or {}):
try:
api("POST", f"/_matrix/client/v3/join/{urllib.parse.quote(room)}", {})
log(f"вступил в комнату {room}")
send(room, "📚 Привет! Я книжный бот. Напишите `/help`.")
except Exception as e:
log(f"не смог вступить в {room}: {e}")
for room, data in (res.get("rooms", {}).get("join", {}) or {}).items():
for ev in (data.get("timeline", {}).get("events") or []):
if ev.get("type") != "m.room.message":
continue
sender = ev.get("sender", "")
body = (ev.get("content", {}).get("body") or "").strip()
# терпимый разбор: убираем кавычки/пометки редактора,
# лишние пробелы и приводим команду к нижнему регистру
body = body.strip("`").strip()
body = re.sub(r"^[\s`'\"]+", "", body)
body = re.sub(r"^/\s+", "/", body)
body = re.sub(r"^(\w+)\s*:", "", body) # «/find: Дюна»
if not body:
continue
low = body.lower()
# свободный текст тоже считаем поиском
if not low.startswith("/"):
m_free = re.match(r"^(найди|найти|find|поиск)\s+(.+)$", low)
m_dl = re.match(r"^(скачай|скачать|download|качай)\s+(.+)$", low)
m_sim = re.match(r"^(похожие|похожее|ещё|еще|similar)\s+(.+)$", low)
if m_free:
body = "/find " + body[m_free.start(2):]
low = body.lower()
elif m_dl:
body = "/скачать " + body[m_dl.start(2):]
low = body.lower()
elif m_sim:
body = "/РїРѕС…РѕР¶РёРµ " + body[m_sim.start(2):]
low = body.lower()
else:
continue
if allowed and sender not in allowed:
send(room, "⛔ У вас нет доступа к книжному боту.\n"
f"Ваш адрес: `{sender}` — попросите администратора добавить.")
continue
parts = body.split(maxsplit=1)
cmd = parts[0].lower().replace(" ", "")
if cmd in ("/фind", "/финд", "/поиск", "/найди"):
cmd = "/find"
arg = parts[1].strip() if len(parts) > 1 else ""
log(f"{sender}: {cmd} {arg}")
if cmd in ("/help", "/start"):
reply = (
"📚 **Книжный бот**\n\n"
"**Личное:**\n"
"`/полина` — каталог: что прочитано, что ждёт\n"
"`/похожие название` — что ещё у автора и в серии\n"
"`/скачать название` — скачать книгу в библиотеку\n\n"
"**РџРѕРёСЃРє:**\n"
"`/find название` — искать книгу везде\n"
"`/lib запрос` — что уже есть в библиотеке\n"
"`/wanted` — ещё не прочитано\n\n"
"**Telegram-каналы:**\n"
"`/tgadd @канал`, `/tglist`, `/tgdel @канал`\n\n"
"Бот ищет в ЛитРес, Open Library, archive.org, "
"Флибусте, libgen и в каналах Telegram.\n"
"Скачивает fb2/epub и кладёт в автоимпорт Calibre-Web."
)
elif cmd in ("/полина", "/polina", "/каталог"):
reply = cmd_polina()
elif cmd in ("/похожие", "/similar", "/ещё", "/еще"):
if not arg:
reply = "Что искать? `/похожие Дюна`"
else:
reply = cmd_similar(arg)
elif cmd in ("/скачать", "/download", "/качай"):
if not arg:
reply = "Что скачать? `/скачать Дюна`"
else:
send(room, f"⬇️ Качаю «{arg}», это может занять до минуты…")
reply = cmd_download(arg)
elif cmd == "/tg":
arg_low = arg.lower()
if arg_low.startswith("скачать"):
reply = cmd_tg_save(arg[len("скачать"):].strip())
else:
reply = cmd_tg_search(arg)
elif cmd in ("/tgsave", "/tgскачать"):
reply = cmd_tg_save(arg)
elif cmd == "/find":
if not arg:
reply = "Напишите название: `/find Дюна`"
else:
send(room, f"🔎 Ищу «{arg}», это займёт до минуты…")
reply = cmd_find(arg, cfg)
elif cmd == "/lib":
if not arg:
reply = "Что искать? `/lib Дюна`"
else:
rows = search_library(arg)
reply = ("📖 **В библиотеке:**\n" + "\n".join(
f"• {t}" + (f" — {a}" if a else "") for t, a in rows)) if rows \
else f"В библиотеке нет «{arg}»."
elif cmd in ("/wanted", "/дальше", "/next", "/чточитать"):
reply = cmd_wanted()
elif cmd == "/tgadd":
reply = cmd_tg_add(arg, cfg)
elif cmd == "/tglist":
ch = cfg.get("tg_channels") or []
reply = ("📨 Каналы: " + ", ".join("@" + c for c in ch)) if ch else "Список пуст. `/tgadd @канал`"
elif cmd == "/tgdel":
name = arg.lstrip("@").strip()
ch = cfg.get("tg_channels") or []
if name in ch:
ch.remove(name)
save_cfg(cfg)
reply = f"Убрал @{name}."
else:
reply = f"@{name} нет в списке."
else:
reply = "Не знаю такой команды. `/help`"
send(room, reply)
except Exception as e:
log(f"ошибка цикла: {e}")
time.sleep(5)
if __name__ == "__main__":
main()