792 lines
26 KiB
Python
792 lines
26 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
|
||
import io
|
||
import os
|
||
import re
|
||
import time
|
||
import random
|
||
import logging
|
||
import socket
|
||
import tempfile
|
||
import subprocess
|
||
import json
|
||
from logging.handlers import RotatingFileHandler
|
||
from typing import Optional, Tuple, Dict, Any, Callable, TypeVar, List
|
||
from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
|
||
|
||
import requests
|
||
from requests.adapters import HTTPAdapter
|
||
|
||
try:
|
||
from urllib3.util.retry import Retry
|
||
except Exception:
|
||
Retry = None # type: ignore
|
||
|
||
try:
|
||
import imageio_ffmpeg
|
||
except Exception:
|
||
imageio_ffmpeg = None # type: ignore
|
||
|
||
|
||
# =======================
|
||
# ENV loader (Windows-friendly)
|
||
# =======================
|
||
|
||
def load_env_file(path: str = "config.env") -> None:
|
||
if not os.path.exists(path):
|
||
return
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
for raw in f:
|
||
line = raw.strip()
|
||
if not line or line.startswith("#") or line.startswith(";"):
|
||
continue
|
||
if "=" not in line:
|
||
continue
|
||
|
||
k, v = line.split("=", 1)
|
||
k = k.strip()
|
||
v = v.strip()
|
||
|
||
if v and v[0] not in "\"'":
|
||
m = re.search(r"\s+#", v)
|
||
if m:
|
||
v = v[: m.start()].rstrip()
|
||
|
||
v = v.strip().strip('"').strip("'")
|
||
if k:
|
||
os.environ.setdefault(k, v)
|
||
|
||
|
||
load_env_file()
|
||
|
||
|
||
# =======================
|
||
# CONFIG
|
||
# =======================
|
||
|
||
MASTODON_BASE_URL = os.getenv("MASTODON_BASE_URL", "https://bronyfurry.com").strip().rstrip("/")
|
||
MASTODON_ACCESS_TOKEN = os.getenv("MASTODON_ACCESS_TOKEN", "").strip()
|
||
|
||
FURBOORU_BASE_URL = os.getenv("FURBOORU_BASE_URL", "https://furbooru.org").strip().rstrip("/")
|
||
FURBOORU_API_KEY = os.getenv("FURBOORU_API_KEY", "").strip()
|
||
SAFE_FILTER_ID = os.getenv("SAFE_FILTER_ID", "").strip()
|
||
NSFW_FILTER_ID = os.getenv("NSFW_FILTER_ID", "").strip()
|
||
|
||
USER_AGENT = os.getenv("USER_AGENT", "giffer-bot/3.3 (by @giffer@bronyfurry.com)").strip()
|
||
|
||
CHECK_INTERVAL = int(os.getenv("CHECK_INTERVAL", "30"))
|
||
|
||
# Rate-limit / anti-spam
|
||
USER_COOLDOWN_SEC = int(os.getenv("USER_COOLDOWN_SEC", "20"))
|
||
GLOBAL_RATE_PER_SEC = float(os.getenv("GLOBAL_RATE_PER_SEC", "1.0"))
|
||
GLOBAL_BURST = int(os.getenv("GLOBAL_BURST", "3"))
|
||
|
||
# Network hardening
|
||
CONNECT_TIMEOUT = float(os.getenv("CONNECT_TIMEOUT", "5"))
|
||
READ_TIMEOUT = float(os.getenv("READ_TIMEOUT", "20"))
|
||
SOCKET_DEFAULT_TIMEOUT = float(os.getenv("SOCKET_DEFAULT_TIMEOUT", "25"))
|
||
|
||
# Watchdog for Mastodon calls
|
||
MASTO_CALL_TIMEOUT = float(os.getenv("MASTO_CALL_TIMEOUT", "25"))
|
||
|
||
# Media download safety
|
||
MAX_GIF_BYTES = int(os.getenv("MAX_GIF_BYTES", str(25 * 1024 * 1024))) # 25MB
|
||
DOWNLOAD_TIMEOUT = float(os.getenv("DOWNLOAD_TIMEOUT", "40"))
|
||
|
||
# Wait for Mastodon media processing
|
||
MEDIA_PROCESS_MAX_WAIT = float(os.getenv("MEDIA_PROCESS_MAX_WAIT", "60"))
|
||
|
||
NSFW_VISIBILITY = os.getenv("NSFW_VISIBILITY", "public").strip() # public/unlisted/private/direct
|
||
|
||
# Logging
|
||
LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
|
||
LOG_FILE = os.getenv("LOG_FILE", "giffer.log").strip() or "giffer.log"
|
||
|
||
# State (for "do not reply twice")
|
||
STATE_FILE = os.getenv("STATE_FILE", "giffer_state.json").strip() or "giffer_state.json"
|
||
PROCESSED_CACHE_MAX = int(os.getenv("PROCESSED_CACHE_MAX", "800")) # how many status_ids to remember
|
||
|
||
|
||
# =======================
|
||
# LOGGING
|
||
# =======================
|
||
|
||
logger = logging.getLogger("giffer")
|
||
logger.setLevel(getattr(logging, LOG_LEVEL, logging.INFO))
|
||
logger.handlers.clear()
|
||
|
||
fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
|
||
|
||
ch = logging.StreamHandler()
|
||
ch.setFormatter(fmt)
|
||
logger.addHandler(ch)
|
||
|
||
fh = RotatingFileHandler(LOG_FILE, maxBytes=5 * 1024 * 1024, backupCount=3, encoding="utf-8")
|
||
fh.setFormatter(fmt)
|
||
logger.addHandler(fh)
|
||
|
||
|
||
# =======================
|
||
# GLOBAL NETWORK SETTINGS
|
||
# =======================
|
||
|
||
socket.setdefaulttimeout(SOCKET_DEFAULT_TIMEOUT)
|
||
|
||
|
||
def make_session() -> requests.Session:
|
||
s = requests.Session()
|
||
s.headers.update({"User-Agent": USER_AGENT})
|
||
|
||
if Retry is not None:
|
||
retry = Retry(
|
||
total=3,
|
||
connect=3,
|
||
read=2,
|
||
status=2,
|
||
backoff_factor=0.6,
|
||
status_forcelist=(429, 500, 502, 503, 504),
|
||
allowed_methods=("GET", "POST"),
|
||
raise_on_status=False,
|
||
)
|
||
adapter = HTTPAdapter(max_retries=retry, pool_connections=10, pool_maxsize=10)
|
||
else:
|
||
adapter = HTTPAdapter(pool_connections=10, pool_maxsize=10)
|
||
|
||
s.mount("https://", adapter)
|
||
s.mount("http://", adapter)
|
||
return s
|
||
|
||
|
||
http = make_session()
|
||
|
||
_executor = ThreadPoolExecutor(max_workers=4)
|
||
T = TypeVar("T")
|
||
|
||
|
||
def run_with_timeout(fn: Callable[[], T], timeout: float, what: str) -> Optional[T]:
|
||
fut = _executor.submit(fn)
|
||
try:
|
||
return fut.result(timeout=timeout)
|
||
except FuturesTimeoutError:
|
||
logger.error("Timeout: %s (>%ss). Continuing.", what, timeout)
|
||
return None
|
||
except Exception as e:
|
||
logger.error("Error in %s: %s", what, e)
|
||
return None
|
||
|
||
|
||
# =======================
|
||
# STATE (persist last_seen + processed status_ids)
|
||
# =======================
|
||
|
||
def load_state() -> Dict[str, Any]:
|
||
if not os.path.exists(STATE_FILE):
|
||
return {"last_seen_notif_id": None, "processed_status_ids": []}
|
||
try:
|
||
with open(STATE_FILE, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
if "last_seen_notif_id" not in data:
|
||
data["last_seen_notif_id"] = None
|
||
if "processed_status_ids" not in data or not isinstance(data["processed_status_ids"], list):
|
||
data["processed_status_ids"] = []
|
||
return data
|
||
except Exception as e:
|
||
logger.warning("Failed to read state file (%s). Starting fresh.", e)
|
||
return {"last_seen_notif_id": None, "processed_status_ids": []}
|
||
|
||
def save_state(state: Dict[str, Any]) -> None:
|
||
try:
|
||
tmp = STATE_FILE + ".tmp"
|
||
with open(tmp, "w", encoding="utf-8") as f:
|
||
json.dump(state, f, ensure_ascii=False)
|
||
os.replace(tmp, STATE_FILE)
|
||
except Exception as e:
|
||
logger.warning("Failed to write state file: %s", e)
|
||
|
||
def remember_processed(state: Dict[str, Any], status_id: int) -> None:
|
||
arr = state.get("processed_status_ids", [])
|
||
arr.append(int(status_id))
|
||
# keep last N
|
||
if len(arr) > PROCESSED_CACHE_MAX:
|
||
arr = arr[-PROCESSED_CACHE_MAX:]
|
||
state["processed_status_ids"] = arr
|
||
|
||
def is_processed(state: Dict[str, Any], status_id: int) -> bool:
|
||
try:
|
||
return int(status_id) in set(state.get("processed_status_ids", []))
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
# =======================
|
||
# RATE LIMIT HELPERS
|
||
# =======================
|
||
|
||
_user_last: Dict[str, float] = {}
|
||
_global_tokens = float(GLOBAL_BURST)
|
||
_global_last = time.monotonic()
|
||
|
||
|
||
def user_allowed(acct: str) -> bool:
|
||
now = time.time()
|
||
last = _user_last.get(acct, 0.0)
|
||
if now - last < USER_COOLDOWN_SEC:
|
||
logger.info("Cooldown hit for user=%s (wait %.1fs)", acct, USER_COOLDOWN_SEC - (now - last))
|
||
return False
|
||
_user_last[acct] = now
|
||
return True
|
||
|
||
|
||
def global_wait_if_needed() -> None:
|
||
global _global_tokens, _global_last
|
||
now = time.monotonic()
|
||
elapsed = now - _global_last
|
||
_global_last = now
|
||
|
||
_global_tokens = min(float(GLOBAL_BURST), _global_tokens + elapsed * GLOBAL_RATE_PER_SEC)
|
||
|
||
if _global_tokens >= 1.0:
|
||
_global_tokens -= 1.0
|
||
return
|
||
|
||
need = (1.0 - _global_tokens) / max(GLOBAL_RATE_PER_SEC, 0.001)
|
||
logger.info("Global rate-limit wait %.2fs", need)
|
||
time.sleep(max(0.0, need))
|
||
_global_tokens = 0.0
|
||
|
||
|
||
# =======================
|
||
# TEXT HELPERS
|
||
# =======================
|
||
|
||
def strip_html(html: str) -> str:
|
||
text = re.sub(r"<[^>]+>", " ", html)
|
||
return re.sub(r"\s+", " ", text).strip()
|
||
|
||
|
||
def parse_query(content_html: str) -> Tuple[str, bool]:
|
||
text = strip_html(content_html).lower()
|
||
text = re.sub(r"@\s*[a-z0-9_]+(?:@[a-z0-9\.\-]+)?", " ", text, flags=re.I)
|
||
text = re.sub(r"\s+", " ", text).strip()
|
||
|
||
is_nsfw = bool(re.search(r"\bnsfw\b", text))
|
||
text = re.sub(r"\bnsfw\b", " ", text).strip()
|
||
text = re.sub(r"\s+", " ", text).strip()
|
||
return text, is_nsfw
|
||
|
||
|
||
def split_tags(query: str) -> List[str]:
|
||
q = (query or "").strip()
|
||
if not q:
|
||
return []
|
||
q = q.replace(",", " ")
|
||
parts = re.findall(r'"([^"]+)"|(\S+)', q)
|
||
tokens = []
|
||
for a, b in parts:
|
||
t = (a or b).strip()
|
||
if t:
|
||
tokens.append(t)
|
||
tokens = [t for t in tokens if t.lower() not in {"random", "rnd"}]
|
||
return tokens
|
||
|
||
|
||
def safe_visibility(v: str) -> str:
|
||
v = (v or "public").strip().lower()
|
||
return v if v in {"public", "unlisted", "private", "direct"} else "public"
|
||
|
||
|
||
def make_alt_text(img: Dict[str, Any], query: str, is_nsfw: bool) -> str:
|
||
tags = img.get("tags", [])
|
||
if isinstance(tags, list):
|
||
raw = [str(t).strip() for t in tags]
|
||
elif isinstance(tags, str):
|
||
raw = [t.strip() for t in tags.split(",")]
|
||
else:
|
||
raw = []
|
||
|
||
block = {"safe", "questionable", "explicit", "nsfw", "sfw", "animated", "gif"}
|
||
cleaned = []
|
||
for t in raw:
|
||
if not t:
|
||
continue
|
||
t2 = t.lower().strip()
|
||
if t2 in block:
|
||
continue
|
||
cleaned.append(t2.replace("_", " "))
|
||
|
||
seen = set()
|
||
uniq = []
|
||
for t in cleaned:
|
||
if t in seen:
|
||
continue
|
||
seen.add(t)
|
||
uniq.append(t)
|
||
|
||
prefix = "NSFW animated GIF" if is_nsfw else "Animated GIF"
|
||
if uniq:
|
||
return (f"{prefix}: " + ", ".join(uniq[:20]))[:900]
|
||
if query:
|
||
return f"{prefix} (from query): {query[:900]}"
|
||
return prefix
|
||
|
||
|
||
def source_link(img: Dict[str, Any]) -> str:
|
||
vu = img.get("view_url")
|
||
if isinstance(vu, str) and vu.startswith("http"):
|
||
return vu
|
||
img_id = img.get("id")
|
||
if img_id is not None:
|
||
return f"{FURBOORU_BASE_URL}/images/{img_id}"
|
||
return FURBOORU_BASE_URL
|
||
|
||
|
||
# =======================
|
||
# FURBOORU
|
||
# =======================
|
||
|
||
def furbooru_search_gif(query: str, nsfw: bool) -> Optional[Dict[str, Any]]:
|
||
global_wait_if_needed()
|
||
|
||
url = f"{FURBOORU_BASE_URL}/api/v1/json/search/images"
|
||
base_tags = ["animated", "gif"] if nsfw else ["safe", "animated", "gif"]
|
||
user_tags = split_tags(query)
|
||
all_tags = user_tags + base_tags
|
||
q = ", ".join(all_tags) if all_tags else ", ".join(base_tags)
|
||
|
||
params: Dict[str, Any] = {"q": q, "per_page": 50, "page": 1}
|
||
if FURBOORU_API_KEY:
|
||
params["key"] = FURBOORU_API_KEY
|
||
if nsfw and NSFW_FILTER_ID:
|
||
params["filter_id"] = NSFW_FILTER_ID
|
||
if (not nsfw) and SAFE_FILTER_ID:
|
||
params["filter_id"] = SAFE_FILTER_ID
|
||
|
||
backoff = 1.0
|
||
for attempt in range(4):
|
||
logger.info("Furbooru search attempt=%d q=%s", attempt + 1, q)
|
||
try:
|
||
r = http.get(url, params=params, timeout=(CONNECT_TIMEOUT, READ_TIMEOUT))
|
||
except requests.RequestException as e:
|
||
logger.error("Furbooru request error: %s", e)
|
||
return None
|
||
|
||
if r.status_code == 429:
|
||
logger.warning("Furbooru 429 Too Many Requests. Backoff %.1fs", backoff)
|
||
time.sleep(backoff)
|
||
backoff *= 2
|
||
continue
|
||
|
||
if r.status_code >= 400:
|
||
logger.error("Furbooru HTTP %s: %r", r.status_code, (r.text or "")[:200])
|
||
return None
|
||
|
||
try:
|
||
data = r.json()
|
||
except Exception as e:
|
||
logger.error("Furbooru JSON parse error: %s", e)
|
||
return None
|
||
|
||
images = data.get("images", [])
|
||
candidates = []
|
||
for img in images:
|
||
if img.get("format") != "gif":
|
||
continue
|
||
if not img.get("thumbnails_generated", False):
|
||
continue
|
||
reps = img.get("representations") or {}
|
||
if not any(reps.get(k) for k in ("full", "large", "medium", "small", "thumb")):
|
||
continue
|
||
candidates.append(img)
|
||
|
||
logger.info("Furbooru found=%d candidates=%d", len(images), len(candidates))
|
||
return random.choice(candidates) if candidates else None
|
||
|
||
return None
|
||
|
||
|
||
def representation_candidates(img: Dict[str, Any]) -> List[str]:
|
||
reps = img.get("representations") or {}
|
||
keys = ["full", "large", "medium", "small", "thumb"]
|
||
out: List[str] = []
|
||
for k in keys:
|
||
u = reps.get(k)
|
||
if isinstance(u, str) and u.startswith("http") and u not in out:
|
||
out.append(u)
|
||
return out
|
||
|
||
|
||
def download_bytes(url: str, max_bytes: int) -> Optional[bytes]:
|
||
logger.info("Downloading %s", url)
|
||
try:
|
||
with http.get(url, timeout=(CONNECT_TIMEOUT, DOWNLOAD_TIMEOUT), stream=True) as r:
|
||
if r.status_code >= 400:
|
||
logger.error("Download HTTP %s", r.status_code)
|
||
return None
|
||
total = 0
|
||
chunks = []
|
||
for chunk in r.iter_content(chunk_size=64 * 1024):
|
||
if not chunk:
|
||
continue
|
||
total += len(chunk)
|
||
if total > max_bytes:
|
||
raise ValueError(f"File too large (> {max_bytes} bytes)")
|
||
chunks.append(chunk)
|
||
logger.info("Downloaded bytes=%d", total)
|
||
return b"".join(chunks)
|
||
except ValueError:
|
||
raise
|
||
except requests.RequestException as e:
|
||
logger.error("Download error: %s", e)
|
||
return None
|
||
|
||
|
||
# =======================
|
||
# GIF -> MP4 (ffmpeg)
|
||
# =======================
|
||
|
||
def find_ffmpeg_exe() -> Optional[str]:
|
||
for cmd in ("ffmpeg", "ffmpeg.exe"):
|
||
try:
|
||
p = subprocess.run([cmd, "-version"], capture_output=True, text=True)
|
||
if p.returncode == 0:
|
||
return cmd
|
||
except Exception:
|
||
pass
|
||
if imageio_ffmpeg is not None:
|
||
try:
|
||
return imageio_ffmpeg.get_ffmpeg_exe()
|
||
except Exception:
|
||
return None
|
||
return None
|
||
|
||
|
||
def gif_bytes_to_mp4(gif_bytes: bytes) -> Optional[bytes]:
|
||
ffmpeg = find_ffmpeg_exe()
|
||
if not ffmpeg:
|
||
logger.error("FFmpeg not found. Install ffmpeg or `pip install imageio-ffmpeg`.")
|
||
return None
|
||
|
||
with tempfile.TemporaryDirectory() as td:
|
||
in_gif = os.path.join(td, "in.gif")
|
||
out_mp4 = os.path.join(td, "out.mp4")
|
||
|
||
with open(in_gif, "wb") as f:
|
||
f.write(gif_bytes)
|
||
|
||
cmd = [
|
||
ffmpeg, "-y",
|
||
"-i", in_gif,
|
||
"-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
|
||
"-movflags", "+faststart",
|
||
"-pix_fmt", "yuv420p",
|
||
"-c:v", "libx264",
|
||
"-preset", "veryfast",
|
||
"-crf", "28",
|
||
"-an",
|
||
out_mp4
|
||
]
|
||
|
||
try:
|
||
p = subprocess.run(cmd, capture_output=True, text=True)
|
||
except Exception as e:
|
||
logger.error("FFmpeg execution error: %s", e)
|
||
return None
|
||
|
||
if p.returncode != 0:
|
||
logger.error("FFmpeg failed: %s", (p.stderr or "")[-400:])
|
||
return None
|
||
|
||
try:
|
||
with open(out_mp4, "rb") as f:
|
||
mp4 = f.read()
|
||
logger.info("Converted GIF->MP4 bytes=%d", len(mp4))
|
||
return mp4
|
||
except Exception as e:
|
||
logger.error("Reading MP4 failed: %s", e)
|
||
return None
|
||
|
||
|
||
# =======================
|
||
# MASTODON
|
||
# =======================
|
||
|
||
def init_mastodon():
|
||
if not MASTODON_ACCESS_TOKEN:
|
||
raise SystemExit("MASTODON_ACCESS_TOKEN is empty. Put it into config.env or env vars.")
|
||
from mastodon import Mastodon
|
||
return Mastodon(
|
||
access_token=MASTODON_ACCESS_TOKEN,
|
||
api_base_url=MASTODON_BASE_URL,
|
||
user_agent=USER_AGENT,
|
||
request_timeout=max(CONNECT_TIMEOUT + READ_TIMEOUT, 10.0),
|
||
)
|
||
|
||
|
||
def upload_media(mastodon, data: bytes, mime: str, alt_text: str) -> Optional[int]:
|
||
bio = io.BytesIO(data)
|
||
bio.name = "giffer." + ("mp4" if mime == "video/mp4" else "gif")
|
||
logger.info("Uploading media mime=%s (alt_len=%d)", mime, len(alt_text))
|
||
|
||
def _call():
|
||
return mastodon.media_post(media_file=bio, mime_type=mime, description=alt_text)
|
||
|
||
media = run_with_timeout(_call, MASTO_CALL_TIMEOUT, f"mastodon.media_post({mime})")
|
||
if not media:
|
||
return None
|
||
return int(media["id"])
|
||
|
||
|
||
def wait_media_ready(mastodon, media_id: int, max_wait: float) -> bool:
|
||
start = time.time()
|
||
delay = 0.6
|
||
while time.time() - start < max_wait:
|
||
att = run_with_timeout(lambda: mastodon.media(media_id), MASTO_CALL_TIMEOUT, "mastodon.media(get)")
|
||
if att and att.get("url"):
|
||
return True
|
||
time.sleep(delay)
|
||
delay = min(delay * 1.4, 3.0)
|
||
return False
|
||
|
||
|
||
def post_reply_safe(mastodon, status_id: int, text: str, visibility: str) -> None:
|
||
def _call():
|
||
return mastodon.status_post(text, in_reply_to_id=status_id, visibility=visibility)
|
||
run_with_timeout(_call, MASTO_CALL_TIMEOUT, "mastodon.status_post(reply)")
|
||
|
||
|
||
def post_status_with_media(mastodon, status_id: int, text: str, media_id: int,
|
||
visibility: str, nsfw: bool) -> bool:
|
||
if nsfw:
|
||
def _call():
|
||
return mastodon.status_post(
|
||
text,
|
||
in_reply_to_id=status_id,
|
||
media_ids=[media_id],
|
||
sensitive=True,
|
||
spoiler_text="NSFW",
|
||
visibility=visibility,
|
||
)
|
||
res = run_with_timeout(_call, MASTO_CALL_TIMEOUT, "mastodon.status_post(nsfw)")
|
||
return res is not None
|
||
else:
|
||
def _call():
|
||
return mastodon.status_post(
|
||
text,
|
||
in_reply_to_id=status_id,
|
||
media_ids=[media_id],
|
||
visibility=visibility,
|
||
)
|
||
res = run_with_timeout(_call, MASTO_CALL_TIMEOUT, "mastodon.status_post(sfw)")
|
||
return res is not None
|
||
|
||
|
||
def is_mastodon_422_unsupported(err_msg: str) -> bool:
|
||
s = (err_msg or "").lower()
|
||
return (" 422" in s or "unprocessable" in s) and ("not supported" in s or "gif" in s or "supported" in s)
|
||
|
||
|
||
def upload_gif_then_mp4_fallback(mastodon, img: Dict[str, Any], alt: str) -> Tuple[Optional[int], str]:
|
||
urls = representation_candidates(img)
|
||
if not urls:
|
||
return None, ""
|
||
|
||
last_err = ""
|
||
|
||
# GIF attempts (big -> small)
|
||
for u in urls:
|
||
try:
|
||
gif_bytes = download_bytes(u, MAX_GIF_BYTES)
|
||
if not gif_bytes:
|
||
last_err = "download failed"
|
||
continue
|
||
mid = upload_media(mastodon, gif_bytes, "image/gif", alt)
|
||
if mid is not None:
|
||
return mid, "image/gif"
|
||
last_err = "upload timeout/none"
|
||
except Exception as e:
|
||
last_err = str(e)
|
||
if is_mastodon_422_unsupported(last_err):
|
||
logger.warning("GIF rejected (422) for %s: %s. Trying smaller...", u, last_err)
|
||
continue
|
||
logger.error("GIF upload failed hard: %s", last_err)
|
||
break
|
||
|
||
# MP4 fallback (use smallest downloadable gif)
|
||
logger.info("Trying MP4 fallback...")
|
||
gif_bytes = None
|
||
for u in reversed(urls):
|
||
b = download_bytes(u, MAX_GIF_BYTES)
|
||
if b:
|
||
gif_bytes = b
|
||
break
|
||
if not gif_bytes:
|
||
logger.error("Cannot download any GIF for MP4 conversion. Last error: %s", last_err)
|
||
return None, ""
|
||
|
||
mp4 = gif_bytes_to_mp4(gif_bytes)
|
||
if not mp4:
|
||
return None, ""
|
||
|
||
mid = upload_media(mastodon, mp4, "video/mp4", alt)
|
||
if mid is None:
|
||
return None, ""
|
||
return mid, "video/mp4"
|
||
|
||
|
||
# =======================
|
||
# MAIN LOOP
|
||
# =======================
|
||
|
||
def reply_text(prefix: str, query: str, src: str, used_mime: str) -> str:
|
||
q = query if query else "random"
|
||
note = "\n(конвертировано в MP4 из-за ограничений инстанса)" if used_mime == "video/mp4" else ""
|
||
return f"{prefix} по запросу: `{q}`{note}\nОриг: {src}"
|
||
|
||
|
||
def main():
|
||
state = load_state()
|
||
last_seen_id = state.get("last_seen_notif_id", None)
|
||
|
||
# Convert to int if it's stored as string
|
||
try:
|
||
if last_seen_id is not None:
|
||
last_seen_id = int(last_seen_id)
|
||
except Exception:
|
||
last_seen_id = None
|
||
|
||
processed_set = set(int(x) for x in state.get("processed_status_ids", []) if isinstance(x, int) or str(x).isdigit())
|
||
# normalize back into state list
|
||
state["processed_status_ids"] = list(processed_set)[-PROCESSED_CACHE_MAX:]
|
||
save_state(state)
|
||
|
||
mastodon = init_mastodon()
|
||
from mastodon import MastodonError
|
||
|
||
logger.info("Starting giffer bot on %s (Furbooru: %s)", MASTODON_BASE_URL, FURBOORU_BASE_URL)
|
||
logger.info("Loaded state: last_seen_notif_id=%s processed_cache=%d", last_seen_id, len(state["processed_status_ids"]))
|
||
|
||
while True:
|
||
logger.info("Polling mentions... since_id=%s", last_seen_id)
|
||
|
||
def _fetch():
|
||
return mastodon.notifications(types=["mention"], since_id=last_seen_id)
|
||
|
||
notifs = run_with_timeout(_fetch, MASTO_CALL_TIMEOUT, "mastodon.notifications(mention)")
|
||
if notifs is None:
|
||
time.sleep(CHECK_INTERVAL)
|
||
continue
|
||
|
||
logger.info("Got %d mention notifications", len(notifs))
|
||
|
||
for notif in reversed(notifs):
|
||
notif_id = notif.get("id")
|
||
if notif_id is not None:
|
||
try:
|
||
last_seen_id = int(notif_id)
|
||
state["last_seen_notif_id"] = last_seen_id
|
||
save_state(state) # <- important: persist immediately
|
||
except Exception:
|
||
pass
|
||
|
||
acct = notif.get("account", {}).get("acct", "unknown")
|
||
status = notif.get("status") or {}
|
||
status_id = status.get("id")
|
||
if not status_id:
|
||
continue
|
||
|
||
try:
|
||
status_id_int = int(status_id)
|
||
except Exception:
|
||
continue
|
||
|
||
# ---- NEW: don't reply twice ----
|
||
if status_id_int in processed_set:
|
||
logger.info("Skipping already processed status_id=%s", status_id_int)
|
||
continue
|
||
|
||
# mark as processed early to prevent double-processing if we crash mid-way
|
||
processed_set.add(status_id_int)
|
||
remember_processed(state, status_id_int)
|
||
save_state(state)
|
||
|
||
if not user_allowed(acct):
|
||
continue
|
||
|
||
query, is_nsfw = parse_query(status.get("content", ""))
|
||
logger.info("Mention from=%s nsfw=%s query=%r status_id=%s", acct, is_nsfw, query, status_id_int)
|
||
|
||
try:
|
||
img = furbooru_search_gif(query, is_nsfw)
|
||
if not img:
|
||
post_reply_safe(
|
||
mastodon,
|
||
status_id_int,
|
||
f"Ничего не нашёл по запросу: `{query or 'random'}` 😿",
|
||
safe_visibility(status.get("visibility", "public")),
|
||
)
|
||
continue
|
||
|
||
src = source_link(img)
|
||
alt = make_alt_text(img, query, is_nsfw)
|
||
|
||
media_id, used_mime = upload_gif_then_mp4_fallback(mastodon, img, alt)
|
||
if not media_id:
|
||
post_reply_safe(
|
||
mastodon,
|
||
status_id_int,
|
||
"Не смог загрузить (инстанс отклоняет GIF/видео или проблемы сети). Попробуй другой запрос 🙏",
|
||
safe_visibility(status.get("visibility", "public")),
|
||
)
|
||
continue
|
||
|
||
logger.info("Uploaded media_id=%s mime=%s. Waiting processing...", media_id, used_mime)
|
||
if not wait_media_ready(mastodon, media_id, max_wait=MEDIA_PROCESS_MAX_WAIT):
|
||
post_reply_safe(
|
||
mastodon,
|
||
status_id_int,
|
||
"Медиа загрузилось, но Mastodon слишком долго его обрабатывает. Попробуй ещё раз через минуту 🙏",
|
||
safe_visibility(status.get("visibility", "public")),
|
||
)
|
||
continue
|
||
|
||
visibility = safe_visibility(NSFW_VISIBILITY if is_nsfw else status.get("visibility", "public"))
|
||
text = reply_text("NSFW" if is_nsfw else "GIF", query, src, used_mime)
|
||
|
||
posted = post_status_with_media(mastodon, status_id_int, text, media_id, visibility, nsfw=is_nsfw)
|
||
if posted:
|
||
logger.info("Posted successfully for user=%s", acct)
|
||
else:
|
||
logger.error("Failed to post status for user=%s (status_id=%s)", acct, status_id_int)
|
||
|
||
except ValueError as e:
|
||
post_reply_safe(
|
||
mastodon,
|
||
status_id_int,
|
||
f"Не могу загрузить: {e}",
|
||
safe_visibility(status.get("visibility", "public")),
|
||
)
|
||
except requests.RequestException as e:
|
||
post_reply_safe(
|
||
mastodon,
|
||
status_id_int,
|
||
f"Ошибка сети: {e}",
|
||
safe_visibility(status.get("visibility", "public")),
|
||
)
|
||
except MastodonError as e:
|
||
logger.error("Mastodon error: %s", e)
|
||
except Exception as e:
|
||
logger.exception("Unexpected error: %s", e)
|
||
post_reply_safe(
|
||
mastodon,
|
||
status_id_int,
|
||
f"Неожиданная ошибка: {e}",
|
||
safe_visibility(status.get("visibility", "public")),
|
||
)
|
||
|
||
time.sleep(CHECK_INTERVAL)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|