New bot message system. Squelching joinraid and storage log noise. Join raids beep in console.

cogs/basecog.py

-from discord import Guild, Message, PartialEmoji, RawReactionActionEvent, TextChannel
+from discord import Guild, Member, Message, PartialEmoji, RawReactionActionEvent, TextChannel
 from discord.ext import commands
-from datetime import timedelta
+from datetime import datetime, timedelta
 
 from config import CONFIG
 from rscollections import AgeBoundDict
 from storage import ConfigKey, Storage
 import json
 
+class BotMessageReaction:
+	"""
+	A possible reaction to a bot message that will trigger an action. The list
+	of available reactions will be listed at the end of a BotMessage. When a
+	mod reacts to the message with the emote, something can happen.
+
+	If the reaction is disabled, reactions will not register. The description
+	will still show up in the message, but no emoji is shown. This can be used
+	to explain why an action is no longer available.
+	"""
+	def __init__(self, emoji: str, is_enabled: bool, description: str):
+		self.emoji = emoji
+		self.is_enabled = is_enabled
+		self.description = description
+
+	def __eq__(self, other):
+		return other is not None and \
+			other.emoji == self.emoji and \
+			other.is_enabled == self.is_enabled and \
+			other.description == self.description
+
+class BotMessage:
+	"""
+	Holds state for a bot-generated message. A message is composed, sent via
+	`BaseCog.post_message()`, and can later be updated.
+
+	A message consists of a type (e.g. info, warning), text, optional quoted
+	text (such as the content of a flagged message), and an optional list of
+	actions that can be taken via a mod reacting to the message.
+	"""
+
+	TYPE_DEFAULT = 0
+	TYPE_INFO = 1
+	TYPE_MOD_WARNING = 2
+	TYPE_SUCCESS = 3
+	TYPE_FAILURE = 4
+
+	def __init__(self,
+			guild: Guild,
+			text: str,
+			type: int = 0, # TYPE_DEFAULT
+			context = None,
+			reply_to: Message = None):
+		self.guild = guild
+		self.text = text
+		self.type = type
+		self.context = context
+		self.quote = None
+		self.__posted_text = None  # last text posted, to test for changes
+		self.__posted_emoji = set()
+		self.__message = None  # Message
+		self.__reply_to = reply_to
+		self.__reactions = []  # BotMessageReaction[]
+
+	def is_sent(self) -> bool:
+		"""
+		Returns whether this message has been sent to the guild. This may
+		continue returning False even after calling BaseCog.post_message if
+		the guild has no configured warning channel.
+		"""
+		return self.__message is not None
+
+	def message_id(self):
+		return self.__message.id if self.__message else None
+
+	def message_sent_at(self):
+		return self.__message.created_at if self.__message else None
+
+	async def set_text(self, new_text: str) -> None:
+		"""
+		Replaces the text of this message. If the message has been sent, it will
+		be updated.
+		"""
+		self.text = new_text
+		await self.__update_if_sent()
+
+	async def set_reactions(self, reactions: list) -> None:
+		"""
+		Replaces all BotMessageReactions with a new list. If the message has
+		been sent, it will be updated.
+		"""
+		if reactions == self.__reactions:
+			# No change
+			return
+		self.__reactions = reactions.copy() if reactions is not None else []
+		await self.__update_if_sent()
+
+	async def add_reaction(self, reaction: BotMessageReaction) -> None:
+		"""
+		Adds one BotMessageReaction to this message. If a reaction already
+		exists for the given emoji it is replaced with the new one. If the
+		message has been sent, it will be updated.
+		"""
+		# Alias for update. Makes for clearer intent.
+		await self.update_reaction(reaction)
+
+	async def update_reaction(self, reaction: BotMessageReaction) -> None:
+		"""
+		Updates or adds a BotMessageReaction. If the message has been sent, it
+		will be updated.
+		"""
+		found = False
+		for i in range(len(self.__reactions)):
+			existing = self.__reactions[i]
+			if existing.emoji == reaction.emoji:
+				if reaction == self.__reactions[i]:
+					# No change
+					return
+				self.__reactions[i] = reaction
+				found = True
+				break
+		if not found:
+			self.__reactions.append(reaction)
+		await self.__update_if_sent()
+
+	async def remove_reaction(self, reaction_or_emoji) -> None:
+		"""
+		Removes a reaction. Can pass either a BotMessageReaction or just the
+		emoji string. If the message has been sent, it will be updated.
+		"""
+		for i in range(len(self.__reactions)):
+			existing = self.__reactions[i]
+			if (isinstance(reaction_or_emoji, str) and existing.emoji == reaction_or_emoji) or \
+				(isinstance(reaction_or_emoji, BotMessageReaction) and existing.emoji == reaction_or_emoji.emoji):
+				self.__reactions.pop(i)
+				await self.__update_if_sent()
+				return
+
+	def reaction_for_emoji(self, emoji) -> BotMessageReaction:
+		for reaction in self.__reactions:
+			if isinstance(emoji, PartialEmoji) and reaction.emoji == emoji.name:
+				return reaction
+			elif isinstance(emoji, str) and reaction.emoji == emoji:
+				return reaction
+		return None
+
+	async def __update_if_sent(self) -> None:
+		if self.__message:
+			await self._update()
+
+	async def _update(self) -> None:
+		content: str = self.__formatted_message()
+		if self.__message:
+			if content != self.__posted_text:
+				await self.__message.edit(content=content)
+				self.__posted_text = content
+		else:
+			if self.__reply_to:
+				self.__message = await self.__reply_to.reply(content=content, mention_author=False)
+				self.__posted_text = content
+			else:
+				channel_id = Storage.get_config_value(self.guild, ConfigKey.WARNING_CHANNEL_ID)
+				if channel_id is None:
+					BaseCog.guild_trace(self.guild, 'No warning channel set! No warning issued.')
+					return
+				channel: TextChannel = self.guild.get_channel(channel_id)
+				if channel is None:
+					BaseCog.guild_trace(self.guild, 'Configured warning channel does not exist!')
+					return
+				self.__message = await channel.send(content=content)
+				self.__posted_text = content
+		emoji_to_remove = self.__posted_emoji.copy()
+		for reaction in self.__reactions:
+			if reaction.is_enabled:
+				if reaction.emoji not in self.__posted_emoji:
+					await self.__message.add_reaction(reaction.emoji)
+					self.__posted_emoji.add(reaction.emoji)
+				if reaction.emoji in emoji_to_remove:
+					emoji_to_remove.remove(reaction.emoji)
+		for emoji in emoji_to_remove:
+			await self.__message.clear_reaction(emoji)
+			if emoji in self.__posted_emoji:
+				self.__posted_emoji.remove(emoji)
+
+	def __formatted_message(self) -> str:
+		s: str = ''
+
+		if self.type == self.TYPE_INFO:
+			s += CONFIG['info_emoji'] + ' '
+		elif self.type == self.TYPE_MOD_WARNING:
+			mention: str = Storage.get_config_value(self.guild, ConfigKey.WARNING_MENTION)
+			if mention:
+				s += mention + ' '
+			s += CONFIG['warning_emoji'] + ' '
+		elif self.type == self.TYPE_SUCCESS:
+			s += CONFIG['success_emoji'] + ' '
+		elif self.type == self.TYPE_FAILURE:
+			s += CONFIG['failure_emoji'] + ' '
+
+		s += self.text
+
+		if self.quote:
+			s += f'\n\n> {self.quote}'
+
+		if len(self.__reactions) > 0:
+			s += '\n\nAvailable actions:'
+			for reaction in self.__reactions:
+				if reaction.is_enabled:
+					s += f'\n   {reaction.emoji} {reaction.description}'
+				else:
+					s += f'\n   {reaction.description}'
+
+		return s
+
 class BaseCog(commands.Cog):
 	def __init__(self, bot):
 		self.bot = bot
-		self.listened_mod_react_message_ids = AgeBoundDict(timedelta(minutes=5), lambda message_id, tpl : tpl[0])
+
+	# Config
 
 	@classmethod
 	def get_cog_default(cls, key: str):
 			return None
 		return cog.get(key)
 
-	def listen_for_reactions_to(self, message: Message, context = None) -> None:
-		"""
-		Registers a warning message as something a mod may react to to enact
-		some action. `context` will be passed back in `on_mod_react` and can be
-		any value that helps give the cog context about the action being
-		performed.
-		"""
-		self.listened_mod_react_message_ids[message.id] = (message.created_at, context)
+	# Bot message handling
+
+	@classmethod
+	def __bot_messages(cls, guild: Guild) -> AgeBoundDict:
+		bm = Storage.get_state_value(guild, 'bot_messages')
+		if bm is None:
+			far_future = datetime.utcnow() + timedelta(days=1000)
+			bm = AgeBoundDict(timedelta(seconds=600),
+				lambda k, v : v.message_sent_at() or far_future)
+			Storage.set_state_value(guild, 'bot_messages', bm)
+		return bm
+
+	@classmethod
+	async def post_message(cls, message: BotMessage) -> bool:
+		await message._update()
+		guild_messages = cls.__bot_messages(message.guild)
+		if message.is_sent():
+			guild_messages[message.message_id()] = message
+			return True
+		return False
 
 	@commands.Cog.listener()
 	async def on_raw_reaction_add(self, payload: RawReactionActionEvent):
 		if message.author.id != self.bot.user.id:
 			# Bot didn't author this
 			return
-		if not member.permissions_in(channel).ban_members:
-			# Not a mod
+		guild_messages = self.__bot_messages(guild)
+		bot_message = guild_messages.get(message.id)
+		if bot_message is None:
+			# Unknown message (expired or was never tracked)
 			return
-		tpl = self.listened_mod_react_message_ids.get(message.id)
-		if tpl is None:
-			# Not a message we're listening for
+		reaction = bot_message.reaction_for_emoji(payload.emoji)
+		if reaction is None or not reaction.is_enabled:
+			# Can't use this reaction with this message
 			return
-		context = tpl[1]
-		await self.on_mod_react(message, payload.emoji, context)
+		if not member.permissions_in(channel).ban_members:
+			# Not a mod (could make permissions configurable per BotMessageReaction some day)
+			return
+		await self.on_mod_react(bot_message, reaction, member)
 
-	async def on_mod_react(self, message: Message, emoji: PartialEmoji, context) -> None:
+	async def on_mod_react(self,
+			bot_message: BotMessage,
+			reaction: BotMessageReaction,
+			reacted_by: Member) -> None:
 		"""
-		Override point for getting a mod's emote on a bot message. Used to take
-		action on a warning, such as banning an offending user. This event is
-		only triggered for registered bot messages and reactions by members
-		with the proper permissions. The given `context` value is whatever was
-		passed in `listen_to_reactions_to()`.
+		Subclass override point for receiving mod reactions to bot messages sent
+		via `post_message()`.
 		"""
 		pass
 
-	async def validate_param(self, context: commands.Context, param_name: str, value,
+	@classmethod
+	async def validate_param(cls, context: commands.Context, param_name: str, value,
 		allowed_types: tuple = None,
 		min_value = None,
 		max_value = None) -> bool:
 		to the original message and a False will be returned. If all checks
 		succeed, True will be returned.
 		"""
+		# TODO: Rework this to use BotMessage
 		if allowed_types is not None and not isinstance(value, allowed_types):
 			if len(allowed_types) == 1:
 				await context.message.reply(f'⚠️ `{param_name}` must be of type ' +

cogs/crosspostcog.py

-from discord import Guild, Message, PartialEmoji
+from discord import Guild, Member, Message, PartialEmoji
 from discord.ext import commands
 from datetime import datetime, timedelta
 import math
 
 from config import CONFIG
 from rscollections import AgeBoundList, SizeBoundDict
-from cogs.basecog import BaseCog
+from cogs.basecog import BaseCog, BotMessage, BotMessageReaction
 from storage import Storage
 
 class SpamContext:
 		self.member = member
 		self.message_hash = message_hash
 		self.age = datetime.now()
-		self.warning_message = None
+		self.bot_message = None  # BotMessage
 		self.is_kicked = False
 		self.is_banned = False
-		self.messages = set()
-		self.deleted_messages = set()
+		self.is_autobanned = False
+		self.spam_messages = set()  # of Message
+		self.deleted_messages = set()  # of Message
 
 class CrossPostCog(BaseCog):
 	STATE_KEY_RECENT_MESSAGES = "crosspost_recent_messages"
 				context.age = message.created_at
 			for m in member_messages:
 				if hash(m.content) == message_hash:
-					context.messages.add(m)
+					context.spam_messages.add(m)
 			await self.__update_from_context(context)
 
 	async def __update_from_context(self, context: SpamContext):
-		content = next(iter(context.messages)).content
-		if len(context.messages) >= self.__ban_count(context.member.guild):
+		if len(context.spam_messages) >= self.__ban_count(context.member.guild):
 			if not context.is_banned:
-				await context.member.ban(reason='Posting same message repeatedly', delete_message_days=1)
-				msg = f'User {context.member.mention} auto banned for ' + \
-					'crosspost spamming.\n' + \
-					f'> {content}'
-				if context.warning_message:
-					await self.update_warn(context.warning_message, msg)
-					await context.warning_message.clear_reaction(CONFIG['trash_emoji'])
-					await context.warning_message.clear_reaction(CONFIG['kick_emoji'])
-					await context.warning_message.clear_reaction(CONFIG['ban_emoji'])
-				else:
-					context.warning_message = await self.warn(context.member.guild, msg)
-		elif len(context.messages) >= self.__warn_count(context.member.guild):
-			content = next(iter(context.messages)).content
-			msg = f'User {context.member.mention} has posted the exact same ' + \
-				f'message {len(context.messages)} times.\n' + \
-				f'> {content}' + \
-				'\n'
-			can_delete = len(context.messages) > len(context.deleted_messages)
-			if can_delete:
-				msg += f'\n{CONFIG["trash_emoji"]} to delete messages'
+				count = len(context.spam_messages)
+				await context.member.ban(reason=f'Autobanned by Rocketbot for posting same message {count} times', delete_message_days=1)
+				context.is_kicked = True
+				context.is_banned = True
+				context.is_autobanned = True
+				context.deleted_messages |= context.spam_messages
 			else:
-				msg += '\nAll messages deleted'
-			if not context.is_kicked:
-				msg += f'\n{CONFIG["kick_emoji"]} to kick user'
-			elif not context.is_banned:
-				msg += '\nUser kicked'
-			if context.is_banned:
-				msg += '\nUser banned'
-			else:
-				msg += '\n{CONFIG["ban_emoji"]} to ban user'
-			if context.warning_message:
-				await self.update_warn(context.warning_message, msg)
-			else:
-				context.warning_message = await self.warn(context.member.guild, msg)
-				self.listen_for_reactions_to(context.warning_message, context)
-			if can_delete:
-				await context.warning_message.add_reaction(CONFIG['trash_emoji'])
-			else:
-				await context.warning_message.clear_reaction(CONFIG['trash_emoji'])
-			if not context.is_kicked:
-				await context.warning_message.add_reaction(CONFIG['kick_emoji'])
-			else:
-				await context.warning_message.clear_reaction(CONFIG['kick_emoji'])
-			if not context.is_banned:
-				await context.warning_message.add_reaction(CONFIG['ban_emoji'])
+				# Already banned. Nothing to update in the message.
+				return
+		await self.__update_message_from_context(context)
+
+	async def __update_message_from_context(self, context: SpamContext) -> None:
+		first_spam_message = next(iter(context.spam_messages))
+		spam_count = len(context.spam_messages)
+		deleted_count = len(context.deleted_messages)
+		message = context.bot_message
+		if message is None:
+			message = BotMessage(context.member.guild, '',
+				BotMessage.TYPE_MOD_WARNING, context)
+			message.quote = first_spam_message.content
+		if context.is_autobanned:
+			text = f'User {context.member.mention} auto banned for ' + \
+				f'posting the same message {deleted_count} ' + \
+				'times. Messages from past 24 hours deleted.'
+			await message.set_reactions([])
+			await message.set_text(text)
+		else:
+			await message.set_text(f'User {context.member.mention} posted ' +
+				f'the same message {spam_count} times.')
+			can_delete = spam_count > deleted_count
+			can_kick = not context.is_kicked
+			can_ban = not context.is_banned
+			await message.add_reaction(
+				BotMessageReaction(
+					CONFIG['trash_emoji'],
+					can_delete,
+					'Delete messages' if can_delete else f'Deleted {deleted_count} messages'))
+			if can_ban:
+				# Only show kick info if they can also be banned. Otherwise we say
+				# dumb stuff like "user was kicked, user was banned".
+				await message.add_reaction(
+					BotMessageReaction(
+						CONFIG['kick_emoji'],
+						can_kick,
+						'Kick user' if can_kick else 'User kicked'))
 			else:
-				await context.warning_message.clear_reaction(CONFIG['ban_emoji'])
+				await message.remove_reaction(CONFIG['kick_emoji'])
+			await message.add_reaction(
+				BotMessageReaction(
+					CONFIG['ban_emoji'], 
+					can_ban,
+					'Ban user' if can_ban else 'User banned'))
+		if context.bot_message is None:
+			await self.post_message(message)
+			context.bot_message = message
 
 	async def __delete_messages(self, context: SpamContext) -> None:
-		for message in context.messages - context.deleted_messages:
+		for message in context.spam_messages - context.deleted_messages:
 			await message.delete()
 			context.deleted_messages.add(message)
 		await self.__update_from_context(context)
 
 	async def __ban(self, context: SpamContext) -> None:
 		await context.member.ban(reason='Posting same message repeatedly', delete_message_days=1)
-		context.deleted_messages |= context.messages
+		context.deleted_messages |= context.spam_messages
 		context.is_kicked = True
 		context.is_banned = True
 		await self.__update_from_context(context)
 
-	async def on_mod_react(self, message: Message, emoji: PartialEmoji, context: SpamContext) -> None:
+	async def on_mod_react(self,
+			bot_message: BotMessage,
+			reaction: BotMessageReaction,
+			reacted_by: Member) -> None:
+		context: SpamContext = bot_message.context
 		if context is None:
 			return
 
-		if emoji.name == CONFIG['trash_emoji']:
+		if reaction.emoji == CONFIG['trash_emoji']:
 			await self.__delete_messages(context)
-		elif emoji.name == CONFIG['kick_emoji']:
+		elif reaction.emoji == CONFIG['kick_emoji']:
 			await self.__kick(context)
-		elif emoji.name == CONFIG['ban_emoji']:
+		elif reaction.emoji == CONFIG['ban_emoji']:
 			await self.__ban(context)
 
 	@commands.Cog.listener()

cogs/joinraidcog.py

 		self.phase and self.raid_start_time properties.
 		"""
 		# Check for existing record for this user
-		print(f'handle_join({member.name}) start')
 		join: JoinRecord = None
 		i: int = 0
 		while i < len(self.joins):
 			elem = self.joins[i]
 			if elem.member.id == member.id:
-				print(f'Member {member.name} already in join list at index {i}. Removing.')
 				join = self.joins.pop(i)
 				join.join_time = now
 				break
 		self.joins.append(join or JoinRecord(member))
 		# Check raid status and do upkeep
 		self.__process_joins(now, max_age_seconds, max_join_count)
-		print(f'handle_join({member.name}) end')
 
 	def __process_joins(self,
 			now: datetime,
 		Processes self.joins after each addition, detects raids, updates
 		self.phase, and throws out unneeded records.
 		"""
-		print('__process_joins {')
 		i: int = 0
 		recent_count: int = 0
 		should_cull: bool = self.phase == RaidPhase.NONE
 			is_old: bool = age > max_age_seconds
 			if not is_old:
 				recent_count += 1
-				print(f'- {i}. {join.member.name} is {age}s old - recent_count={recent_count}')
 			if is_old and should_cull:
 				self.joins.pop(i)
-				print(f'- {i}. {join.member.name} is {age}s old - too old, removing')
 			else:
-				print(f'- {i}. {join.member.name} is {age}s old - moving on to next')
 				i += 1
 		is_raid = recent_count > max_join_count
-		print(f'- is_raid {is_raid}')
 		if is_raid:
 			if self.phase == RaidPhase.NONE:
 				self.phase = RaidPhase.JUST_STARTED
 				self.raid_start_time = now
-				print('- Phase moved to JUST_STARTED. Recording raid start time.')
+				print('\u0007Join raid started!')
 			elif self.phase == RaidPhase.JUST_STARTED:
 				self.phase = RaidPhase.CONTINUING
-				print('- Phase moved to CONTINUING.')
+				print(f'\u0007Join raid up to {recent_count} people')
 		elif self.phase == self.phase in (RaidPhase.JUST_STARTED, RaidPhase.CONTINUING):
 			self.phase = RaidPhase.ENDED
-			print('- Phase moved to ENDED.')
+			print('Previous join raid ended')
 
 		# Undo join add if the raid is over
 		if self.phase == RaidPhase.ENDED and len(self.joins) > 0:
 			last = self.joins.pop(-1)
-			print(f'- Popping last join for {last.member.name}')
-		print('} __process_joins')
 
 	async def kick_all(self,
 			reason: str = "Part of join raid") -> list[Member]:
 			join.is_kicked = True
 			kicks.append(join.member)
 		self.phase = RaidPhase.ENDED
+		if len(kicks) > 0:
+			print(f'Kicked {len(kicks)} people')
 		return kicks
 
 	async def ban_all(self,
 			join.is_banned = True
 			bans.append(join.member)
 		self.phase = RaidPhase.ENDED
+		if len(bans) > 0:
+			print(f'Banned {len(bans)} people')
 		return bans
 
 class GuildContext:

cogs/urlspamcog.py

 				# TODO: Info to mods
 
 	def __contains_url(self, text: str) -> bool:
-		p = re.compile(r'http[^\s]*')
+		p = re.compile(r'http(?:s)?://[^\s]+')
 		return p.search(text) is not None
 
 	def __format_timedelta(self, timespan: timedelta) -> str:
 		m = (timespan.seconds // 60) % 60
 		s = timespan.seconds % 60
 		if d > 0:
-			parts.append(f'{d}d')
+			parts.append(f'{d} days')
 		if d > 0 or h > 0:
-			parts.append(f'{h}h')
+			parts.append(f'{h} hours')
 		if d > 0 or h > 0 or m > 0:
-			parts.append(f'{m}m')
-		parts.append(f'{s}s')
+			parts.append(f'{m} minutes')
+		parts.append(f'{s} seconds')
 		# Limit the precision to the two most significant elements
 		while len(parts) > 2:
 			parts.pop(-1)

config.py.sample

 	'ban_emoji': '🚫',
 	'trash_emoji': '🗑',
 	'success_emoji': '✅',
+	'failure_emoji': '❌',
 	'warning_emoji': '⚠️',
 	'info_emoji': 'ℹ️',
 	'config_path': 'config/',

storage.py

 
 	@classmethod
 	def __trace(cls, message: str) -> None:
-		print(f'{cls.__name__}: {message}')
+		# print(f'{cls.__name__}: {message}')
+		pass