Better config.py organization for cog defaults. All emoji come from config.

cogs/basecog.py

 		self.bot = bot
 		self.listened_mod_react_message_ids = AgeBoundDict(timedelta(minutes=5), lambda message_id, tpl : tpl[0])
 
+	@classmethod
+	def get_cog_default(cls, key: str):
+		"""
+		Convenience method for getting a cog configuration default from
+		`CONFIG['cogs'][<cogname>][<key>]`.
+		"""
+		cogs: dict = CONFIG['cog_defaults']
+		cog = cogs.get(cls.__name__)
+		if cog is None:
+			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

cogs/configcog.py

 from discord import Guild, TextChannel
 from discord.ext import commands
+
+from config import CONFIG
 from storage import ConfigKey, Storage
 from cogs.basecog import BaseCog
 
 		Storage.set_config_value(guild, ConfigKey.WARNING_CHANNEL_ID,
 			context.channel.id)
 		await context.message.reply(
-			f'Warning channel updated to {channel.mention}.',
+			f'{CONFIG["success_emoji"]} Warning channel updated to {channel.mention}.',
 			mention_author=False)
 
 	@config.command(
 		channel_id = Storage.get_config_value(guild, ConfigKey.WARNING_CHANNEL_ID)
 		if channel_id is None:
 			await context.message.reply(
-				'No warning channel is configured.',
+				f'{CONFIG["info_emoji"]} No warning channel is configured.',
 				mention_author=False)
 		else:
 			channel = guild.get_channel(channel_id)
 			await context.message.reply(
-				f'Warning channel is configured as {channel.mention}.',
+				f'{CONFIG["info_emoji"]} Warning channel is configured as {channel.mention}.',
 				mention_author=False)
 
 	@config.command(
 		Storage.set_config_value(guild, ConfigKey.WARNING_MENTION, mention)
 		if mention is None:
 			await context.message.reply(
-				'Warning messages will not tag anyone.',
+				f'{CONFIG["success_emoji"]} Warning messages will not tag anyone.',
 				mention_author=False)
 		else:
 			await context.message.reply(
-				f'Warning messages will now tag {mention}.',
+				f'{CONFIG["success_emoji"]} Warning messages will now tag {mention}.',
 				mention_author=False)
 
 	@config.command(
 		mention: str = Storage.get_config_value(guild, ConfigKey.WARNING_MENTION)
 		if mention is None:
 			await context.message.reply(
-				'No warning mention configured.',
+				f'{CONFIG["info_emoji"]} No warning mention configured.',
 				mention_author=False)
 		else:
 			await context.message.reply(
-				f'Warning messages will tag {mention}',
+				f'{CONFIG["info_emoji"]} Warning messages will tag {mention}',
 				mention_author=False)

cogs/crosspostcog.py

 from datetime import datetime, timedelta
 import math
 
+from config import CONFIG
 from rscollections import AgeBoundList, SizeBoundDict
 from cogs.basecog import BaseCog
 from storage import Storage
 	# Config
 
 	def __warn_count(self, guild: Guild) -> int:
-		return Storage.get_config_value(guild, self.CONFIG_KEY_WARN_COUNT) or 3
+		return Storage.get_config_value(guild, self.CONFIG_KEY_WARN_COUNT) or \
+			self.get_cog_default('warn_message_count')
 
 	def __ban_count(self, guild: Guild) -> int:
-		return Storage.get_config_value(guild, self.CONFIG_KEY_BAN_COUNT) or 9999
+		return Storage.get_config_value(guild, self.CONFIG_KEY_BAN_COUNT) or \
+			self.get_cog_default('ban_message_count')
 
 	def __min_message_length(self, guild: Guild) -> int:
-		return Storage.get_config_value(guild, self.CONFIG_KEY_MIN_MESSAGE_LENGTH) or 0
+		return Storage.get_config_value(guild, self.CONFIG_KEY_MIN_MESSAGE_LENGTH) or \
+			self.get_cog_default('min_message_length')
 
 	def __message_age_seconds(self, guild: Guild) -> int:
-		return Storage.get_config_value(guild, self.CONFIG_KEY_MESSAGE_AGE) or 120
+		return Storage.get_config_value(guild, self.CONFIG_KEY_MESSAGE_AGE) or \
+			self.get_cog_default('time_window_seconds')
 
 	async def __record_message(self, message: Message) -> None:
 		if message.author.permissions_in(message.channel).ban_members:
 					f'> {content}'
 				if context.warning_message:
 					await self.update_warn(context.warning_message, msg)
-					await context.warning_message.clear_reaction('🗑')
-					await context.warning_message.clear_reaction('👢')
-					await context.warning_message.clear_reaction('🚫')
+					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):
 				'\n'
 			can_delete = len(context.messages) > len(context.deleted_messages)
 			if can_delete:
-				msg += '\n🗑 to delete messages'
+				msg += f'\n{CONFIG["trash_emoji"]} to delete messages'
 			else:
 				msg += '\nAll messages deleted'
 			if not context.is_kicked:
-				msg += '\n👢 to kick user'
+				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🚫 to ban user'
+				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('🗑')
+				await context.warning_message.add_reaction(CONFIG['trash_emoji'])
 			else:
-				await context.warning_message.clear_reaction('🗑')
+				await context.warning_message.clear_reaction(CONFIG['trash_emoji'])
 			if not context.is_kicked:
-				await context.warning_message.add_reaction('👢')
+				await context.warning_message.add_reaction(CONFIG['kick_emoji'])
 			else:
-				await context.warning_message.clear_reaction('👢')
+				await context.warning_message.clear_reaction(CONFIG['kick_emoji'])
 			if not context.is_banned:
-				await context.warning_message.add_reaction('🚫')
+				await context.warning_message.add_reaction(CONFIG['ban_emoji'])
 			else:
-				await context.warning_message.clear_reaction('🚫')
+				await context.warning_message.clear_reaction(CONFIG['ban_emoji'])
 
 	async def __delete_messages(self, context: SpamContext) -> None:
 		for message in context.messages - context.deleted_messages:
 		if context is None:
 			return
 
-		if emoji.name == '🗑':
+		if emoji.name == CONFIG['trash_emoji']:
 			await self.__delete_messages(context)
-		elif emoji.name == '👢':
+		elif emoji.name == CONFIG['kick_emoji']:
 			await self.__kick(context)
-		elif emoji.name == '🚫':
+		elif emoji.name == CONFIG['ban_emoji']:
 			await self.__ban(context)
 
 	@commands.Cog.listener()
 			allowed_types=(int, ), min_value=self.MIN_WARN_COUNT):
 			return
 		Storage.set_config_value(context.guild, self.CONFIG_KEY_WARN_COUNT, warn_count)
-		await context.message.reply(f'✅ Mods will be warned if a user posts ' +
-			f'the exact same message {warn_count} or more times within ' +
+		await context.message.reply(
+			CONFIG['success_emoji'] + ' ' +
+			'Mods will be warned if a user posts the exact same message ' +
+			f'{warn_count} or more times within ' +
 			f'{self.__message_age_seconds(context.guild)} seconds.',
 			mention_author=False)
 
 			allowed_types=(int, ), min_value=self.MIN_BAN_COUNT):
 			return
 		Storage.set_config_value(context.guild, self.CONFIG_KEY_BAN_COUNT, ban_count)
-		await context.message.reply(f'✅ Users will be banned if they post ' +
-			f'the exact same message {ban_count} or more times within ' +
+		await context.message.reply(
+			CONFIG['success_emoji'] + ' ' +
+			'Users will be banned if they post the exact same message ' +
+			f'{ban_count} or more times within ' +
 			f'{self.__message_age_seconds(context.guild)} seconds.',
 			mention_author=False)
 
 		brief='Returns the number of duplicate messages to trigger an automatic ban',
 	)
 	async def joinraid_getbancount(self, context: commands.Context):
-		await context.message.reply(f'ℹ️ Users will be banned if they post ' +
-			f'the exact same message {self.__ban_count(context.guild)} or more ' +
-			f'times within {self.__message_age_seconds(context.guild)} seconds.',
+		await context.message.reply(
+			CONFIG['info_emoji'] + ' ' +
+			'Users will be banned if they post the exact same message ' +
+			f'{self.__ban_count(context.guild)} or more times within ' +
+			f'{self.__message_age_seconds(context.guild)} seconds.',
 			mention_author=False)
 
 	@crosspost.command(
 			return
 		Storage.set_config_value(context.guild, self.CONFIG_KEY_MIN_MESSAGE_LENGTH, min_length)
 		if min_length == 0:
-			await context.message.reply(f'✅ All messages will count against ' +
-				'spam counts, regardless of length.', mention_author=False)
+			await context.message.reply(
+				CONFIG['success_emoji'] + ' ' +
+				f'All messages will count against spam counts, regardless ' +
+				'of length.', mention_author=False)
 		else:
-			await context.message.reply(f'✅ Only messages {min_length} ' +
-				f'characters or longer will count against spam counts.',
+			await context.message.reply(
+				CONFIG['success_emoji'] + ' ' +
+				f'Only messages {min_length} characters or longer will ' +
+				'count against spam counts.',
 				mention_author=False)
 
 	@crosspost.command(
 	async def joinraid_getminlength(self, context: commands.Context):
 		min_length = self.__min_message_length(context.guild)
 		if min_length == 0:
-			await context.message.reply(f'ℹ️ All messages will count against ' +
-				'spam counts, regardless of length.', mention_author=False)
+			await context.message.reply(
+				CONFIG['info_emoji'] + ' ' +
+				f'All messages will count against spam counts, regardless ' +
+				'of length.', mention_author=False)
 		else:
-			await context.message.reply(f'ℹ️ Only messages {min_length} ' +
-				f'characters or longer will count against spam counts.',
+			await context.message.reply(
+				CONFIG['info_emoji'] + ' ' +
+				f'Only messages {min_length} characters or longer will ' +
+				'count against spam counts.',
 				mention_author=False)
 
 	@crosspost.command(
 			allowed_types=(int, ), min_value=self.MIN_TIME_SPAN):
 			return
 		Storage.set_config_value(context.guild, self.CONFIG_KEY_MESSAGE_AGE, seconds)
-		await context.message.reply(f'✅ Only messages in the past {seconds} ' +
-			f'seconds will be checked for duplicates.',
+		await context.message.reply(
+			CONFIG['success_emoji'] + ' ' +
+			f'Only messages in the past {seconds} seconds will be checked ' +
+			'for duplicates.',
 			mention_author=False)
 
 	@crosspost.command(
 	)
 	async def joinraid_gettimewindow(self, context: commands.Context):
 		seconds = self.__message_age_seconds(context.guild)
-		await context.message.reply(f'ℹ️ Only messages in the past {seconds} ' +
-			'seconds will be checked for duplicates.',
+		await context.message.reply(
+			CONFIG['info_emoji'] + ' ' +
+			f'Only messages in the past {seconds} seconds will be checked ' +
+			'for duplicates.',
 			mention_author=False)

cogs/joinraidcog.py

 	"""
 	def __init__(self, guild_id: int):
 		self.guild_id = guild_id
-		self.join_warning_count = CONFIG['joinWarningCount']
-		self.join_warning_seconds = CONFIG['joinWarningSeconds']
+		self.join_warning_count = self.get_cog_default('warning_count')
+		self.join_warning_seconds = self.get_cog_default('warning_seconds')
 		# Non-persisted runtime state
 		self.current_raid = JoinRaidRecord()
 		self.all_raids = [ self.current_raid ] # periodically culled of old ones
 		Returns the join rate configured for this guild.
 		"""
 		count: int = Storage.get_config_value(guild, self.STATE_KEY_RAID_COUNT) \
-			or CONFIG['joinWarningCount']
+			or self.get_cog_default('warning_count')
 		seconds: float = Storage.get_config_value(guild, self.STATE_KEY_RAID_SECONDS) \
-			or CONFIG['joinWarningSeconds']
+			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 False
+		return Storage.get_config_value(guild, self.STATE_KEY_ENABLED) \
+			or self.get_cog_default('enabled')
 
 	# -- Commands -----------------------------------------------------------
 
 		Storage.set_config_value(guild, self.STATE_KEY_ENABLED, True)
 		# TODO: Startup tracking if necessary
 		await context.message.reply(
-			'✅ ' + self.__describe_raid_settings(guild, force_enabled_status=True),
+			CONFIG['success_emoji'] + ' ' +
+			self.__describe_raid_settings(guild, force_enabled_status=True),
 			mention_author=False)
 
 	@joinraid.command(
 		Storage.set_config_value(guild, self.STATE_KEY_ENABLED, False)
 		# TODO: Tear down tracking if necessary
 		await context.message.reply(
-			'✅ ' + self.__describe_raid_settings(guild, force_enabled_status=True),
+			CONFIG['success_emoji'] + ' ' +
+			self.__describe_raid_settings(guild, force_enabled_status=True),
 			mention_author=False)
 
 	@joinraid.command(
 		guild = context.guild
 		if join_count < self.MIN_JOIN_COUNT:
 			await context.message.reply(
-				f'⚠️ `join_count` must be >= {self.MIN_JOIN_COUNT}',
+				CONFIG['warning_emoji'] + ' ' +
+				f'`join_count` must be >= {self.MIN_JOIN_COUNT}',
 				mention_author=False)
 			return
 		if seconds <= 0:
 			await context.message.reply(
-				f'⚠️ `seconds` must be > 0',
+				CONFIG['warning_emoji'] + ' ' +
+				f'`seconds` must be > 0',
 				mention_author=False)
 			return
 		Storage.set_config_values(guild, {
 		})
 
 		await context.message.reply(
-			'✅ ' + self.__describe_raid_settings(guild, force_rate_status=True),
+			CONFIG['success_emoji'] + ' ' +
+			self.__describe_raid_settings(guild, force_rate_status=True),
 			mention_author=False)
 
 	@joinraid.command(
 	async def joinraid_getrate(self, context: commands.Context):
 		'Command handler'
 		await context.message.reply(
-			'ℹ️ ' + self.__describe_raid_settings(context.guild, force_rate_status=True),
+			CONFIG['info_emoji'] + ' ' +
+			self.__describe_raid_settings(context.guild, force_rate_status=True),
 			mention_author=False)
 
 	# -- Listeners ----------------------------------------------------------
 			# Either not a warning message or one we stopped tracking
 			return
 		emoji: PartialEmoji = payload.emoji
-		if emoji.name == CONFIG['kickEmoji']:
+		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['banEmoji']:
+		elif emoji.name == CONFIG['ban_emoji']:
 			await raid.ban_all()
 			gc.reset_raid(message.created_at)
 			await self.__update_raid_warning(guild, 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['kickEmoji'])
+			await raid.warning_message.add_reaction(CONFIG['kick_emoji'])
 		if can_ban:
-			await raid.warning_message.add_reaction(CONFIG['banEmoji'])
+			await raid.warning_message.add_reaction(CONFIG['ban_emoji'])
 
 	async def __update_raid_warning(self, guild: Guild, raid: JoinRaidRecord) -> None:
 		"""
 		(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['kickEmoji'])
+			await raid.warning_message.clear_reaction(CONFIG['kick_emoji'])
 		if not can_ban:
-			await raid.warning_message.clear_reaction(CONFIG['banEmoji'])
+			await raid.warning_message.clear_reaction(CONFIG['ban_emoji'])
 
 	def __describe_raid(self, raid: JoinRaidRecord) -> tuple:
 		"""
 
 		message += '\n'
 		if any_kickable:
-			message += f'\nReact to this message with {CONFIG["kickEmoji"]} to kick all these users.'
+			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["banEmoji"]} to ban all these users.'
+			message += f'\nReact to this message with {CONFIG["ban_emoji"]} to ban all these users.'
 		else:
 			message += '\nNo users left to ban.'
 

config.py.sample

 # Copy this file to config.py and fill in necessary values
 CONFIG = {
-	'clientToken': 'token',
-	'joinWarningCount': 5,
-	'joinWarningSeconds': 5,
-	'commandPrefix': '$rb_',
-	'kickEmojiName': 'boot',
-	'kickEmoji': '👢',
-	'banEmojiName': 'no_entry_sign',
-	'banEmoji': '🚫',
-	'configPath': 'config/',
+	'client_token': 'token',
+	'command_prefix': '$rb_',
+	'kick_emoji': '👢',
+	'ban_emoji': '🚫',
+	'trash_emoji': '🗑',
+	'success_emoji': '✅',
+	'warning_emoji': '⚠️',
+	'info_emoji': 'ℹ️',
+	'config_path': 'config/',
+	'cog_defaults': {
+		'JoinRaidCog': {
+			'enabled': False,
+			'warning_count': 5,
+			'warning_seconds': 5,
+		},
+		'CrossPostCog': {
+			'warn_message_count': 3,
+			'ban_message_count': 9999,
+			'time_window_seconds': 120,
+			'min_message_length': 0,
+		},
+	},
 }

rocketbot.py

 intents = Intents.default()
 intents.messages = True
 intents.members = True # To get join/leave events
-bot = Rocketbot(command_prefix=CONFIG['commandPrefix'], intents=intents)
+bot = Rocketbot(command_prefix=CONFIG['command_prefix'], intents=intents)
 bot.add_cog(GeneralCog(bot))
 bot.add_cog(ConfigCog(bot))
 bot.add_cog(JoinRaidCog(bot))
 bot.add_cog(CrossPostCog(bot))
-bot.run(CONFIG['clientToken'], bot=True, reconnect=True)
+bot.run(CONFIG['client_token'], bot=True, reconnect=True)
 print('\nBot aborted')

storage.py

 		"""
 		Returns the JSON file path where guild config should be written.
 		"""
-		config_value: str = CONFIG['configPath']
+		config_value: str = CONFIG['config_path']
 		path: str = config_value if config_value.endswith('/') else f'{config_value}/'
 		return f'{path}guild_{guild.id}.json'