mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-11 19:34:05 +01:00
Krzysztof kuhy Rudnicki
48957a105d
Some checks are pending
CI / check (push) Waiting to run
You asked for !add_photo in testbot without the real album being reachable there. One album cannot do that: its people.json "groups" list *is* the privacy guarantee, so making the commands exist in a second group necessarily makes the real photos postable there. So the bot now loads several albums. PHOTO_PACK_DIR takes a comma-separated list, the spelling GROUP_IDS and TRUSTED_INVITERS already use. Each album carries its own group scope, its own people, its own tags and its own custom labels; they share nothing but the process they run in. That makes trigger collisions between albums legal for the first time, and the registry had to learn it. Two albums are two different sets of people and both may reasonably call somebody "!alfa" -- no message can ever mean both, because a command a group is not scoped to is not a command there at all. So a trigger may be claimed more than once, and DuplicateTriggerError now fires only where the group sets *overlap*. Overlapping albums are refused at startup rather than resolved by registration order: a coin toss about which private album receives a photo is the outcome this whole design exists to prevent. Two consequences worth naming: - registry.resolve() takes an optional group. Without one it still answers "does anything claim this word", which is what pack_add's mint check wants; with one it answers "what runs here", which is what the dispatcher wants. resolve_with_args no longer resolves-then-checks, because with two claimants the first one found may be the wrong group's. - CommandContext moved to signal_bot/context.py to keep registry.py under the 250-line cap. A filing change: that file is "which word runs what", this one is "what the thing that runs may do". DOCS-add-photo.md is likewise a split, not new prose -- DOCS-photo-pack.md had grown past the cap and the ingest path is its own subject now. Verified live: the unit serves both albums, the real group resolves its 13 album commands and testbot its 7, and !losowe / !alfa / !dodaj all fire in testbot through the live dispatcher. 997 tests, 100% branch coverage, 28 e2e scenarios. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JqqE22jp94B1ypwxppdr1o
96 lines
3.3 KiB
Python
96 lines
3.3 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""``!random``: a photo from the album, optionally narrowed by custom tags.
|
|
|
|
Custom tags define no commands of their own -- that is what keeps a hot-swap
|
|
a data swap -- so this is the only door to a label ``!add_photo`` minted.
|
|
|
|
Its resolver is deliberately **not** the one ``!add_photo`` uses. That one
|
|
mints a key for a label nobody has; if ``!random`` shared it, every typo here
|
|
would quietly create a tag, and the album would fill with keys nobody can
|
|
reach. An unknown label resolves to a sentinel instead and is answered with
|
|
the same line as a combination nobody photographed -- from the group's side
|
|
those are the same question.
|
|
|
|
Labels only, never people: ``!alfa`` already exists for those, and a second
|
|
entrance with an unscoped argument list is one too many.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
from typing import TYPE_CHECKING, Final
|
|
|
|
from signal_bot.pack import MAX_NAMES, media_type
|
|
from signal_bot.pack_command import NAME_PREFIX, NO_PHOTO, UNKNOWN, pick
|
|
|
|
if TYPE_CHECKING:
|
|
from signal_bot.context import CommandContext
|
|
from signal_bot.decorators import Decorator
|
|
from signal_bot.pack_holder import PackHolder
|
|
from signal_bot.registry import ArgResolver, CommandRegistry, Handler
|
|
|
|
COMMAND_NAME: Final = f"{NAME_PREFIX}random"
|
|
|
|
DESCRIPTION: Final = "losowe zdjęcie z albumu, opcjonalnie po etykiecie"
|
|
|
|
|
|
def random_resolver(holder: PackHolder) -> ArgResolver:
|
|
"""Turn typed labels into custom-tag keys, minting nothing.
|
|
|
|
Reads through the holder rather than closing over a Pack, so a tag
|
|
minted at 12:00 resolves at 12:01 without a restart.
|
|
"""
|
|
|
|
def resolve(words: tuple[str, ...]) -> tuple[str, ...]:
|
|
custom = holder.pack.custom
|
|
return tuple(custom.resolve(word) or UNKNOWN for word in words)
|
|
|
|
return resolve
|
|
|
|
|
|
def random_handler(holder: PackHolder) -> Handler:
|
|
"""Build the handler that answers ``!random``."""
|
|
|
|
async def handler(ctx: CommandContext) -> None:
|
|
keys = ctx.args
|
|
# The ceiling is applied to the label list directly rather than
|
|
# through candidate_keysets, whose ">=" is written against a
|
|
# head-plus-tail shape that !random does not have.
|
|
if len(keys) > MAX_NAMES or UNKNOWN in keys:
|
|
await ctx.reply(NO_PHOTO)
|
|
return
|
|
pack = holder.pack
|
|
# An empty frozenset is a superset test that every file passes, so
|
|
# bare !random needs no separate path through here.
|
|
viable = pack.matching(frozenset(keys))
|
|
if not viable:
|
|
await ctx.reply(NO_PHOTO)
|
|
return
|
|
filename = pick(viable)
|
|
payload = base64.b64encode(pack.media_path(filename).read_bytes()).decode("ascii")
|
|
await ctx.reply_media(payload, media_type(filename), filename)
|
|
|
|
return handler
|
|
|
|
|
|
def register_random_command(
|
|
registry: CommandRegistry,
|
|
holder: PackHolder,
|
|
triggers: tuple[str, ...],
|
|
*,
|
|
decorate: Decorator | None = None,
|
|
) -> None:
|
|
"""Register ``!random``, scoped to the album's own groups."""
|
|
handler = random_handler(holder)
|
|
if decorate is not None:
|
|
handler = decorate(handler)
|
|
registry.register(
|
|
COMMAND_NAME,
|
|
triggers,
|
|
handler,
|
|
DESCRIPTION,
|
|
groups=holder.pack.groups,
|
|
takes_args=True,
|
|
arg_resolver=random_resolver(holder),
|
|
)
|