647 lines
25 KiB
Python
647 lines
25 KiB
Python
"""Telegram-бот поверх парсера: лента, абузы, источники, прогон, автодобавление.
|
||
|
||
Запуск: OMNI_BOT_TOKEN=... python -m omni.bot
|
||
Доступ: OMNI_BOT_OWNERS=<id>,<id> (пусто = read-only: /new /abuse /find /src /stats /tag)
|
||
|
||
Бот не постит никуда сам: только отвечает в личный чат тем, кто в списке.
|
||
Команды:
|
||
/new [n] последние записи
|
||
/abuse [тег] абузы: promo trial keys leak tool resale
|
||
/find <текст> поиск по базе
|
||
/src <текст> поиск источника
|
||
/add <url> добавить источник (сначала реальная проверка фида)
|
||
/run <категория> прогнать категорию
|
||
/auto [n] автодобавление новых фидов
|
||
/sub [@канал] подписать чат/канал на новые абузы
|
||
/unsub [@канал] отписаться
|
||
/post [@канал] опубликовать абузы сейчас\n /sum [тег] ИИ-саммари подборки\n /tr <id|слово> перевод записи
|
||
/stats цифры
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import html
|
||
import json
|
||
import os
|
||
import re
|
||
import time
|
||
import urllib.parse
|
||
import urllib.request
|
||
|
||
from . import abuse as abuse_mod
|
||
from . import ai as ai_mod
|
||
from . import discover as discover_mod
|
||
from . import feeds, net, source_state, sources, store
|
||
|
||
API = "https://api.telegram.org/bot%s/" % os.environ.get("OMNI_BOT_TOKEN", "")
|
||
TOKEN = os.environ.get("OMNI_BOT_TOKEN", "")
|
||
OWNERS = {int(x) for x in re.findall(r"\d{5,}", os.environ.get("OMNI_BOT_OWNERS") or os.environ.get("OMNI_BOT_ALLOW") or "")}
|
||
MAX_LEN = 3600
|
||
|
||
|
||
def _api(method, **params):
|
||
if not TOKEN:
|
||
raise SystemExit("OMNI_BOT_TOKEN не задан")
|
||
url = API + method
|
||
data = urllib.parse.urlencode(params).encode()
|
||
req = urllib.request.Request(url, data=data)
|
||
with urllib.request.urlopen(req, timeout=40) as resp:
|
||
return json.loads(resp.read().decode("utf-8"))
|
||
|
||
|
||
def _send(chat_id, text, preview=True, reply_markup=None):
|
||
text = text[:MAX_LEN]
|
||
if os.environ.get("OMNI_BOT_DRY"):
|
||
print("[DRY] " + text.replace("</b>", "").replace("<b>", "")[:1200])
|
||
return {"ok": True}
|
||
kw = {}
|
||
if reply_markup:
|
||
kw["reply_markup"] = json.dumps(reply_markup, ensure_ascii=False)
|
||
return _api("sendMessage", chat_id=chat_id, text=text, parse_mode="HTML",
|
||
disable_web_page_preview="false" if preview else "true", **kw)
|
||
|
||
|
||
def _esc(s):
|
||
return html.escape(str(s or ""), quote=False)
|
||
|
||
|
||
def fmt_item(it):
|
||
title = _esc((it.get("title") or "")[:150])
|
||
src = _esc(it.get("source") or "")
|
||
url = it.get("url") or ""
|
||
line = "<b>%s</b>\n<code>%s</code>" % (title, src)
|
||
if url:
|
||
line += ' · <a href="%s">открыть</a>' % _esc(url)
|
||
return line
|
||
|
||
|
||
def cmd_start(chat_id, arg):
|
||
_send(chat_id, "<b>omni</b> — парсер-радар\n\n"
|
||
"/new 5 — последние записи\n"
|
||
"/abuse promo — абузы по тегу\n"
|
||
"/find claude — поиск\n"
|
||
"/src reddit — источник\n"
|
||
"/add <url> — подключить фид\n"
|
||
"/run abuse — прогнать категорию\n"
|
||
"/auto 10 — автодобавление\n"
|
||
"/stats — цифры\n/sub @канал — постить новые абузы в канал\n/post @канал — опубликовать сейчас",
|
||
reply_markup=KB_MAIN)
|
||
|
||
|
||
def cmd_new(chat_id, arg):
|
||
n = int(arg) if arg.strip().isdigit() else 8
|
||
items, _total = store.browse2(limit=min(n, 20), sort="fresh")
|
||
if not items:
|
||
return _send(chat_id, "пусто")
|
||
_send(chat_id, "последние %d:\n\n" % len(items) + "\n\n".join(fmt_item(i) for i in items))
|
||
|
||
|
||
def cmd_abuse(chat_id, arg):
|
||
tag = arg.strip().split()[0] if arg.strip() else None
|
||
d = abuse_mod.scan(limit=10, tag=tag)
|
||
if not d["items"]:
|
||
return _send(chat_id, "абузов не видно")
|
||
head = "абузы · %s · %d\n\n" % ("все" if not tag else tag, d["total"])
|
||
body = []
|
||
for it in d["items"]:
|
||
body.append("<b>%s</b>\n<code>%s</code> · %s" % (
|
||
_esc(it["title"][:120]), _esc(it["source"]), _esc(",".join(it["tags"]))))
|
||
_send(chat_id, head + "\n\n".join(body))
|
||
|
||
|
||
def cmd_find(chat_id, arg):
|
||
q = arg.strip()
|
||
if not q:
|
||
return _send(chat_id, "что искать?")
|
||
rows = store.search(q, limit=8)
|
||
keys = ("provider", "kind", "source", "title", "score", "url")
|
||
items = [dict(zip(keys, r)) if not isinstance(r, dict) else r for r in rows]
|
||
if not items:
|
||
return _send(chat_id, "нет совпадений")
|
||
_send(chat_id, "поиск: %s\n\n" % _esc(q) + "\n\n".join(fmt_item(i) for i in items))
|
||
|
||
|
||
def cmd_src(chat_id, arg):
|
||
q = arg.strip().lower()
|
||
all_s = sources.all_sources()
|
||
hits = [s for s in all_s if q and (q in s.name.lower() or q in s.url.lower() or q in s.category.lower())]
|
||
if not hits:
|
||
return _send(chat_id, "нет такого источника")
|
||
out = ["<b>%s</b> · %s · %s" % (_esc(s.name), _esc(s.category), _esc(s.adapter)) for s in hits[:12]]
|
||
_send(chat_id, "источники (%d):\n\n" % len(hits) + "\n".join(out))
|
||
|
||
|
||
def cmd_add(chat_id, arg):
|
||
url = arg.strip()
|
||
if not url.startswith("http"):
|
||
return _send(chat_id, "нужен url фида")
|
||
ok, n, ad = discover_mod.probe(url, "community", limit=6)
|
||
if not ok:
|
||
return _send(chat_id, "фид пустой или недоступен: %s" % _esc(ad))
|
||
name = "manual_" + re.sub(r"[^a-z0-9]+", "_", urllib.parse.urlsplit(url).netloc.lower())[:32]
|
||
source_state.add_custom(name, "community", url, kind="rss" if ad == "rss" else "html",
|
||
adapter=ad, tags=["manual"], limit=15)
|
||
_send(chat_id, "добавлен <code>%s</code> · %s · %d записей" % (_esc(name), _esc(ad), n))
|
||
|
||
|
||
def cmd_run(chat_id, arg):
|
||
cat = arg.strip() or "abuse"
|
||
srcs = [s for s in sources.all_sources() if s.category == cat]
|
||
if not srcs:
|
||
return _send(chat_id, "нет категории %s" % _esc(cat))
|
||
_send(chat_id, "прогон %s (%d источников)…" % (_esc(cat), len(srcs)))
|
||
got = new = 0
|
||
for s in srcs[:80]:
|
||
try:
|
||
items = feeds.fetch(s, 10)
|
||
except Exception:
|
||
items = []
|
||
got += len(items)
|
||
if items:
|
||
n_new, _dup = store.add(items)
|
||
new += n_new
|
||
_send(chat_id, "готово: собрано %d, новых %d" % (got, new))
|
||
|
||
|
||
def cmd_auto(chat_id, arg):
|
||
n = int(arg) if arg.strip().isdigit() else 15
|
||
res = discover_mod.discover(limit_hosts=30, workers=8, max_add=min(n, 30))
|
||
_send(chat_id, "автодобавление: кандидатов %d, живых %d\n%s" % (
|
||
res["found"], res["alive"], _esc(", ".join(res["added"][:10]))))
|
||
|
||
|
||
def cmd_stats(chat_id, arg):
|
||
s = store.stats()
|
||
a = sources.all_sources()
|
||
fl = source_state.flags()
|
||
alive = sum(1 for x in a if (fl.get(x.name, {}).get("items") or 0) > 0)
|
||
_send(chat_id, "<b>omni</b>\nзаписей %s · источников %d · живых %s\nкатегорий %d · прогонов %s · с ценой %s" % (
|
||
s.get("items"), len(a), alive, len(sources.CATEGORIES), s.get("runs"), s.get("priced")))
|
||
|
||
|
||
# --- подписка, формат, канал -------------------------------------------------
|
||
HIDE_TAGS = {"keys"} # про ключи не постим и не показываем
|
||
SUBS_SQL = ("CREATE TABLE IF NOT EXISTS abuse_subs (chat_id INTEGER PRIMARY KEY, "
|
||
"ts INTEGER DEFAULT 0, last_id INTEGER DEFAULT 0)")
|
||
|
||
KB_MAIN = {"inline_keyboard": [
|
||
[{"text": "Лента", "callback_data": "m:new"}, {"text": "Абузы", "callback_data": "m:abuse"}],
|
||
[{"text": "Источники", "callback_data": "m:src"}, {"text": "Цифры", "callback_data": "m:stats"}],
|
||
[{"text": "Промо", "callback_data": "t:promo"}, {"text": "Триалы", "callback_data": "t:trial"},
|
||
{"text": "Сливы", "callback_data": "t:leak"}],
|
||
[{"text": "Подписка: вкл", "callback_data": "sub:on"}, {"text": "выкл", "callback_data": "sub:off"}],
|
||
[{"text": "Формат: кратко", "callback_data": "fmt:short"},
|
||
{"text": "полно", "callback_data": "fmt:full"}],
|
||
[{"text": "ИИ-саммари", "callback_data": "ai:sum"},
|
||
{"text": "Перевод: вкл/выкл", "callback_data": "ai:tr"}],
|
||
[{"text": "Саммари в подписке: вкл/выкл", "callback_data": "ai:sm"}],
|
||
[{"text": "Пост в канал", "callback_data": "post:now"}],
|
||
]}
|
||
|
||
PREFS_SQL = "CREATE TABLE IF NOT EXISTS bot_prefs (chat_id INTEGER PRIMARY KEY, fmt TEXT DEFAULT 'short')"
|
||
|
||
|
||
def _conn():
|
||
import sqlite3
|
||
from .config import DB
|
||
c = sqlite3.connect(str(DB), timeout=30)
|
||
c.execute(SUBS_SQL)
|
||
c.execute(PREFS_SQL)
|
||
c.commit()
|
||
return c
|
||
|
||
|
||
def prefs_get(chat_id):
|
||
c = _conn()
|
||
r = c.execute("SELECT fmt FROM bot_prefs WHERE chat_id=?", (chat_id,)).fetchone()
|
||
c.close()
|
||
return (r[0] if r else "short")
|
||
|
||
|
||
def prefs_set(chat_id, fmt):
|
||
c = _conn()
|
||
c.execute("INSERT INTO bot_prefs(chat_id, fmt) VALUES(?,?) "
|
||
"ON CONFLICT(chat_id) DO UPDATE SET fmt=excluded.fmt", (chat_id, fmt))
|
||
c.commit()
|
||
c.close()
|
||
|
||
|
||
def subs_add(target, last_id=0):
|
||
c = _conn()
|
||
if not last_id:
|
||
last_id = c.execute("SELECT COALESCE(MAX(id),0) FROM items").fetchone()[0]
|
||
c.execute("INSERT INTO abuse_subs(chat_id, ts, last_id) VALUES(?,?,?) "
|
||
"ON CONFLICT(chat_id) DO UPDATE SET last_id=excluded.last_id",
|
||
(target, int(time.time()), last_id))
|
||
c.commit()
|
||
c.close()
|
||
return last_id
|
||
|
||
|
||
def subs_del(target):
|
||
c = _conn()
|
||
n = c.execute("DELETE FROM abuse_subs WHERE chat_id=?", (target,)).rowcount
|
||
c.commit()
|
||
c.close()
|
||
return n
|
||
|
||
|
||
def subs_all():
|
||
c = _conn()
|
||
rows = c.execute("SELECT chat_id, last_id FROM abuse_subs ORDER BY ts DESC").fetchall()
|
||
c.close()
|
||
return rows
|
||
|
||
|
||
def _resolve_chat(arg, chat_id):
|
||
a = (arg or "").strip()
|
||
if not a:
|
||
return chat_id
|
||
if a.lstrip("-").isdigit():
|
||
return int(a)
|
||
try:
|
||
r = _api("getChat", chat_id=a)
|
||
return (r.get("result") or {}).get("id")
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
def _scan_safe(limit=10, tag=None, window=6000):
|
||
d = abuse_mod.scan(limit=limit * 3, tag=tag, window=window)
|
||
out = []
|
||
for it in d.get("items", []):
|
||
tags = [t for t in (it.get("tags") or []) if t not in HIDE_TAGS]
|
||
if not tags:
|
||
continue
|
||
it = dict(it)
|
||
it["tags"] = tags
|
||
out.append(it)
|
||
d["items"] = out[:limit]
|
||
d["hidden_keys"] = len(d.get("items", [])) - len(out)
|
||
return d
|
||
|
||
|
||
def _line(it, fmt="short", tr=False):
|
||
raw = (it.get("title") or "")[:150]
|
||
if tr:
|
||
raw = ai_mod.translate(raw) or raw
|
||
title = _esc(raw)
|
||
src = _esc(it.get("source") or "")
|
||
tags = _esc(",".join(it.get("tags") or []))
|
||
head = "<b>%s</b>\n<code>%s</code> · %s" % (title, src, tags)
|
||
if fmt == "full":
|
||
url = it.get("url") or ""
|
||
if url:
|
||
head += ' · <a href="%s">открыть</a>' % _esc(url)
|
||
return head
|
||
|
||
|
||
AI_SQL = "CREATE TABLE IF NOT EXISTS bot_ai (chat_id INTEGER PRIMARY KEY, tr INTEGER DEFAULT 0, sm INTEGER DEFAULT 0)"
|
||
|
||
|
||
def ai_prefs(chat_id):
|
||
c = _conn()
|
||
c.execute(AI_SQL)
|
||
c.commit()
|
||
r = c.execute("SELECT tr, sm FROM bot_ai WHERE chat_id=?", (chat_id,)).fetchone()
|
||
c.close()
|
||
return (r[0], r[1]) if r else (0, 0)
|
||
|
||
|
||
def ai_set(chat_id, field, val):
|
||
c = _conn()
|
||
c.execute(AI_SQL)
|
||
c.execute("INSERT INTO bot_ai(chat_id, tr, sm) VALUES(?,0,0) ON CONFLICT(chat_id) DO NOTHING", (chat_id,))
|
||
c.execute("UPDATE bot_ai SET %s=? WHERE chat_id=?" % ("tr" if field == "tr" else "sm"), (val, chat_id))
|
||
c.commit()
|
||
c.close()
|
||
|
||
|
||
def ai_scan_summary(limit=12, tag=None):
|
||
"""ИИ-саммари свежих абузов. None если ИИ недоступен."""
|
||
d = _scan_safe(limit=limit, tag=tag)
|
||
items = d.get("items") or []
|
||
if not items:
|
||
return None, 0
|
||
posts = ["%s — %s" % (i.get("title") or "", i.get("source") or "") for i in items]
|
||
return ai_mod.summarize(posts, tag=tag), len(items)
|
||
|
||
|
||
def cmd_sum(chat_id, arg):
|
||
tag = arg.strip().split()[0] if arg.strip() else None
|
||
if not ai_mod.available():
|
||
return _send(chat_id, "ИИ не подключён: задай OMNI_AI_KEY (или ключ reformboss в конфиге Hermes)", reply_markup=KB_MAIN)
|
||
txt, n = ai_scan_summary(limit=14, tag=tag)
|
||
if not txt:
|
||
return _send(chat_id, "саммари не собралось", reply_markup=KB_MAIN)
|
||
_send(chat_id, "<b>саммари · %s · %d записей</b>\n\n%s" % (tag or "все", n, _esc(txt)), reply_markup=KB_MAIN)
|
||
|
||
|
||
def cmd_tr(chat_id, arg):
|
||
"""Перевод записи: /tr <id|слово>."""
|
||
q = arg.strip()
|
||
if not q:
|
||
return _send(chat_id, "что перевести? /tr 4933 или /tr muse", reply_markup=KB_MAIN)
|
||
if not ai_mod.available():
|
||
return _send(chat_id, "ИИ не подключён: задай OMNI_AI_KEY", reply_markup=KB_MAIN)
|
||
title = text = src = url = None
|
||
if q.isdigit():
|
||
import sqlite3
|
||
from .config import DB
|
||
c = sqlite3.connect(str(DB), timeout=20)
|
||
r = c.execute("SELECT title, text, source, url FROM items WHERE id=?", (int(q),)).fetchone()
|
||
c.close()
|
||
if r:
|
||
title, text, src, url = r[0], r[1] or "", r[2], r[3]
|
||
if title is None:
|
||
import sqlite3
|
||
from .config import DB
|
||
c = sqlite3.connect(str(DB), timeout=20)
|
||
r = c.execute("SELECT title, text, source, url FROM items WHERE title LIKE ? "
|
||
"ORDER BY id DESC LIMIT 1", ("%" + q + "%",)).fetchone()
|
||
c.close()
|
||
if r:
|
||
title, text, src, url = r[0], r[1] or "", r[2], r[3]
|
||
if title is None:
|
||
rows = store.search(q, limit=1)
|
||
if rows:
|
||
r = rows[0]
|
||
if isinstance(r, dict):
|
||
title, src, url = r.get("title"), r.get("source"), r.get("url")
|
||
text = r.get("text") or ""
|
||
else:
|
||
src, title, url = r[2], r[3], r[5]
|
||
text = ""
|
||
if not title:
|
||
return _send(chat_id, "не нашёл запись", reply_markup=KB_MAIN)
|
||
payload = title if len(title) > 120 else (title + "\n" + (text or "")[:600]).strip()
|
||
ru = ai_mod.translate(payload)
|
||
if not ru:
|
||
return _send(chat_id, "перевод не получился, попробуй ещё раз", reply_markup=KB_MAIN)
|
||
out = "<b>%s</b>\n<code>%s</code>\n\n%s" % (_esc(title[:150]), _esc(src), _esc(ru))
|
||
if url:
|
||
out += '\n<a href="%s">источник</a>' % _esc(url)
|
||
_send(chat_id, out, reply_markup=KB_MAIN)
|
||
|
||
|
||
def abuse_text(tag=None, limit=6, fmt="short", tr=False):
|
||
d = _scan_safe(limit=limit, tag=tag)
|
||
if not d["items"]:
|
||
return None
|
||
head = "абузы · %s · %d" % (tag or "все", d["total"])
|
||
if tr:
|
||
head += " · перевод"
|
||
lines = []
|
||
for n, i in enumerate(d["items"]):
|
||
lines.append(_line(i, fmt, tr and n < 5))
|
||
return head + "\n\n" + "\n\n".join(lines)
|
||
|
||
|
||
def cmd_abuse(chat_id, arg):
|
||
tag = arg.strip().split()[0] if arg.strip() else None
|
||
tr = bool(ai_prefs(chat_id)[0]) and ai_mod.available()
|
||
txt = abuse_text(tag, fmt=prefs_get(chat_id), tr=tr)
|
||
_send(chat_id, txt or "абузов не видно", reply_markup=KB_MAIN)
|
||
|
||
|
||
def cmd_sub(chat_id, arg):
|
||
target = _resolve_chat(arg, chat_id)
|
||
if not target:
|
||
return _send(chat_id, "не вижу такой чат: добавь бота админом и повтори /sub @канал", reply_markup=KB_MAIN)
|
||
last = subs_add(target)
|
||
where = "сюда" if target == chat_id else "<code>%s</code>" % target
|
||
_send(chat_id, "подписан: %s, шлю только новые абузы (после id %d). /unsub — отписаться" % (where, last),
|
||
reply_markup=KB_MAIN)
|
||
|
||
|
||
def cmd_unsub(chat_id, arg):
|
||
target = _resolve_chat(arg, chat_id) or chat_id
|
||
n = subs_del(target)
|
||
_send(chat_id, "отписал" if n else "подписки не было", reply_markup=KB_MAIN)
|
||
|
||
|
||
def cmd_subs(chat_id, arg):
|
||
rows = subs_all()
|
||
if not rows:
|
||
return _send(chat_id, "подписок нет", reply_markup=KB_MAIN)
|
||
body = "\n".join("<code>%s</code> · id %s" % (c, i) for c, i in rows[:20])
|
||
_send(chat_id, "<b>подписки (%d)</b>\n%s" % (len(rows), body), reply_markup=KB_MAIN)
|
||
|
||
|
||
def publish(target, tag=None, limit=5):
|
||
"""Один пост с абузами в указанный чат/канал."""
|
||
fmt = prefs_get(target) if isinstance(target, int) else "short"
|
||
txt = abuse_text(tag, limit=limit, fmt=fmt)
|
||
if not txt:
|
||
return False
|
||
_send(target, txt)
|
||
return True
|
||
|
||
|
||
def cmd_test(chat_id, arg):
|
||
target = _resolve_chat(arg, chat_id)
|
||
if not target:
|
||
return _send(chat_id, "куда постить? /post @канал", reply_markup=KB_MAIN)
|
||
ok = publish(target)
|
||
_send(chat_id, "опубликовал" if ok else "нечего публиковать", reply_markup=KB_MAIN)
|
||
|
||
|
||
def push_new(per_chat=5, window=2000):
|
||
subs = subs_all()
|
||
if not subs:
|
||
return 0
|
||
d = _scan_safe(limit=400, window=window)
|
||
items = sorted(d["items"], key=lambda x: x.get("id") or 0)
|
||
sent = 0
|
||
for target, last in subs:
|
||
fresh = [i for i in items if (i.get("id") or 0) > (last or 0)]
|
||
if not fresh:
|
||
continue
|
||
chunk = fresh[:per_chat] # раньше уходили САМЫЕ СТАРЫЕ из окна
|
||
fmt = prefs_get(target) if isinstance(target, int) else "short"
|
||
tr = sm = 0
|
||
if isinstance(target, int):
|
||
tr, sm = ai_prefs(target)
|
||
tr = bool(tr) and ai_mod.available()
|
||
pre = ""
|
||
if sm and ai_mod.available():
|
||
posts = ["%s — %s" % (i.get("title") or "", i.get("source") or "") for i in chunk]
|
||
summary = ai_mod.summarize(posts)
|
||
if summary:
|
||
pre = "<b>саммари</b>\n%s\n\n" % _esc(summary)
|
||
text = pre + ("<b>новые абузы · %d</b>\n\n" % len(fresh)) + "\n\n".join(_line(i, fmt, tr) for i in chunk)
|
||
try:
|
||
_send(target, text[:MAX_LEN])
|
||
sent += 1
|
||
except Exception as e:
|
||
print("push fail", target, e, flush=True)
|
||
continue
|
||
subs_add(target, last_id=chunk[-1].get("id") or last)
|
||
return sent
|
||
|
||
|
||
def pusher(every=300):
|
||
while True:
|
||
time.sleep(every)
|
||
try:
|
||
n = push_new()
|
||
if n:
|
||
print("pushed", n, flush=True)
|
||
except Exception as e:
|
||
print("pusher fail", e, flush=True)
|
||
|
||
|
||
READONLY_CMDS = {"/start", "/help", "/new", "/abuse", "/find", "/src", "/stats",
|
||
"/tag", "/типы", "/sum", "/tr"}
|
||
|
||
|
||
|
||
def cmd_tag(chat_id, arg):
|
||
"""Типы записей: /tag — счётчики, /tag leak — топ записей этого типа."""
|
||
from . import taxonomy
|
||
t = arg.strip().lower()
|
||
if not t:
|
||
counts = store.type_counts()
|
||
rows = sorted(counts.items(), key=lambda x: -x[1])[:14]
|
||
body = "\n".join("%-12s %d" % (taxonomy.LABELS.get(k, k), v) for k, v in rows)
|
||
return _send(chat_id, "<b>типы записей</b>\n<pre>%s</pre>\n/tag <тип> — топ"
|
||
% _esc(body), reply_markup=KB_MAIN)
|
||
if t not in taxonomy.LABELS:
|
||
return _send(chat_id, "нет такого типа: %s" % _esc(t), reply_markup=KB_MAIN)
|
||
items, total = store.browse2(limit=8, sort="score", typ=t)
|
||
if not items:
|
||
return _send(chat_id, "по типу %s пусто" % _esc(t), reply_markup=KB_MAIN)
|
||
head = "<b>%s</b> · всего %d\n\n" % (_esc(taxonomy.LABELS.get(t, t)), total)
|
||
_send(chat_id, head + "\n\n".join(fmt_item(i) for i in items), reply_markup=KB_MAIN)
|
||
|
||
CMDS = {"/start": cmd_start, "/help": cmd_start, "/new": cmd_new, "/abuse": cmd_abuse,
|
||
"/find": cmd_find, "/src": cmd_src, "/add": cmd_add, "/run": cmd_run,
|
||
"/auto": cmd_auto, "/stats": cmd_stats,
|
||
"/sub": cmd_sub, "/unsub": cmd_unsub, "/subs": cmd_subs,
|
||
"/post": cmd_test, "/sum": cmd_sum, "/tr": cmd_tr, "/tag": cmd_tag, "/типы": cmd_tag}
|
||
|
||
|
||
def handle(update):
|
||
msg = update.get("message") or update.get("edited_message") or {}
|
||
chat = msg.get("chat") or {}
|
||
chat_id = chat.get("id")
|
||
text = (msg.get("text") or "").strip()
|
||
uid = (msg.get("from") or {}).get("id")
|
||
if not chat_id or not text:
|
||
return
|
||
parts = text.split(None, 1)
|
||
cmd = parts[0].lower().split("@")[0]
|
||
arg = parts[1] if len(parts) > 1 else ""
|
||
if OWNERS and uid not in OWNERS:
|
||
return
|
||
if not OWNERS and cmd not in READONLY_CMDS:
|
||
# раньше первый написавший становился владельцем: любой, кто нашёл бота
|
||
return _send(chat_id, "read-only: задай OMNI_BOT_OWNERS и перезапусти бота")
|
||
fn = CMDS.get(cmd)
|
||
if not fn:
|
||
return _send(chat_id, "не знаю такую команду. /help")
|
||
try:
|
||
fn(chat_id, arg)
|
||
except Exception as e:
|
||
_send(chat_id, "ошибка: %s" % _esc(type(e).__name__ + ": " + str(e)[:160]))
|
||
|
||
|
||
def handle_cb(cb):
|
||
cb_id = cb.get("id")
|
||
data = cb.get("data") or ""
|
||
msg = cb.get("message") or {}
|
||
chat_id = (msg.get("chat") or {}).get("id")
|
||
try:
|
||
_api("answerCallbackQuery", callback_query_id=cb_id)
|
||
except Exception:
|
||
pass
|
||
if not chat_id or (OWNERS and (cb.get("from") or {}).get("id") not in OWNERS):
|
||
return
|
||
fmt = prefs_get(chat_id)
|
||
if data == "m:new":
|
||
return cmd_new(chat_id, "5")
|
||
if data == "m:abuse":
|
||
return cmd_abuse(chat_id, "")
|
||
if data == "m:src":
|
||
return cmd_src(chat_id, "")
|
||
if data == "m:stats":
|
||
return cmd_stats(chat_id, "")
|
||
if data.startswith("t:"):
|
||
return cmd_abuse(chat_id, data[2:])
|
||
if data == "sub:on":
|
||
return cmd_sub(chat_id, "")
|
||
if data == "sub:off":
|
||
return cmd_unsub(chat_id, "")
|
||
if data.startswith("fmt:"):
|
||
prefs_set(chat_id, data[4:])
|
||
return _send(chat_id, "формат: %s" % ("кратко" if data[4:] == "short" else "полно"), reply_markup=KB_MAIN)
|
||
if data == "post:now":
|
||
return cmd_test(chat_id, "")
|
||
if data == "ai:sum":
|
||
return cmd_sum(chat_id, "")
|
||
if data == "ai:tr":
|
||
tr, _sm = ai_prefs(chat_id)
|
||
ai_set(chat_id, "tr", 0 if tr else 1)
|
||
return _send(chat_id, "перевод абузов: %s" % ("выкл" if tr else "вкл"), reply_markup=KB_MAIN)
|
||
if data == "ai:sm":
|
||
_tr, sm = ai_prefs(chat_id)
|
||
ai_set(chat_id, "sm", 0 if sm else 1)
|
||
return _send(chat_id, "саммари в подписке: %s" % ("выкл" if sm else "вкл"), reply_markup=KB_MAIN)
|
||
|
||
|
||
def run_forever():
|
||
if not TOKEN:
|
||
raise SystemExit("нужен OMNI_BOT_TOKEN")
|
||
offset = 0
|
||
import threading
|
||
threading.Thread(target=pusher, daemon=True).start()
|
||
print("bot up", flush=True)
|
||
while True:
|
||
try:
|
||
r = _api("getUpdates", offset=offset, timeout=25, allowed_updates='["message","callback_query"]')
|
||
except Exception as e:
|
||
print("poll fail", e, flush=True)
|
||
time.sleep(5)
|
||
continue
|
||
for up in r.get("result", []):
|
||
offset = up["update_id"] + 1
|
||
if up.get("callback_query"):
|
||
try:
|
||
handle_cb(up["callback_query"])
|
||
except Exception as e:
|
||
print("cb fail", e, flush=True)
|
||
else:
|
||
handle(up)
|
||
time.sleep(0.3)
|
||
|
||
|
||
|
||
def _single_instance():
|
||
"""Один процесс на токен: второй инстанс выходит, иначе TelegramConflictError и бот молчит."""
|
||
import os, sys, time, tempfile
|
||
path = os.path.join(tempfile.gettempdir(), "omni_bot.lock")
|
||
try:
|
||
if os.path.exists(path):
|
||
age = time.time() - os.path.getmtime(path)
|
||
try:
|
||
pid = int((open(path, encoding="utf-8").read() or "0").strip() or 0)
|
||
except ValueError:
|
||
pid = 0
|
||
if pid and age < 6 * 3600:
|
||
alive = False
|
||
try:
|
||
import psutil
|
||
alive = psutil.pid_exists(pid) and "omni" in " ".join(psutil.Process(pid).cmdline() or [])
|
||
except Exception:
|
||
alive = False
|
||
if alive:
|
||
print("уже запущен pid %s - выхожу" % pid, flush=True)
|
||
sys.exit(0)
|
||
open(path, "w", encoding="utf-8").write(str(os.getpid()))
|
||
os.utime(path, None)
|
||
except Exception as e:
|
||
print("lock skip", e, flush=True)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
_single_instance()
|
||
run_forever() |