Minz
7b3c358b05
Shows what's happening right now underneath the table (connecting, resolving the friend, discovering targets, fetching channel history, waiting out a jittered delay before reacting, sending a reaction, removing a reaction during --undo, etc). Status updates are cheap and DB-free, using the last fetched stats for re-rendering.
93 lines
3.7 KiB
Python
93 lines
3.7 KiB
Python
import asyncio
|
|
import datetime
|
|
import logging
|
|
from typing import Awaitable, Callable, Optional
|
|
|
|
import discord
|
|
|
|
from bot.discovery import Target
|
|
from bot.display import StatsDisplay
|
|
from bot.storage import Storage
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
ReactFn = Callable[[discord.Message, Target], Awaitable[bool]]
|
|
|
|
|
|
async def scan_channel_backlog(
|
|
storage: Storage,
|
|
channel: discord.abc.Messageable,
|
|
target: Target,
|
|
friend_id: int,
|
|
emoji: str,
|
|
cutoff: datetime.datetime,
|
|
react_fn: ReactFn,
|
|
display: Optional[StatsDisplay] = None,
|
|
) -> None:
|
|
"""Scan a channel's history once, resumably, in two phases.
|
|
|
|
Phase 1 finds every message from the friend in the window first (so the
|
|
"found" count settles before any reacting starts, rather than climbing
|
|
in lockstep with "reacted"), permanently logging each one (deduped by
|
|
message ID) so re-scanning it later never inflates the count. Phase 2
|
|
then reacts to each one in order.
|
|
|
|
Before Phase 1 even starts, any message previously logged as found for
|
|
this channel but not yet reacted to (e.g. the script was stopped midway
|
|
through Phase 2 last time) is recovered from that same log and queued
|
|
up again — this is independent of the newest_id_seen checkpoint below,
|
|
so nothing found is ever silently abandoned even if the checkpoint has
|
|
already moved past it.
|
|
"""
|
|
channel_id = getattr(channel, "id", None)
|
|
if channel_id is None:
|
|
return
|
|
chan_label = getattr(channel, "name", None) or target.name
|
|
|
|
if display is not None:
|
|
display.set_status(f"Checking {chan_label} for previously found, unreacted message(s)...")
|
|
|
|
found_messages = []
|
|
pending_ids = await asyncio.to_thread(storage.get_pending_found_message_ids, channel_id, emoji)
|
|
for message_id in pending_ids:
|
|
try:
|
|
found_messages.append(await channel.fetch_message(int(message_id)))
|
|
except discord.NotFound:
|
|
pass # message (or its channel access) is gone since it was found
|
|
except discord.HTTPException:
|
|
log.exception("Failed to refetch pending message %s in channel %s", message_id, channel_id)
|
|
|
|
state = await asyncio.to_thread(storage.get_scan_state, channel_id)
|
|
newest_id_seen = int(state["newest_id_seen"]) if state and state.get("newest_id_seen") else None
|
|
after = discord.Object(id=newest_id_seen) if newest_id_seen else cutoff
|
|
|
|
if display is not None:
|
|
display.set_status(f"Fetching message history for {chan_label}...")
|
|
|
|
try:
|
|
async for message in channel.history(after=after, oldest_first=True, limit=None):
|
|
if newest_id_seen is None or message.id > newest_id_seen:
|
|
newest_id_seen = message.id
|
|
|
|
if message.author.id == friend_id:
|
|
found_messages.append(message)
|
|
await asyncio.to_thread(
|
|
storage.record_message_found, message.id, channel_id, target.target_id, friend_id
|
|
)
|
|
if display is not None:
|
|
display.set_status(f"Scanning {chan_label} — {len(found_messages)} found so far...")
|
|
await display.refresh()
|
|
|
|
await asyncio.to_thread(storage.set_scan_state, channel_id, target.target_id, newest_id_seen, True)
|
|
except discord.Forbidden:
|
|
log.warning("No access to channel %s (%s), skipping", channel_id, getattr(channel, "name", ""))
|
|
return
|
|
except discord.HTTPException:
|
|
log.exception("HTTP error scanning channel %s", channel_id)
|
|
return
|
|
|
|
for i, message in enumerate(found_messages, start=1):
|
|
if display is not None:
|
|
display.set_status(f"Reacting to message {i}/{len(found_messages)} in {chan_label}...")
|
|
await react_fn(message, target)
|