mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-10 19:17:02 +01:00
Krzysztof kuhy Rudnicki
405541be9b
One row per command attempt, not two aggregates written only on success. command_uses holds last-use only and daily_uses counts successes; both are rate-limiter state and both are written by store.record_use, which the dispatcher calls only when a handler returns cleanly. A gate refusal and a crash returned before it, so a command that failed every time looked exactly like one nobody ran, and nothing knew which command a counted message was. command_events now takes every attempt with its outcome, its duration and the item it served; upstream_calls takes every outbound request made while serving one. The two writes stay separate on purpose -- recording a refusal as a use is what slid the cooldown window forward every time somebody was told to wait -- and test_dispatcher_outcomes asserts last_used does not move. Backfilled from journald joined against message_events, with daily_uses filling the residual so the two sources cannot double-count. Two things were wrong on the first attempt and both were found by measuring rather than by reasoning: the window has to be symmetric, because sent_at_ms comes from the sender's phone and the journal stamp from this host (194 of 299 lines landed *before* their own message, by up to 3.2 s); and matching has to be a global closest-pair assignment, because per-row greedy cannot separate two commands seconds apart. Together those took the dropped rows from 137 to zero, and recovered 418 invocations back to 29 August. Also: !analityka in the group, twelve Polish lines, naming at most three people and only ones whose display name has been seen; an Analytics tab with Nivo charts; and continuous latency measurement, which answers the open question in DOCS-latency.md -- a text send is 235 ms and an image send about 2.2 s, so the upload really is where the time goes. EPHEMERAL_TABLES was doing two unrelated jobs and is now two tuples: what a schema bump rebuilds, and what leaving a group clears. daily_uses left the first (it is a backfill source now) and stayed in the second, and _drop_reshaped took over the repair a bump used to do for it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01T4QTp3h5Q3MvfrwGV8xqPf
99 lines
3.5 KiB
Python
99 lines
3.5 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.analytics import probe
|
|
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)
|
|
# Content-addressed, for the reason pack_command records one.
|
|
probe.note_item(filename)
|
|
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),
|
|
)
|