JoinRaidCog refactored. Cleanup to all cogs.

cogs/basecog.py

 class CogSetting:
 	def __init__(self,
 			name: str,
+			datatype,
 			brief: str = None,
 			description: str = None,
 			usage: str = None,
 			max_value = None,
 			enum_values: set = None):
 		self.name = name
+		self.datatype = datatype
 		self.brief = brief
 		self.description = description or ''  # XXX: Can't be None
 		self.usage = usage
 	def add_setting(self, setting: CogSetting) -> None:
 		"""
 		Called by a subclass in __init__ to register a mod-configurable
-		guild setting. A "get" and "set" command will be generated. If the cog
-		has a command group it will be detected automatically and the commands
-		added to that. Otherwise the commands will be added at the top level.
+		guild setting. A "get" and "set" command will be generated. If the
+		setting is named "enabled" (exactly) then "enable" and "disable"
+		commands will be created instead which set the setting to True/False.
+
+		If the cog has a command group it will be detected automatically and
+		the commands added to that. Otherwise the commands will be added at
+		the top level.
 		"""
 		self.settings.append(setting)
 
 
 	def __set_up_setting_commands(self):
 		"""
-		Sets up getter and setter commands for all registered cog settings.
-		Only runs once.
+		Sets up commands for editing all registered cog settings. This method
+		only runs once.
 		"""
 		if self.are_settings_setup:
 			return
 				break
 
 		for setting in self.settings:
-			self.__make_getter_setter_commands(setting, group)
+			if setting.name == 'enabled' or setting.name == 'is_enabled':
+				self.__make_enable_disable_commands(setting, group)
+			else:
+				self.__make_getter_setter_commands(setting, group)
 
 	def __make_getter_setter_commands(self,
 			setting: CogSetting,
 		# 	async def getvar(self, context):
 		async def getter(self, context):
 			await self.__get_setting_command(context, setting)
-		async def setter(self, context, new_value):
+		async def setter_int(self, context, new_value: int):
+			await self.__set_setting_command(context, new_value, setting)
+		async def setter_float(self, context, new_value: float):
+			await self.__set_setting_command(context, new_value, setting)
+		async def setter_str(self, context, new_value: str):
+			await self.__set_setting_command(context, new_value, setting)
+		async def setter_bool(self, context, new_value: bool):
 			await self.__set_setting_command(context, new_value, setting)
 
+		setter = None
+		if setting.datatype == int:
+			setter = setter_int
+		elif setting.datatype == float:
+			setter = setter_float
+		elif setting.datatype == str:
+			setter = setter_str
+		elif setting.datatype == bool:
+			setter = setter_bool
+		else:
+			raise RuntimeError(f'Datatype {setting.datatype} unsupported')
+
 		get_command = commands.Command(
 			getter,
 			name=f'get{setting.name}',
 			self.bot.add_command(get_command)
 			self.bot.add_command(set_command)
 
+	def __make_enable_disable_commands(self,
+			setting: CogSetting,
+			group: commands.core.Group) -> None:
+		"""
+		Creates "enable" and "disable" commands.
+		"""
+		async def enabler(self, context):
+			await self.__enable_command(context, setting)
+		async def disabler(self, context):
+			await self.__disable_command(context, setting)
+
+		enable_command = commands.Command(
+			enabler,
+			name='enable',
+			brief=f'Enables {setting.brief}',
+			description=setting.description,
+			checks=[
+				commands.has_permissions(ban_members=True),
+				commands.guild_only(),
+			])
+		disable_command = commands.Command(
+			disabler,
+			name='disable',
+			brief=f'Disables {setting.brief}',
+			description=setting.description,
+			checks=[
+				commands.has_permissions(ban_members=True),
+				commands.guild_only(),
+			])
+
+		enable_command.cog = self
+		disable_command.cog = self
+
+		if group:
+			group.add_command(enable_command)
+			group.add_command(disable_command)
+		else:
+			self.bot.add_command(enable_command)
+			self.bot.add_command(disable_command)
+
 	async def __set_setting_command(self, context, new_value, setting) -> None:
 		setting_name = setting.name
 		if context.command.parent:
 		await context.message.reply(
 			f'{CONFIG["success_emoji"]} `{setting_name}` is now set to `{new_value}`',
 			mention_author=False)
+		await self.on_setting_updated(context.guild, setting)
+		self.log(context.guild, f'{context.author.name} set {key} to {new_value}')
 
 	async def __get_setting_command(self, context, setting) -> None:
 		setting_name = setting.name
 				f'{CONFIG["info_emoji"]} `{setting_name}` is set to `{value}`',
 				mention_author=False)
 
+	async def __enable_command(self, context, setting) -> None:
+		key = f'{self.__class__.__name__}.{setting.name}'
+		Storage.set_config_value(context.guild, key, True)
+		await context.message.reply(
+			f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} enabled.',
+			mention_author=False)
+		await self.on_setting_updated(context.guild, setting)
+		self.log(context.guild, f'{context.author.name} enabled {self.__class__.__name__}')
+
+	async def __disable_command(self, context, setting) -> None:
+		key = f'{self.__class__.__name__}.{setting.name}'
+		Storage.set_config_value(context.guild, key, False)
+		await context.message.reply(
+			f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} disabled.',
+			mention_author=False)
+		await self.on_setting_updated(context.guild, setting)
+		self.log(context.guild, f'{context.author.name} disabled {self.__class__.__name__}')
+
+	async def on_setting_updated(self, guild: Guild, setting: CogSetting) -> None:
+		"""
+		Subclass override point for being notified when a CogSetting is edited.
+		"""
+		pass
+
 	# Bot message handling
 
 	@classmethod

cogs/configcog.py

 
 	@config.command(
 		name='setwarningchannel',
-		brief='Sets the channel where mod warnings are posted',
+		brief='Sets where to post mod warnings',
 		description='Run this command in the channel where bot messages ' +
-			'intended for server moderators should be sent. Other bot messages ' +
-			'may still be posted in the channel a command was invoked in. If ' +
-			'no output channel is set, mod-related messages will not be posted!',
+			'intended for server moderators should be sent. Other bot ' +
+			'messages may still be posted in the channel a command was ' +
+			'invoked in. If no output channel is set, mod-related messages ' +
+			'will not be posted!',
 	)
 	async def config_setwarningchannel(self, context: commands.Context) -> None:
-		'Command handler'
 		guild: Guild = context.guild
 		channel: TextChannel = context.channel
 		Storage.set_config_value(guild, ConfigKey.WARNING_CHANNEL_ID,
 		brief='Shows the channel where mod warnings are posted',
 	)
 	async def config_getwarningchannel(self, context: commands.Context) -> None:
-		'Command handler'
 		guild: Guild = context.guild
 		channel_id = Storage.get_config_value(guild, ConfigKey.WARNING_CHANNEL_ID)
 		if channel_id is None:
 			'attention of certain users, be sure to specify a properly ' +
 			'formed @ tag, not just the name of the user/role.'
 	)
-	async def config_setwarningmention(self, context: commands.Context, mention: str = None) -> None:
+	async def config_setwarningmention(self,
+			context: commands.Context,
+			mention: str = None) -> None:
 		guild: Guild = context.guild
 		Storage.set_config_value(guild, ConfigKey.WARNING_MENTION, mention)
 		if mention is None:

cogs/crosspostcog.py

-from discord import Guild, Member, Message, PartialEmoji
-from discord.ext import commands
 from datetime import datetime, timedelta
-import math
+from discord import Guild, Member, Message
+from discord.ext import commands
 
+from cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 from config import CONFIG
 from rscollections import AgeBoundList, SizeBoundDict
-from cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
 from storage import Storage
 
 class SpamContext:
 		self.is_autobanned = False
 		self.spam_messages = set()  # of Message
 		self.deleted_messages = set()  # of Message
+		self.unique_channels = set()  # of TextChannel
 
 class CrossPostCog(BaseCog):
-	SETTING_WARN_COUNT = CogSetting('warncount',
+	"""
+	Detects a user posting the same text in multiple channels in a short period
+	of time: a common pattern for spammers. Repeated posts in the same channel
+	aren't detected, as this can often be for a reason or due to trying a
+	failed post when connectivity is poor. Minimum message length can be
+	enforced for detection. Minimum is always at least 1 to ignore posts with
+	just embeds or images and no text.
+	"""
+	SETTING_ENABLED = CogSetting('enabled', bool,
+		brief='crosspost detection',
+		description='Whether crosspost detection is enabled.')
+	SETTING_WARN_COUNT = CogSetting('warncount', int,
 		brief='number of messages to trigger a warning',
-		description='The number of identical messages to trigger a mod warning.',
+		description='The number of unique channels the same message is ' + \
+			'posted in by the same user to trigger a mod warning.',
 		usage='<count:int>',
 		min_value=2)
-	SETTING_BAN_COUNT = CogSetting('bancount',
+	SETTING_BAN_COUNT = CogSetting('bancount', int,
 		brief='number of messages to trigger a ban',
-		description='The number of identical messages to trigger an ' + \
-			'automatic ban. Set to a large value to effectively disable, e.g. 9999.',
+		description='The number of unique channels the same message is ' + \
+			'posted in by the same user to trigger an automatic ban. Set ' + \
+			'to a large value to effectively disable, e.g. 9999.',
 		usage='<count:int>',
 		min_value=2)
-	SETTING_MIN_LENGTH = CogSetting('minlength',
+	SETTING_MIN_LENGTH = CogSetting('minlength', int,
 		brief='minimum message length',
 		description='The minimum number of characters in a message to be ' + \
 			'checked for duplicates. This can help ignore common short ' + \
-			'messages like "lol" or a single emoji. Set to 0 to count all ' + \
-			'message lengths.',
+			'messages like "lol" or a single emoji.',
 		usage='<character_count:int>',
-		min_value=0)
-	SETTING_TIMESPAN = CogSetting('timespan',
+		min_value=1)
+	SETTING_TIMESPAN = CogSetting('timespan', float,
 		brief='time window to look for dupe messages',
 		description='The number of seconds of message history to look at ' + \
 			'when looking for duplicates. Shorter values are preferred, ' + \
 		usage='<seconds:int>',
 		min_value=1)
 
-	STATE_KEY_RECENT_MESSAGES = "crosspost_recent_messages"
-	STATE_KEY_SPAM_CONTEXT = "crosspost_spam_context"
-
-	CONFIG_KEY_WARN_COUNT = "crosspost_warn_count"
-	CONFIG_KEY_BAN_COUNT = "crosspost_ban_count"
-	CONFIG_KEY_MIN_MESSAGE_LENGTH = "crosspost_min_message_length"
-	CONFIG_KEY_MESSAGE_AGE = "crosspost_message_age"
+	STATE_KEY_RECENT_MESSAGES = "CrossPostCog.recent_messages"
+	STATE_KEY_SPAM_CONTEXT = "CrossPostCog.spam_context"
 
 	def __init__(self, bot):
 		super().__init__(bot)
+		self.add_setting(CrossPostCog.SETTING_ENABLED)
 		self.add_setting(CrossPostCog.SETTING_WARN_COUNT)
 		self.add_setting(CrossPostCog.SETTING_BAN_COUNT)
 		self.add_setting(CrossPostCog.SETTING_MIN_LENGTH)
 		self.add_setting(CrossPostCog.SETTING_TIMESPAN)
 		self.max_spam_contexts = 12
 
-	# Config
-
 	async def __record_message(self, message: Message) -> None:
 		if message.author.permissions_in(message.channel).ban_members:
 			# User exempt from spam detection
 			# Message too short to count towards spam total
 			return
 		max_age = timedelta(seconds=self.get_guild_setting(message.guild, self.SETTING_TIMESPAN))
-		recent_messages = Storage.get_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES) \
-			or AgeBoundList(max_age, lambda index, message : message.created_at)
+		warn_count = self.get_guild_setting(message.guild, self.SETTING_WARN_COUNT)
+		recent_messages = Storage.get_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES)
+		if recent_messages is None:
+			recent_messages = AgeBoundList(max_age, lambda index, message : message.created_at)
+			Storage.set_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES, recent_messages)
 		recent_messages.max_age = max_age
 		recent_messages.append(message)
-		Storage.set_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES, recent_messages)
 
 		# Get all recent messages by user
 		member_messages = [m for m in recent_messages if m.author.id == message.author.id]
-		if len(member_messages) < self.get_guild_setting(message.guild, self.SETTING_WARN_COUNT):
+		if len(member_messages) < warn_count:
 			return
 
 		# Look for repeats
-		hash_to_count = {}
+		hash_to_channels = {}  # int --> set(TextChannel)
 		max_count = 0
 		for m in member_messages:
 			key = hash(m.content)
-			count = (hash_to_count.get(key) or 0) + 1
-			hash_to_count[key] = count
-			max_count = max(max_count, count)
-		if max_count < self.get_guild_setting(message.guild, self.SETTING_WARN_COUNT):
+			channels = hash_to_channels.get(key)
+			if channels is None:
+				channels = set()
+				hash_to_channels[key] = channels
+			channels.add(m.channel)
+			max_count = max(max_count, len(channels))
+		if max_count < warn_count:
 			return
 
 		# Handle the spam
-		spam_lookup = Storage.get_state_value(message.guild, self.STATE_KEY_SPAM_CONTEXT) \
-			or SizeBoundDict(self.max_spam_contexts, lambda key, context : context.age)
-		Storage.set_state_value(message.guild, self.STATE_KEY_SPAM_CONTEXT, spam_lookup)
-		for message_hash, count in hash_to_count.items():
-			if count < self.get_guild_setting(message.guild, self.SETTING_WARN_COUNT):
+		spam_lookup = Storage.get_state_value(message.guild, self.STATE_KEY_SPAM_CONTEXT)
+		if spam_lookup is None:
+			spam_lookup = SizeBoundDict(
+				self.max_spam_contexts,
+				lambda key, context : context.age)
+			Storage.set_state_value(message.guild, self.STATE_KEY_SPAM_CONTEXT, spam_lookup)
+		for message_hash, channels in hash_to_channels.items():
+			channel_count = len(channels)
+			if channel_count < warn_count:
 				continue
 			key = f'{message.author.id}|{message_hash}'
 			context = spam_lookup.get(key)
 				context = SpamContext(message.author, message_hash)
 				spam_lookup[key] = context
 				context.age = message.created_at
+				self.log(message.guild,
+					f'\u0007{message.author.name} ({message.author.id}) ' + \
+					f'posted the same message in {channel_count} or more channels.')
 			for m in member_messages:
 				if hash(m.content) == message_hash:
 					context.spam_messages.add(m)
+					context.unique_channels.add(m.channel)
 			await self.__update_from_context(context)
 
 	async def __update_from_context(self, context: SpamContext):
-		if len(context.spam_messages) >= self.get_guild_setting(context.member.guild, self.SETTING_BAN_COUNT):
+		ban_count = self.get_guild_setting(context.member.guild, self.SETTING_BAN_COUNT)
+		channel_count = len(context.unique_channels)
+		if channel_count >= ban_count:
 			if not context.is_banned:
 				count = len(context.spam_messages)
-				await context.member.ban(reason=f'Autobanned by Rocketbot for posting same message {count} times', delete_message_days=1)
+				await context.member.ban(
+					reason='Rocketbot: Posted same message in ' + \
+						f'{channel_count} channels. Banned by ' + \
+						f'{self.bot.user.name}.',
+					delete_message_days=1)
 				context.is_kicked = True
 				context.is_banned = True
 				context.is_autobanned = True
 				context.deleted_messages |= context.spam_messages
-				self.log(context.member.guild, f'Bot autobanned {context.member.name} ({context.member.id}) for spamming')
+				self.log(context.member.guild,
+					f'{context.member.name} ({context.member.id}) posted ' + \
+					f'same message in {channel_count} channels. Banned by ' + \
+					f'{self.bot.user.name}.')
 			else:
 				# Already banned. Nothing to update in the message.
 				return
 	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)
+		channel_count = len(context.unique_channels)
+		deleted_count = len(context.spam_messages)
 		message = context.bot_message
 		if message is None:
 			message = BotMessage(context.member.guild, '',
 			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.'
+				f'posting the same message in {channel_count} channels. ' + \
+				'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.')
+				f'the same message in {channel_count} channels.')
 			await message.set_reactions(BotMessageReaction.standard_set(
 				did_delete = deleted_count >= spam_count,
 				message_count = spam_count,
 			await self.post_message(message)
 			context.bot_message = message
 
-	async def __delete_messages(self, context: SpamContext) -> None:
-		for message in context.spam_messages - context.deleted_messages:
-			await message.delete()
-			context.deleted_messages.add(message)
-		await self.__update_from_context(context)
-		self.log(context.member.guild, f'Mod deleted messages from {context.member.name} ({context.member.id})')
-
-	async def __kick(self, context: SpamContext) -> None:
-		await context.member.kick(reason='Posting same message repeatedly')
-		context.is_kicked = True
-		await self.__update_from_context(context)
-		self.log(context.member.guild, f'Mod kicked user {context.member.name} ({context.member.id})')
-
-	async def __ban(self, context: SpamContext) -> None:
-		await context.member.ban(reason='Posting same message repeatedly', delete_message_days=1)
-		context.deleted_messages |= context.spam_messages
-		context.is_kicked = True
-		context.is_banned = True
-		await self.__update_from_context(context)
-		self.log(context.member.guild, f'Mod banned user {context.member.name} ({context.member.id})')
-
 	async def on_mod_react(self,
 			bot_message: BotMessage,
 			reaction: BotMessageReaction,
 		if context is None:
 			return
 
+		channel_count = len(context.unique_channels)
 		if reaction.emoji == CONFIG['trash_emoji']:
-			await self.__delete_messages(context)
+			for message in context.spam_messages - context.deleted_messages:
+				await message.delete()
+				context.deleted_messages.add(message)
+			await self.__update_from_context(context)
+			self.log(context.member.guild,
+				f'{context.member.name} ({context.member.id}) posted same ' + \
+				f'message in {channel_count} channels. Deleted by {reacted_by.name}.')
 		elif reaction.emoji == CONFIG['kick_emoji']:
-			await self.__kick(context)
+			await context.member.kick(
+				reason=f'Rocketbot: Posted same message in {channel_count} ' + \
+					f'channels. Kicked by {reacted_by.name}.')
+			context.is_kicked = True
+			await self.__update_from_context(context)
+			self.log(context.member.guild,
+				f'{context.member.name} ({context.member.id}) posted same ' + \
+				f'message in {channel_count} channels. Kicked by {reacted_by.name}.')
 		elif reaction.emoji == CONFIG['ban_emoji']:
-			await self.__ban(context)
+			await context.member.ban(
+				reason=f'Rocketbot: Posted same message in {channel_count} ' + \
+					f'channels. Banned by {reacted_by.name}.',
+				delete_message_days=1)
+			context.deleted_messages |= context.spam_messages
+			context.is_kicked = True
+			context.is_banned = True
+			await self.__update_from_context(context)
+			self.log(context.member.guild,
+				f'{context.member.name} ({context.member.id}) posted same ' + \
+				f'message in {channel_count} channels. Kicked by {reacted_by.name}.')
 
 	@commands.Cog.listener()
 	async def on_message(self, message: Message):
 				message.content is None or \
 				message.content == '':
 			return
+		if not self.get_guild_setting(message.guild, self.SETTING_ENABLED):
+			return
 		await self.__record_message(message)
 
-	# -- Commands -----------------------------------------------------------
-
 	@commands.group(
-		brief='Manages crosspost/repeated post detection and handling',
+		brief='Manages crosspost detection and handling',
 	)
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def crosspost(self, context: commands.Context):
-		'Command group'
+		'Crosspost detection command group'
 		if context.invoked_subcommand is None:
 			await context.send_help()

cogs/joinraidcog.py

-from discord import Guild, Intents, Member, Message, PartialEmoji, RawReactionActionEvent
+from datetime import datetime, timedelta
+from discord import Guild, Member
 from discord.ext import commands
-from storage import Storage
-from cogs.basecog import BaseCog
-from config import CONFIG
-from datetime import datetime
-
-class JoinRecord:
-	"""
-	Data object containing details about a single guild join event.
-	"""
-	def __init__(self, member: Member):
-		self.member = member
-		self.join_time = member.joined_at or datetime.now()
-		# These flags only track whether this bot has kicked/banned
-		self.is_kicked = False
-		self.is_banned = False
-
-	def age_seconds(self, now: datetime) -> float:
-		"""
-		Returns the age of this join in seconds from the given "now" time.
-		"""
-		a = now - self.join_time
-		return float(a.total_seconds())
-
-class RaidPhase:
-	"""
-	Enum of phases in a JoinRaidRecord. Phases progress monotonically.
-	"""
-	NONE = 0
-	JUST_STARTED = 1
-	CONTINUING = 2
-	ENDED = 3
-
-class JoinRaidRecord:
-	"""
-	Tracks recent joins to a guild to detect join raids, where a large number
-	of automated users all join at the same time. Manages list of joins to not
-	grow unbounded.
-	"""
-	def __init__(self):
-		self.joins = []
-		self.phase = RaidPhase.NONE
-		# datetime when the raid started, or None.
-		self.raid_start_time = None
-		# Message posted to Discord to warn of the raid. Convenience property
-		# managed by caller. Ignored by this class.
-		self.warning_message = None
-
-	def handle_join(self,
-			member: Member,
-			now: datetime,
-			max_join_count: int,
-			max_age_seconds: float) -> None:
-		"""
-		Processes a new member join to a guild and detects join raids. Updates
-		self.phase and self.raid_start_time properties.
-		"""
-		# Check for existing record for this user
-		join: JoinRecord = None
-		i: int = 0
-		while i < len(self.joins):
-			elem = self.joins[i]
-			if elem.member.id == member.id:
-				join = self.joins.pop(i)
-				join.join_time = now
-				break
-			i += 1
-		# Add new record to end
-		self.joins.append(join or JoinRecord(member))
-		# Check raid status and do upkeep
-		self.__process_joins(now, max_age_seconds, max_join_count)
-
-	def __process_joins(self,
-			now: datetime,
-			max_age_seconds: float,
-			max_join_count: int) -> None:
-		"""
-		Processes self.joins after each addition, detects raids, updates
-		self.phase, and throws out unneeded records.
-		"""
-		i: int = 0
-		recent_count: int = 0
-		should_cull: bool = self.phase == RaidPhase.NONE
-		while i < len(self.joins):
-			join: JoinRecord = self.joins[i]
-			age: float = join.age_seconds(now)
-			is_old: bool = age > max_age_seconds
-			if not is_old:
-				recent_count += 1
-			if is_old and should_cull:
-				self.joins.pop(i)
-			else:
-				i += 1
-		is_raid = recent_count > max_join_count
-		if is_raid:
-			if self.phase == RaidPhase.NONE:
-				self.phase = RaidPhase.JUST_STARTED
-				self.raid_start_time = now
-			elif self.phase == RaidPhase.JUST_STARTED:
-				self.phase = RaidPhase.CONTINUING
-		elif self.phase == self.phase in (RaidPhase.JUST_STARTED, RaidPhase.CONTINUING):
-			self.phase = RaidPhase.ENDED
-
-		# Undo join add if the raid is over
-		if self.phase == RaidPhase.ENDED and len(self.joins) > 0:
-			last = self.joins.pop(-1)
-
-	async def kick_all(self,
-			reason: str = "Part of join raid") -> list[Member]:
-		"""
-		Kicks all users in this join raid. Skips users who have already been
-		flagged as having been kicked or banned. Returns a List of Members
-		who were newly kicked.
-		"""
-		kicks = []
-		guild = None
-		for join in self.joins:
-			guild = join.member.guild
-			if join.is_kicked or join.is_banned:
-				continue
-			await join.member.kick(reason=reason)
-			join.is_kicked = True
-			kicks.append(join.member)
-		self.phase = RaidPhase.ENDED
-		if len(kicks) > 0:
-			self.log(guild, f'Mod kicked {len(kicks)} people')
-		return kicks
-
-	async def ban_all(self,
-			reason: str = "Part of join raid",
-			delete_message_days: int = 0) -> list[Member]:
-		"""
-		Bans all users in this join raid. Skips users who have already been
-		flagged as having been banned. Users who were previously kicked can
-		still be banned. Returns a List of Members who were newly banned.
-		"""
-		bans = []
-		guild = None
-		for join in self.joins:
-			guild = join.member.guild
-			if join.is_banned:
-				continue
-			await join.member.ban(
-				reason=reason,
-				delete_message_days=delete_message_days)
-			join.is_banned = True
-			bans.append(join.member)
-		self.phase = RaidPhase.ENDED
-		if len(bans) > 0:
-			self.log(guild, f'Mod banned {len(bans)} people')
-		return bans
+import weakref
 
-class GuildContext:
-	"""
-	Logic and state for a single guild serviced by the bot.
-	"""
-	def __init__(self, guild_id: int):
-		self.guild_id = guild_id
-		# Non-persisted runtime state
-		self.current_raid = JoinRaidRecord()
-		self.all_raids = [ self.current_raid ] # periodically culled of old ones
-
-	def reset_raid(self, now: datetime):
-		"""
-		Retires self.current_raid and creates a new empty one.
-		"""
-		self.current_raid = JoinRaidRecord()
-		self.all_raids.append(self.current_raid)
-		self.__cull_old_raids(now)
-
-	def find_raid_for_message_id(self, message_id: int) -> JoinRaidRecord:
-		"""
-		Retrieves a JoinRaidRecord instance for the given raid warning message.
-		Returns None if not found.
-		"""
-		for raid in self.all_raids:
-			if raid.warning_message is not None and raid.warning_message.id == message_id:
-				return raid
-		return None
+from cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
+from config import CONFIG
+from rscollections import AgeBoundList
+from storage import Storage
 
-	def __cull_old_raids(self, now: datetime):
-		"""
-		Gets rid of old JoinRaidRecord records from self.all_raids that are too
-		old to still be useful.
-		"""
-		i: int = 0
-		while i < len(self.all_raids):
-			raid = self.all_raids[i]
-			if raid == self.current_raid:
-				i += 1
-				continue
-			age_seconds = float((raid.raid_start_time - now).total_seconds())
-			if age_seconds > 86400.0:
-				self.__trace('Culling old raid')
-				self.all_raids.pop(i)
-			else:
-				i += 1
+class JoinRaidContext:
+	def __init__(self, join_members: list):
+		self.join_members = list(join_members)
+		self.kicked_members = set()
+		self.banned_members = set()
+		self.warning_message_ref = None
 
-	def __trace(self, message):
-		"""
-		Debugging trace.
-		"""
-		print(f'{self.guild_id}: {message}')
+	def last_join_time(self) -> datetime:
+		return self.join_members[-1].joined_at
 
 class JoinRaidCog(BaseCog):
 	"""
 	Cog for monitoring member joins and detecting potential bot raids.
 	"""
-	MIN_JOIN_COUNT = 2
-
-	STATE_KEY_RAID_COUNT = 'joinraid_count'
-	STATE_KEY_RAID_SECONDS = 'joinraid_seconds'
-	STATE_KEY_ENABLED = 'joinraid_enabled'
+	SETTING_ENABLED = CogSetting('enabled', bool,
+			brief='join raid detection',
+			description='Whether this cog is enabled for a guild.')
+	SETTING_JOIN_COUNT = CogSetting('joincount', int,
+			brief='number of joins to trigger a warning',
+			description='The number of joins occuring within the time ' + \
+				'window to trigger a mod warning.',
+			usage='<count:int>',
+			min_value=2)
+	SETTING_JOIN_TIME = CogSetting('jointime', float,
+			brief='time window length to look for joins',
+			description='The number of seconds of join history to look ' + \
+				'at when counting recent joins. If joincount or more ' + \
+				'joins occur within jointime seconds a mod warning is issued.',
+			usage='<seconds:float>',
+			min_value=1.0,
+			max_value=900.0)
+
+	STATE_KEY_RECENT_JOINS = "JoinRaidCog.recent_joins"	
+	STATE_KEY_LAST_RAID = "JoinRaidCog.last_raid"
 
 	def __init__(self, bot):
 		super().__init__(bot)
-		self.guild_id_to_context = {}  # Guild.id -> GuildContext
-
-	# -- Config -------------------------------------------------------------
-
-	def __get_raid_rate(self, guild: Guild) -> tuple:
-		"""
-		Returns the join rate configured for this guild.
-		"""
-		count: int = Storage.get_config_value(guild, self.STATE_KEY_RAID_COUNT) \
-			or self.get_cog_default('warning_count')
-		seconds: float = Storage.get_config_value(guild, self.STATE_KEY_RAID_SECONDS) \
-			or self.get_cog_default('warning_seconds')
-		return (count, seconds)
-
-	def __is_enabled(self, guild: Guild) -> bool:
-		"""
-		Returns whether join raid detection is enabled in this guild.
-		"""
-		return Storage.get_config_value(guild, self.STATE_KEY_ENABLED) \
-			or self.get_cog_default('enabled')
-
-	# -- Commands -----------------------------------------------------------
+		self.add_setting(JoinRaidCog.SETTING_ENABLED)
+		self.add_setting(JoinRaidCog.SETTING_JOIN_COUNT)
+		self.add_setting(JoinRaidCog.SETTING_JOIN_TIME)
 
 	@commands.group(
 		brief='Manages join raid detection and handling',
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
-	@joinraid.command(
-		name='enable',
-		brief='Enables join raid detection',
-		description='Join raid detection is off by default.',
-	)
-	async def joinraid_enable(self, context: commands.Context):
-		'Command handler'
-		guild = context.guild
-		Storage.set_config_value(guild, self.STATE_KEY_ENABLED, True)
-		# TODO: Startup tracking if necessary
-		await context.message.reply(
-			CONFIG['success_emoji'] + ' ' +
-			self.__describe_raid_settings(guild, force_enabled_status=True),
-			mention_author=False)
-
-	@joinraid.command(
-		name='disable',
-		brief='Disables join raid detection',
-		description='Join raid detection is off by default.',
-	)
-	async def joinraid_disable(self, context: commands.Context):
-		'Command handler'
-		guild = context.guild
-		Storage.set_config_value(guild, self.STATE_KEY_ENABLED, False)
-		# TODO: Tear down tracking if necessary
-		await context.message.reply(
-			CONFIG['success_emoji'] + ' ' +
-			self.__describe_raid_settings(guild, force_enabled_status=True),
-			mention_author=False)
-
-	@joinraid.command(
-		name='setrate',
-		brief='Sets the rate of joins which triggers a warning to mods',
-		description='Each time a member joins, the join records from the ' +
-			'previous _x_ seconds are counted up, where _x_ is the number of ' +
-			'seconds configured by this command. If that count meets or ' +
-			'exceeds the maximum join count configured by this command then ' +
-			'a raid is detected and a warning is issued to the mods.',
-		usage='<join_count:int> <seconds:float>',
-	)
-	async def joinraid_setrate(self, context: commands.Context,
-			join_count: int,
-			seconds: float):
-		'Command handler'
-		guild = context.guild
-		if join_count < self.MIN_JOIN_COUNT:
-			await context.message.reply(
-				CONFIG['warning_emoji'] + ' ' +
-				f'`join_count` must be >= {self.MIN_JOIN_COUNT}',
-				mention_author=False)
-			return
-		if seconds <= 0:
-			await context.message.reply(
-				CONFIG['warning_emoji'] + ' ' +
-				f'`seconds` must be > 0',
-				mention_author=False)
-			return
-		Storage.set_config_values(guild, {
-			self.STATE_KEY_RAID_COUNT: join_count,
-			self.STATE_KEY_RAID_SECONDS: seconds,
-		})
-
-		await context.message.reply(
-			CONFIG['success_emoji'] + ' ' +
-			self.__describe_raid_settings(guild, force_rate_status=True),
-			mention_author=False)
-
-	@joinraid.command(
-		name='getrate',
-		brief='Shows the rate of joins which triggers a warning to mods',
-	)
-	async def joinraid_getrate(self, context: commands.Context):
-		'Command handler'
-		await context.message.reply(
-			CONFIG['info_emoji'] + ' ' +
-			self.__describe_raid_settings(context.guild, force_rate_status=True),
-			mention_author=False)
-
-	# -- Listeners ----------------------------------------------------------
-
-	@commands.Cog.listener()
-	async def on_raw_reaction_add(self, payload: RawReactionActionEvent):
-		'Event handler'
-		if payload.user_id == self.bot.user.id:
-			# Ignore bot's own reactions
-			return
-		member: Member = payload.member
-		if member is None:
-			return
-		guild: Guild = self.bot.get_guild(payload.guild_id)
-		if guild is None:
-			# Possibly a DM
-			return
-		channel: GuildChannel = guild.get_channel(payload.channel_id)
-		if channel is None:
-			# Possibly a DM
-			return
-		message: Message = await channel.fetch_message(payload.message_id)
-		if message is None:
-			# Message deleted?
-			return
-		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
-			# TODO: Remove reaction?
-			return
-		gc: GuildContext = self.__get_guild_context(guild)
-		raid: JoinRaidRecord = gc.find_raid_for_message_id(payload.message_id)
-		if raid is None:
-			# Either not a warning message or one we stopped tracking
-			return
-		emoji: PartialEmoji = payload.emoji
-		if emoji.name == CONFIG['kick_emoji']:
-			await raid.kick_all()
-			gc.reset_raid(message.created_at)
-			await self.__update_raid_warning(guild, raid)
-		elif emoji.name == CONFIG['ban_emoji']:
-			await raid.ban_all()
-			gc.reset_raid(message.created_at)
-			await self.__update_raid_warning(guild, raid)
+	async def on_mod_react(self,
+			bot_message: BotMessage,
+			reaction: BotMessageReaction,
+			reacted_by: Member) -> None:
+		guild: Guild = bot_message.guild
+		raid: JoinRaidRecord = bot_message.context
+		if reaction.emoji == CONFIG['kick_emoji']:
+			to_kick = set(raid.join_members) - raid.kicked_members
+			for member in to_kick:
+				await member.kick(
+					reason=f'Rocketbot: Part of join raid. Kicked by {reacted_by.name}.')
+			raid.kicked_members |= to_kick
+			await self.__update_warning_message(raid)
+			self.log(guild, f'Join raid users kicked by {reacted_by.name}.')
+		elif reaction.emoji == CONFIG['ban_emoji']:
+			to_ban = set(raid.join_members) - raid.banned_members
+			for member in to_ban:
+				await member.ban(
+					reason=f'Rocketbot: Part of join raid. Banned by {reacted_by.name}.',
+					delete_message_days=0)
+			raid.banned_members |= to_ban
+			await self.__update_warning_message(raid)
+			self.log(guild, f'Join raid users banned by {reacted_by.name}')
 
 	@commands.Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
 		'Event handler'
 		guild: Guild = member.guild
-		if not self.__is_enabled(guild):
+		if not self.get_guild_setting(guild, self.SETTING_ENABLED):
 			return
-		(count, seconds) = self.__get_raid_rate(guild)
-		now = member.joined_at
-		gc: GuildContext = self.__get_guild_context(guild)
-		raid: JoinRaidRecord = gc.current_raid
-		raid.handle_join(member, now, count, seconds)
-		if raid.phase == RaidPhase.JUST_STARTED:
-			await self.__post_raid_warning(guild, raid)
-		elif raid.phase == RaidPhase.CONTINUING:
-			await self.__update_raid_warning(guild, raid)
-		elif raid.phase == RaidPhase.ENDED:
-			# First join that occurred too late to be part of last raid. Join
-			# not added. Start a new raid record and add it there.
-			gc.reset_raid(now)
-			gc.current_raid.handle_join(member, now, count, seconds)
-
-	# -- Misc ---------------------------------------------------------------
-
-	def __describe_raid_settings(self,
-			guild: Guild,
-			force_enabled_status=False,
-			force_rate_status=False) -> str:
-		"""
-		Creates a Discord message describing the current join raid settings.
-		"""
-		enabled = self.__is_enabled(guild)
-		(count, seconds) = self.__get_raid_rate(guild)
-
-		sentences = []
-
-		if enabled or force_rate_status:
-			sentences.append(f'Join raids will be detected at {count} or more joins per {seconds} seconds.')
-
-		if enabled and force_enabled_status:
-				sentences.append('Raid detection enabled.')
-		elif not enabled:
-			sentences.append('Raid detection disabled.')
-
-		tips = []
-		if enabled or force_rate_status:
-			tips.append('• Use `setrate` subcommand to change detection threshold')
-		if enabled:
-			tips.append('• Use `disable` subcommand to disable detection.')
+		min_count = self.get_guild_setting(guild, self.SETTING_JOIN_COUNT)
+		seconds = self.get_guild_setting(guild, self.SETTING_JOIN_TIME)
+		timespan: timedelta = timedelta(seconds=seconds)
+
+		last_raid: JoinRaidContext = Storage.get_state_value(guild, self.STATE_KEY_LAST_RAID)
+		recent_joins: AgeBoundList = Storage.get_state_value(guild, self.STATE_KEY_RECENT_JOINS)
+		if recent_joins is None:
+			recent_joins = AgeBoundList(timespan, lambda i, member : member.joined_at)
+			Storage.set_state_value(guild, self.STATE_KEY_RECENT_JOINS, recent_joins)
+		if last_raid:
+			if member.joined_at - last_raid.last_join_time() > timespan:
+				# Last raid is over
+				Storage.set_state_value(guild, self.STATE_KEY_LAST_RAID, None)
+				recent_joins.append(member)
+				return
+			# Add join to existing raid
+			last_raid.join_members.append(member)
+			await self.__update_warning_message(last_raid)
 		else:
-			tips.append('• Use `enable` subcommand to enable detection.')
-
-		message = ''
-		message += ' '.join(sentences)
-		if len(tips) > 0:
-			message += '\n\n' + ('\n'.join(tips))
-		return message
-
-	def __get_guild_context(self, guild: Guild) -> GuildContext:
-		"""
-		Looks up the GuildContext for the given Guild or creates a new one if
-		one does not yet exist.
-		"""
-		gc: GuildContext = self.guild_id_to_context.get(guild.id)
-		if gc is not None:
-			return gc
-		gc = GuildContext(guild.id)
-		gc.join_warning_count = self.get_cog_default('warning_count')
-		gc.join_warning_seconds = self.get_cog_default('warning_seconds')
-
-		self.guild_id_to_context[guild.id] = gc
-		return gc
-
-	async def __post_raid_warning(self, guild: Guild, raid: JoinRaidRecord) -> None:
-		"""
-		Posts a warning message about the given raid.
-		"""
-		(message, can_kick, can_ban) = self.__describe_raid(raid)
-		raid.warning_message = await self.warn(guild, message)
-		if can_kick:
-			await raid.warning_message.add_reaction(CONFIG['kick_emoji'])
-		if can_ban:
-			await raid.warning_message.add_reaction(CONFIG['ban_emoji'])
-		self.log(guild, f'New join raid detected!')
-
-	async def __update_raid_warning(self, guild: Guild, raid: JoinRaidRecord) -> None:
-		"""
-		Updates the existing warning message for a raid.
-		"""
-		if raid.warning_message is None:
+			# Add join to the general, non-raid recent join list
+			recent_joins.append(member)
+			if len(recent_joins) >= min_count:
+				self.log(guild, '\u0007Join raid detected')
+				last_raid = JoinRaidContext(recent_joins)
+				Storage.set_state_value(guild, self.STATE_KEY_LAST_RAID, last_raid)
+				recent_joins.clear()
+				msg = BotMessage(guild,
+						text='',
+						type=BotMessage.TYPE_MOD_WARNING,
+						context=last_raid)
+				last_raid.warning_message_ref = weakref.ref(msg)
+				await self.__update_warning_message(last_raid)
+				await self.post_message(msg)
+
+	async def on_setting_updated(self, guild: Guild, setting: CogSetting) -> None:
+		if setting is self.SETTING_JOIN_TIME:
+			seconds = self.get_guild_setting(guild, self.SETTING_JOIN_TIME)
+			timespan: timedelta = timedelta(seconds=seconds)
+			recent_joins: AgeBoundList = Storage.get_state_value(guild,
+				self.STATE_KEY_RECENT_JOINS)
+			if recent_joins:
+				recent_joins.max_age = timespan
+				recent_joins.purge_old_elements()
+
+	async def __update_warning_message(self, context: JoinRaidContext) -> None:
+		if context.warning_message_ref is None:
 			return
-		(message, can_kick, can_ban) = self.__describe_raid(raid)
-		await self.update_warn(raid.warning_message, message)
-		if not can_kick:
-			await raid.warning_message.clear_reaction(CONFIG['kick_emoji'])
-		if not can_ban:
-			await raid.warning_message.clear_reaction(CONFIG['ban_emoji'])
-
-	def __describe_raid(self, raid: JoinRaidRecord) -> tuple:
-		"""
-		Creates a Discord warning message with details about the given raid.
-		Returns a tuple containing the message text, a flag if any users can
-		still be kicked, and a flag if anyone can still be banned.
-		"""
-		message = '🚨 **JOIN RAID DETECTED** 🚨'
-		message += '\nThe following members joined in close succession:\n'
-		any_kickable = False
-		any_bannable = False
-		for join in raid.joins:
-			message += '\n• '
-			if join.is_banned:
-				message += '~~' + join.member.mention + '~~ - banned'
-			elif join.is_kicked:
-				message += '~~' + join.member.mention + '~~ - kicked'
-				any_bannable = True
+		bot_message = context.warning_message_ref()
+		if bot_message is None:
+			return
+		text = 'JOIN RAID DETECTED\n\n' + \
+			'The following members joined in close succession:\n'
+		for member in context.join_members:
+			text += '\n• '
+			if member in context.banned_members:
+				text += f'~~{member.mention} ({member.id})~~ - banned'
+			elif member in context.kicked_members:
+				text += f'~~{member.mention} ({member.id})~~ - kicked'
 			else:
-				message += join.member.mention
-				any_bannable = True
-				any_kickable = True
-		message += '\n_(list updates automatically)_'
-
-		message += '\n'
-		if any_kickable:
-			message += f'\nReact to this message with {CONFIG["kick_emoji"]} to kick all these users.'
-		else:
-			message += '\nNo users left to kick.'
-		if any_bannable:
-			message += f'\nReact to this message with {CONFIG["ban_emoji"]} to ban all these users.'
-		else:
-			message += '\nNo users left to ban.'
-
-		return (message, any_kickable, any_bannable)
+				text += f'{member.mention} ({member.id})'
+		text += '\n_(list updates automatically)_'
+		await bot_message.set_text(text)
+		member_count = len(context.join_members)
+		kick_count = len(context.kicked_members)
+		ban_count = len(context.banned_members)
+		await bot_message.set_reactions(BotMessageReaction.standard_set(
+			did_kick=kick_count >= member_count,
+			did_ban=ban_count >= member_count,
+			user_count=member_count))

cogs/patterncog.py

 					await message.author.kick(reason='Rocketbot: Message matched banned pattern')
 					text = f'Message from {message.author.mention} matched ' + \
 						'banned pattern. Message deleted and user kicked.'
-					self.log(message.guild, 'Message matched pattern. Kicked user.')
+					self.log(message.guild,
+						'\u0007Message matched pattern. Kicked ' + \
+						f'{message.author.name} ({message.author.id}).')
 				elif pattern.action == 'ban':
 					await message.delete()
 					await message.author.ban(reason='Rocketbot: Message matched banned pattern')
 					text = f'Message from {message.author.mention} matched ' + \
 						'banned pattern. Message deleted and user banned.'
-					self.log(message.guild, 'Message matched pattern. Banned user.')
+					self.log(message.guild,
+						'\u0007Message matched pattern. Banned ' + \
+						f'{message.author_name} ({message.author.id}).')
 				if text:
 					m = BotMessage(message.guild,
 						text = msg,
 			string
 			regex
 			mention
+
+		Evaluation
+			and
+			or
+			( )
+			!( )
 	"""
 
 	@commands.group(

cogs/urlspamcog.py

 		self.is_banned = False
 
 class URLSpamCog(BaseCog):
-	SETTING_ACTION = CogSetting('action',
+	"""
+	Detects users posting URLs who just joined recently: a common spam pattern.
+	Can be configured to take immediate action or just warn the mods.
+	"""
+
+	SETTING_ENABLED = CogSetting('enabled', bool,
+			brief='URL spam detection',
+			description='Whether URLs posted soon after joining are flagged.')
+	SETTING_ACTION = CogSetting('action', str,
 			brief='action to take on spam',
 			description='The action to take on detected URL spam.',
 			enum_values=set(['nothing', 'modwarn', 'delete', 'kick', 'ban']))
-	SETTING_JOIN_AGE = CogSetting('joinage',
+	SETTING_JOIN_AGE = CogSetting('joinage', float,
 			brief='seconds since member joined',
 			description='The minimum seconds since the user joined the ' + \
 				'server before they can post URLs. URLs posted by users ' + \
 
 	def __init__(self, bot):
 		super().__init__(bot)
+		self.add_setting(URLSpamCog.SETTING_ENABLED)
 		self.add_setting(URLSpamCog.SETTING_ACTION)
 		self.add_setting(URLSpamCog.SETTING_JOIN_AGE)
 
 			return
 
 		action = self.get_guild_setting(message.guild, self.SETTING_ACTION)
-		min_join_age = timedelta(seconds=self.get_guild_setting(message.guild, self.SETTING_JOIN_AGE))
+		join_seconds = self.get_guild_setting(message.guild, self.SETTING_JOIN_AGE)
+		min_join_age = timedelta(seconds=join_seconds)
 		if action == 'nothing':
 			return
 		if not self.__contains_url(message.content):
 			if action == 'modwarn':
 				needs_attention = True
 				self.log(message.guild, f'New user {message.author.name} ' + \
-					f'({message.author.id}) posted URL. Mods alerted.')
+					f'({message.author.id}) posted URL {join_age_str} after ' + \
+					'joining. Mods alerted.')
 			elif action == 'delete':
 				await message.delete()
 				context.is_deleted = True
 				self.log(message.guild, f'New user {message.author.name} ' + \
-					f'({message.author.id}) posted URL. Message deleted.')
+					f'({message.author.id}) posted URL {join_age_str} after ' + \
+					'joining. Message deleted.')
 			elif action == 'kick':
 				await message.delete()
 				context.is_deleted = True
-				await message.author.kick(reason='User posted a link ' + \
-					f'{join_age_str} after joining')
+				await message.author.kick(
+					reason=f'Rocketbot: Posted a link {join_age_str} after joining')
 				context.is_kicked = True
 				self.log(message.guild, f'New user {message.author.name} ' + \
-					f'({message.author.id}) posted URL. User kicked.')
+					f'({message.author.id}) posted URL {join_age_str} after ' + \
+					'joining. User kicked.')
 			elif action == 'ban':
-				await message.author.ban(reason='User posted a link ' + \
-					f'{join_age_str} after joining', delete_message_days=1)
+				await message.author.ban(
+					reason=f'Rocketbot: User posted a link {join_age_str} after joining',
+					delete_message_days=1)
 				context.is_deleted = True
 				context.is_kicked = True
 				context.is_banned = True
 				self.log(message.guild, f'New user {message.author.name} ' + \
-					f'({message.author.id}) posted URL. User banned.')
+					f'({message.author.id}) posted URL {join_age_str} after ' + \
+					'joining. User banned.')
 			bm = BotMessage(
 					message.guild,
 					f'User {message.author.mention} posted a URL ' + \
 			if not context.is_deleted:
 				await sm.delete()
 				context.is_deleted = True
-				self.log(sm.guild, f'URL spam by {sm.author.name} deleted by {reacted_by.name}')
+				self.log(sm.guild, f'URL spam by {sm.author.name} deleted ' + \
+					f'by {reacted_by.name}')
 		elif reaction.emoji == CONFIG['kick_emoji']:
 			if not context.is_deleted:
 				await sm.delete()
 				context.is_deleted = True
 			if not context.is_kicked:
-				await sm.author.kick(reason=f'Rocketbot: Kicked for URL spam by {reacted_by.name}')
+				await sm.author.kick(
+					reason=f'Rocketbot: Kicked for URL spam by {reacted_by.name}')
 				context.is_kicked = True
-				self.log(sm.guild, f'URL spammer {sm.author.name} kicked by {reacted_by.name}')
+				self.log(sm.guild, f'URL spammer {sm.author.name} kicked ' + \
+					f'by {reacted_by.name}')
 		elif reaction.emoji == CONFIG['ban_emoji']:
 			if not context.is_banned:
-				await sm.author.ban(reason=f'Rocketbot: Banned for URL spam by {reacted_by.name}', delete_message_days=1)
+				await sm.author.ban(
+					reason=f'Rocketbot: Banned for URL spam by {reacted_by.name}',
+					delete_message_days=1)
 				context.is_deleted = True
 				context.is_kicked = True
 				context.is_banned = True
-				self.log(sm.guild, f'URL spammer {sm.author.name} banned by {reacted_by.name}')
+				self.log(sm.guild, f'URL spammer {sm.author.name} banned ' + \
+					f'by {reacted_by.name}')
 		else:
 			return
 		await bot_message.set_reactions(BotMessageReaction.standard_set(

config.py.sample

 # Copy this file to config.py and fill in necessary values
 CONFIG = {
-	'__config_version': 2,
+	'__config_version': 3,
 	'client_token': 'token',
 	'command_prefix': '$rb_',
 	'kick_emoji': '👢',
 	'config_path': 'config/',
 	'cog_defaults': {
 		'CrossPostCog': {
+			'enabled': False,
 			'warncount': 3,
 			'bancount': 9999,
-			'minlength': 0,
+			'minlength': 1,
 			'timespan': 60,
 		},
 		'JoinRaidCog': {
 			'warning_seconds': 5,
 		},
 		'URLSpamCog': {
+			'enabled': False,
 			'joinage': 900,  # Should be > 600 due to Discord-imposed waiting period
 			'action': 'nothing',  # "nothing" | "modwarn" | "delete" | "kick" | "ban"
 		},

rocketbot.py

 from cogs.patterncog import PatternCog
 from cogs.urlspamcog import URLSpamCog
 
-CURRENT_CONFIG_VERSION = 2
+CURRENT_CONFIG_VERSION = 3
 if (CONFIG.get('__config_version') or 0) < CURRENT_CONFIG_VERSION:
     raise RuntimeError('config.py format may be outdated. Review ' +
         'config.py.sample, update the "__config_version" field to ' +
 intents.messages = True
 intents.members = True # To get join/leave events
 bot = Rocketbot(command_prefix=CONFIG['command_prefix'], intents=intents)
+
+# Core
 bot.add_cog(GeneralCog(bot))
 bot.add_cog(ConfigCog(bot))
-bot.add_cog(JoinRaidCog(bot))
+
+# Optional
 bot.add_cog(CrossPostCog(bot))
+bot.add_cog(JoinRaidCog(bot))
 bot.add_cog(PatternCog(bot))
 bot.add_cog(URLSpamCog(bot))
+
 bot.run(CONFIG['client_token'], bot=True, reconnect=True)
 print('\nBot aborted')