#!/usr/bin/env python3 # Copyright (c) 2026 Krzysztof Rudnicki. MIT licence. """Regenerate ``signal_bot/traps.json`` from Wikimedia Commons. Run this by hand; the output is committed, so the bot never searches Commons at the moment somebody types ``!puƂapka``. **The file holds page ids, not filenames, and that is load-bearing.** Commons filenames are free text carrying people's names -- the harvest turns up things like ``"Fishing-Boat with Fishermen" - Vasileios Chatzis.jpg``. Committing two thousand of those would eventually collide with a label somebody minted from the chat with ``!add_photo``, and ``scripts/check_personal_data.py`` would then refuse every commit for good, over data nobody can edit out by hand. An integer cannot carry a name. ``prop=imageinfo`` accepts ``pageids=`` and puts ``thumburl`` at the same place ``titles=`` does, so nothing downstream cares. The API plumbing -- the retry loop, the continuation handling, the licence filter and the depth-of-one rule -- lives in ``commons_api.py``, which ``gen_art.py`` shares. """ from __future__ import annotations import argparse import json import sys from pathlib import Path from typing import Final import commons_api import commons_harvest CATEGORIES_FILE: Final = Path(__file__).with_name("trap_categories.json") USER_AGENT: Final = "signal-bot traps generator (https://github.com/kuhyx/signal-bot)" # A harvest smaller than this is a truncated one, and committing it would # quietly shrink the command's whole world. MINIMUM: Final = 500 def categories() -> tuple[tuple[str, ...], frozenset[str], tuple[str, ...]]: """Return the seeds, the pruned set and the pruned patterns.""" document = json.loads(CATEGORIES_FILE.read_text(encoding="utf-8")) return ( tuple(document["seeds"]), frozenset(document["excluded"]), tuple(document["prune_patterns"]), ) def harvest() -> dict[int, str]: """Page id to title, for every usable file one step from the seeds.""" seeds, excluded, patterns = categories() commons_api.verify_seeds(seeds, USER_AGENT) return commons_harvest.walk(seeds, excluded, patterns, USER_AGENT) def _rejection(traps: dict[int, str]) -> str: """Return why this harvest must not be written, or an empty string.""" if len(traps) < MINIMUM: return f"got {len(traps)} traps, expected at least {MINIMUM}" return "" def main() -> int: """Write traps.json, refusing to write a harvest that failed its own checks.""" parser = argparse.ArgumentParser(description="Regenerate signal_bot/traps.json.") parser.add_argument( "--titles", action="store_true", help="print every kept title; the committed file is integers, so this is the review", ) arguments = parser.parse_args() traps = commons_harvest.licensed(harvest(), USER_AGENT) rejection = _rejection(traps) if rejection: sys.stderr.write(f"refusing to write: {rejection}\n") return 1 if arguments.titles: for page in sorted(traps): sys.stdout.write(f"{page}\t{traps[page]}\n") out = Path(__file__).resolve().parent.parent / "signal_bot" / "traps.json" document = {"source": str(CATEGORIES_FILE.name), "traps": sorted(traps)} out.write_text(json.dumps(document, ensure_ascii=False, indent=1) + "\n", encoding="utf-8") sys.stdout.write(f"wrote {len(traps)} traps to {out}\n") return 0 if __name__ == "__main__": raise SystemExit(main())