ОТВЕТ НА ВОПРОС: да, из закрытых каналов доставать можно, но НЕ ботом.
Обычный бот не читает историю каналов и его нельзя добавить в закрытый
канал. Нужен юзербот — программа под вашим аккаунтом.
БЕЗОПАСНОСТЬ, честно:
* Telegram может ограничить аккаунт за автоматизацию — риск умеренный
при аккуратной работе (пауза 3 с, лимит размера, никакой отправки);
* файл сессии = полный доступ к аккаунту — права 600, только на
сервере, не в облачных копиях;
* ГЛАВНАЯ РЕКОМЕНДАЦИЯ: отдельный аккаунт под книги, тогда основной
не участвует.
СОБРАНО: контейнер telegram-books с Telethon. Читает только указанные
каналы, ничего не отправляет, качает epub/fb2/pdf/mobi/azw3/djvu/zip,
помнит скачанное (не дублирует), пережидает FloodWait, складывает файлы
в папку приёма библиотеки (книги появляются в каталоге сами), проверяет
каналы по расписанию.
НУЖНО ОТ ВЛАДЕЛЬЦА: api_id и api_hash с my.telegram.org, список каналов,
однократный ввод кода из Telegram.
Добавлена оговорка про авторские права: механизм нейтрален, но
ответственность за содержимое на пользователе.
216 lines
7.1 KiB
Python
216 lines
7.1 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
fetcher.py — загрузка книг из Telegram-каналов в библиотеку.
|
||
|
||
СХЕМА РАБОТЫ:
|
||
* вход под вашим аккаунтом (сессия Telethon), права те же, что у вас;
|
||
* читает ТОЛЬКО указанные каналы, ничего не отправляет и не пишет;
|
||
* скачивает документы нужных форматов в папку приёма библиотеки;
|
||
* ведёт учёт: что уже скачано, чтобы не качать дважды;
|
||
* при ограничении Telegram (FloodWait) ждёт и продолжает.
|
||
|
||
БЕЗОПАСНОСТЬ:
|
||
* файл сессии даёт полный доступ к аккаунту — он лежит с правами 600
|
||
и не должен попадать в облачные копии;
|
||
* лучше использовать ОТДЕЛЬНЫЙ аккаунт (второй номер), а не основной;
|
||
* ограничение скорости — чтобы не выглядеть как массовая выкачка.
|
||
"""
|
||
import asyncio
|
||
import hashlib
|
||
import json
|
||
import os
|
||
import re
|
||
import sqlite3
|
||
import sys
|
||
import time
|
||
from datetime import datetime, timezone
|
||
from pathlib import Path
|
||
|
||
import yaml
|
||
from telethon import TelegramClient
|
||
from telethon.errors import FloodWaitError, RPCError
|
||
from telethon.tl.types import DocumentAttributeFilename
|
||
|
||
BASE = Path("/app")
|
||
CONFIG = BASE / "config.yaml"
|
||
STATE = BASE / "state.db"
|
||
SESSION = BASE / "session" / "books"
|
||
|
||
ALLOWED = {".epub", ".fb2", ".pdf", ".mobi", ".azw3", ".djvu", ".zip", ".fb2.zip"}
|
||
|
||
|
||
def log(msg: str) -> None:
|
||
ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
|
||
line = f"[{ts}] {msg}"
|
||
print(line, flush=True)
|
||
try:
|
||
with open(BASE / "fetcher.log", "a", encoding="utf-8") as f:
|
||
f.write(line + "\n")
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
def load_config() -> dict:
|
||
with open(CONFIG, encoding="utf-8") as f:
|
||
return yaml.safe_load(f)
|
||
|
||
|
||
def init_state() -> sqlite3.Connection:
|
||
con = sqlite3.connect(STATE)
|
||
con.execute(
|
||
"""create table if not exists downloaded (
|
||
key text primary key,
|
||
channel text,
|
||
message_id integer,
|
||
filename text,
|
||
size integer,
|
||
added text
|
||
)"""
|
||
)
|
||
con.execute(
|
||
"""create table if not exists channel_state (
|
||
channel text primary key,
|
||
last_message_id integer,
|
||
updated text
|
||
)"""
|
||
)
|
||
con.commit()
|
||
return con
|
||
|
||
|
||
def already(con: sqlite3.Connection, key: str) -> bool:
|
||
return con.execute("select 1 from downloaded where key=?", (key,)).fetchone() is not None
|
||
|
||
|
||
def mark(con: sqlite3.Connection, key: str, channel: str, mid: int, name: str, size: int) -> None:
|
||
con.execute(
|
||
"insert or replace into downloaded(key,channel,message_id,filename,size,added) values(?,?,?,?,?,?)",
|
||
(key, channel, mid, name, size, datetime.now(timezone.utc).isoformat()),
|
||
)
|
||
con.commit()
|
||
|
||
|
||
def safe_name(name: str) -> str:
|
||
name = re.sub(r"[\\/:*?\"<>|]+", "_", name).strip()
|
||
name = re.sub(r"\s+", " ", name)
|
||
return name[:180] or "book"
|
||
|
||
|
||
def file_name_of(message) -> str:
|
||
if message.document:
|
||
for attr in message.document.attributes:
|
||
if isinstance(attr, DocumentAttributeFilename):
|
||
return attr.file_name or ""
|
||
return ""
|
||
|
||
|
||
def pick_document(message):
|
||
if not message.document:
|
||
return None
|
||
name = file_name_of(message).lower()
|
||
if not name:
|
||
return None
|
||
if any(name.endswith(ext) for ext in ALLOWED):
|
||
return message.document
|
||
return None
|
||
|
||
|
||
async def process_channel(client: TelegramClient, con: sqlite3.Connection, cfg: dict, channel: str) -> int:
|
||
dest = Path(cfg["destination"])
|
||
dest.mkdir(parents=True, exist_ok=True)
|
||
limit = int(cfg.get("max_file_mb", 150)) * 1024 * 1024
|
||
pause = float(cfg.get("pause_seconds", 3))
|
||
first_run_limit = int(cfg.get("first_run_messages", 300))
|
||
|
||
row = con.execute("select last_message_id from channel_state where channel=?", (channel,)).fetchone()
|
||
last_id = row[0] if row else 0
|
||
got = 0
|
||
|
||
try:
|
||
entity = await client.get_entity(channel)
|
||
except RPCError as e:
|
||
log(f"не удалось открыть канал {channel}: {e}")
|
||
return 0
|
||
|
||
messages = []
|
||
async for msg in client.iter_messages(entity, limit=first_run_limit if last_id == 0 else None,
|
||
min_id=last_id, reverse=True):
|
||
messages.append(msg)
|
||
|
||
log(f"{channel}: сообщений к обработке {len(messages)}")
|
||
|
||
for msg in messages:
|
||
doc = pick_document(msg)
|
||
if doc is None:
|
||
continue
|
||
size = doc.size or 0
|
||
if size > limit:
|
||
log(f"пропуск (большой файл {size // 1024 // 1024} МБ): {file_name_of(msg)}")
|
||
continue
|
||
|
||
name = safe_name(file_name_of(msg))
|
||
key = hashlib.sha1(f"{channel}:{msg.id}:{name}".encode()).hexdigest()
|
||
if already(con, key):
|
||
continue
|
||
|
||
target = dest / name
|
||
if target.exists():
|
||
mark(con, key, channel, msg.id, name, size)
|
||
continue
|
||
|
||
try:
|
||
await client.download_media(msg, file=str(target))
|
||
mark(con, key, channel, msg.id, name, size)
|
||
got += 1
|
||
log(f"скачано: {name} ({size // 1024} КБ)")
|
||
except FloodWaitError as e:
|
||
wait = int(getattr(e, "seconds", 60)) + 5
|
||
log(f"ограничение Telegram, ждём {wait} с")
|
||
await asyncio.sleep(wait)
|
||
except Exception as e:
|
||
log(f"ошибка при скачивании {name}: {e}")
|
||
|
||
con.execute(
|
||
"insert or replace into channel_state(channel,last_message_id,updated) values(?,?,?)",
|
||
(channel, msg.id, datetime.now(timezone.utc).isoformat()),
|
||
)
|
||
con.commit()
|
||
await asyncio.sleep(pause)
|
||
|
||
if messages:
|
||
con.execute(
|
||
"insert or replace into channel_state(channel,last_message_id,updated) values(?,?,?)",
|
||
(channel, messages[-1].id, datetime.now(timezone.utc).isoformat()),
|
||
)
|
||
con.commit()
|
||
return got
|
||
|
||
|
||
async def main() -> None:
|
||
cfg = load_config()
|
||
con = init_state()
|
||
|
||
client = TelegramClient(str(SESSION), int(cfg["api_id"]), cfg["api_hash"])
|
||
await client.start()
|
||
me = await client.get_me()
|
||
log(f"вход выполнен: {me.first_name or ''} @{me.username or me.id}")
|
||
|
||
channels = cfg.get("channels") or []
|
||
if not channels:
|
||
log("в настройках нет каналов — нечего делать")
|
||
await client.disconnect()
|
||
return
|
||
|
||
total = 0
|
||
for ch in channels:
|
||
try:
|
||
total += await process_channel(client, con, cfg, ch)
|
||
except Exception as e:
|
||
log(f"канал {ch}: ошибка {e}")
|
||
log(f"итого скачано: {total}")
|
||
await client.disconnect()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
asyncio.run(main())
|