Bot working

.gitignore

 # Mac!!
 .DS_Store
 
-# Contains secrets so exclude
+# Rocketbot stuff
 /config.py
 rocketbot.db
+/state/

cogs/base.py

-from discord import Guild
+from discord import Guild, Message, TextChannel
 from discord.ext import commands
 
-from storage import Storage
+from storage import StateKey, Storage
 
 class BaseCog(commands.Cog):
 	def __init__(self, bot):
 		self.bot = bot
 
+	@staticmethod
 	def save_setting(guild: Guild, name: str, value):
+		"""
+		Saves one value to a guild's persisted state. The given value must
+		be a JSON-encodable type.
+		"""
+		if value is not None and not isinstance(value, (bool, int, float, str, list, dict)):
+			raise Exception(f'value for key {name} is not supported JSON type! {type(value)}')
 		state: dict = Storage.state_for_guild(guild)
-		state[name] = value
+		if value is None:
+			del state[name]
+		else:
+			state[name] = value
 		Storage.save_guild_state(guild)
 
-	def warn(guild: Guild):
+	@staticmethod
+	async def warn(guild: Guild, message: str) -> bool:
+		"""
+		Sends a warning message to the configured warning channel for the
+		given guild. If no warning channel is configured no action is taken.
+		Returns True if the message was sent successfully or False if the
+		warning channel could not be found.
+		"""
 		state: dict = Storage.state_for_guild(guild)
-		
+		channel_id = state.get(StateKey.WARNING_CHANNEL_ID)
+		if channel_id is None:
+			guild_trace(guild, 'No warning channel set! No warning issued.')
+			return False
+		channel: TextChannel = guild.get_channel(channel_id)
+		if channel is None:
+			guild_trace(guild, 'Configured warning channel no longer exists!')
+			return False
+		message: Message = await channel.send(message)
+		return message is not None
+
+	@staticmethod
+	def guild_trace(guild: Guild, message: str) -> None:
+		print(f'[guild {guild.id}|{guild.name}] {message}')

cogs/config.py

 from discord import Guild, TextChannel
 from discord.ext import commands
-from storage import Storage
+from storage import StateKey, Storage
+from cogs.base import BaseCog
 
-class ConfigCog(commands.Cog):
+class ConfigCog(BaseCog):
 	"""
 	Cog for handling general bot configuration.
 	"""
 			await context.send_help()
 
 	@config.command(
-		name='setoutputchannel',
-		brief='Sets the channel where mod communications occur',
+		name='setwarningchannel',
+		brief='Sets the channel where mod warnings are posted',
 		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!',
 	)
-	async def config_setoutputchannel(self, context: commands.Context):
+	async def config_setwarningchannel(self, context: commands.Context):
 		'Command handler'
 		guild: Guild = context.guild
 		channel: TextChannel = context.channel
-		state: dict = Storage.state_for_guild(context.guild)
-		state['output_channel_id'] = context.channel.id
-		Storage.save_guild_state(context.guild)
-		await context.message.reply(f'Output channel set to {channel.name}', mention_author=False)
+		self.save_setting(guild, StateKey.WARNING_CHANNEL_ID, context.channel.id)
+		await context.message.reply(f'Warning channel set to {channel.name}', mention_author=False)

cogs/general.py

 from discord.ext import commands
+from cogs.base import BaseCog
 
-class GeneralCog(commands.Cog):
+class GeneralCog(BaseCog):
 	def __init__(self, bot: commands.Bot):
 		self.bot = bot
 		self.is_connected = False
 	async def on_ready(self):
 		print('on_ready')
 		self.is_ready = True
+
+	@commands.command()
+	@commands.has_permissions(ban_members=True)
+	@commands.guild_only()
+	async def testwarn(self, context):
+		await self.warn(context.guild, 'Test warning')

cogs/joinraid.py

 from discord import Guild, Intents, Member, Message, PartialEmoji, RawReactionActionEvent
 from discord.ext import commands
 from storage import Storage
+from cogs.base import BaseCog
 
 class JoinRecord:
     """
         self.phase = RaidPhase.ENDED
         return bans
 
-class JoinRaidCog(commands.Cog):
+class JoinRaidCog(BaseCog):
 	"""
 	Cog for monitoring member joins and detecting potential bot raids.
 	"""

storage.py

 
 from config import CONFIG
 
+class StateKey:
+	WARNING_CHANNEL_ID = 'warning_channel_id'
+
 class Storage:
 	"""
 	Static class for managing persisted bot state.
 	# discord.Guild.id -> dict
 	__guild_id_to_state = {}
 
-	def state_for_guild(guild: Guild) -> dict:
+	@classmethod
+	def state_for_guild(cls, guild: Guild) -> dict:
 		"""
 		Returns the state for the given guild, loading from disk if necessary.
 		Always returns a dict.
 		"""
-		state: dict = __guild_id_to_state[guild.id]
+		state: dict = cls.__guild_id_to_state.get(guild.id)
 		if state is not None:
 			# Already in memory
 			return state
 		# Load from disk if possible
-		__trace(f'No loaded state for guild {guild.id}. Attempting to load from disk.')
-		state = __load_guild_state(guild)
-		__guild_id_to_state[guild.id] = state
+		cls.__trace(f'No loaded state for guild {guild.id}. Attempting to load from disk.')
+		state = cls.__load_guild_state(guild)
+		cls.__guild_id_to_state[guild.id] = state
 		return state
 
-	def save_guild_state(guild: Guild) -> NoneType:
+	@classmethod
+	def save_guild_state(cls, guild: Guild) -> None:
 		"""
 		Saves state for the given guild to disk, if any exists.
 		"""
-		state: dict = __guild_id_to_state[guild.id]
+		state: dict = cls.__guild_id_to_state.get(guild.id)
 		if state is None:
 			# Nothing to save
 			return
-		__save_guild_state(guild, state)
+		cls.__save_guild_state(guild, state)
 
-	def __save_guild_state(guild: Guild, state: dict) -> NoneType:
+	@classmethod
+	def __save_guild_state(cls, guild: Guild, state: dict) -> None:
 		"""
 		Saves state for a guild to a JSON file on disk.
 		"""
-		path: str = __guild_path(guild)
-		__trace('Saving state for guild {guild.id} to {path}')
+		path: str = cls.__guild_path(guild)
+		cls.__trace('Saving state for guild {guild.id} to {path}')
 		with open(path, 'w') as file:
 			# Pretty printing to make more legible for debugging
 			# Sorting keys to help with diffs
 			json.dump(state, file, indent='\t', sort_keys=True)
-		__trace('State saved')
+		cls.__trace('State saved')
 
-	def __load_guild_state(guild: Guild) -> dict:
+	@classmethod
+	def __load_guild_state(cls, guild: Guild) -> dict:
 		"""
 		Loads state for a guild from a JSON file on disk.
 		"""
-		path: str = __guild_path(guild)
+		path: str = cls.__guild_path(guild)
 		if not exists(path):
-			__trace(f'No state on disk for guild {guild.id}. Returning {{}}.')
+			cls.__trace(f'No state on disk for guild {guild.id}. Returning {{}}.')
 			return {}
-		__trace('Loading state from disk for guild {guild.id}')
+		cls.__trace(f'Loading state from disk for guild {guild.id}')
 		with open(path, 'r') as file:
 			state = json.load(file)
-		__trace('State loaded')
+		cls.__trace('State loaded')
 		return state
 
-	def __guild_path(guild: Guild) -> str:
+	@classmethod
+	def __guild_path(cls, guild: Guild) -> str:
 		"""
 		Returns the JSON file path where guild state should be written.
 		"""
 		path: str = config_value if config_value.endswith('/') else f'{config_value}/'
 		return f'{path}guild_{guild.id}.json'
 
-	def __trace(message: str) -> NoneType:
+	@classmethod
+	def __trace(cls, message: str) -> None:
 		print(f'{Storage.__name__}: {message}')