Persisted state renamed to config. Storage class now handles transient values too.

cogs/basecog.py

 from discord import Guild, Message, TextChannel
 from discord.ext import commands
 
-from storage import StateKey, Storage
+from storage import ConfigKey, Storage
 import json
 
 class BaseCog(commands.Cog):
 		given guild. If no warning channel is configured no action is taken.
 		Returns the Message if successful or None if not.
 		"""
-		channel_id = Storage.get_state_value(guild, StateKey.WARNING_CHANNEL_ID)
+		channel_id = Storage.get_config_value(guild, ConfigKey.WARNING_CHANNEL_ID)
 		if channel_id is None:
 			cls.guild_trace(guild, 'No warning channel set! No warning issued.')
 			return None
 		if channel is None:
 			cls.guild_trace(guild, 'Configured warning channel does not exist!')
 			return None
-		mention: str = Storage.get_state_value(guild, StateKey.WARNING_MENTION)
+		mention: str = Storage.get_config_value(guild, ConfigKey.WARNING_MENTION)
 		text: str = message
 		if mention is not None:
 			text = f'{mention} {text}'
 		mentions if necessary.
 		"""
 		text: str = new_text
-		mention: str = Storage.get_state_value(
+		mention: str = Storage.get_config_value(
 			warn_message.guild,
-			StateKey.WARNING_MENTION)
+			ConfigKey.WARNING_MENTION)
 		if mention is not None:
 			text = f'{mention} {text}'
 		await warn_message.edit(content=text)

cogs/configcog.py

 from discord import Guild, TextChannel
 from discord.ext import commands
-from storage import StateKey, Storage
+from storage import ConfigKey, Storage
 from cogs.basecog import BaseCog
 
 class ConfigCog(BaseCog):
 		'Command handler'
 		guild: Guild = context.guild
 		channel: TextChannel = context.channel
-		Storage.set_state_value(guild, StateKey.WARNING_CHANNEL_ID,
+		Storage.set_config_value(guild, ConfigKey.WARNING_CHANNEL_ID,
 			context.channel.id)
 		await context.message.reply(
 			f'Warning channel updated to {channel.mention}.',
 	async def config_getwarningchannel(self, context: commands.Context) -> None:
 		'Command handler'
 		guild: Guild = context.guild
-		channel_id = Storage.get_state_value(guild, StateKey.WARNING_CHANNEL_ID)
+		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.',
 	)
 	async def config_setwarningmention(self, context: commands.Context, mention: str = None) -> None:
 		guild: Guild = context.guild
-		Storage.set_state_value(guild, StateKey.WARNING_MENTION, mention)
+		Storage.set_config_value(guild, ConfigKey.WARNING_MENTION, mention)
 		if mention is None:
 			await context.message.reply(
 				'Warning messages will not tag anyone.',
 	)
 	async def config_getwarningmention(self, context: commands.Context) -> None:
 		guild: Guild = context.guild
-		mention: str = Storage.get_state_value(guild, StateKey.WARNING_MENTION)
+		mention: str = Storage.get_config_value(guild, ConfigKey.WARNING_MENTION)
 		if mention is None:
 			await context.message.reply(
 				'No warning mention configured.',

cogs/crosspostcog.py

+from discord import Guild, Message
 from cogs.basecog import BaseCog
 
+class CrossPostCog(BaseCog):
+	class SpamContext:
+		def __init__(self, member):
+			self.member = member
+			self.is_warned = False
+
+	STATE_KEY_RECENT_MESSAGES = "crosspost_recent_messages"
+	STATE_KEY_SPAM_CONTEXT = "crosspost_spam_context"
+
+	def __init__(self, bot):
+		super().__init__(bot)
+		self.max_recent_messages = 20
+		self.messages_per_user = 3
+		self.min_message_length = 10
+
+	def __record_message(self, message: Message) -> None:
+		recent_messages = Storage.get_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES) or []
+		recent_messages.append(message)
+		while len(recent_messages) > self.max_recent_messages:
+			recent_messages.pop(0)
+		Storage.set_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES, recent_messages)
+
+	def __check_for_spam(self, guild: Guild) -> None:
+		recent_messages = Storage.get_state_value(guild, self.STATE_KEY_RECENT_MESSAGES)
+		if recent_messages is None:
+			return
+		user_id_to_count = {}
+		spamming_members = set()
+		for message in recent_messages:
+			content = message.content
+			if len(content) < self.min_message_length:
+				continue
+			key = str(message.author.id) + '|' + hash(content)
+			count = (user_id_to_count.get(key) or 0) + 1
+			user_id_to_count[key] = count
+			if count >= self.messages_per_user:
+				spamming_members.add(message.author)
+		for member in spamming_members:
+			context = self.__spam_context_for_user(member)
+
+	def __spam_context_for_user(self,
+			member: Member,
+			create_if_missing: bool = False) -> SpamContext:
+		spam_lookup = Storage.get_state_value(member.guild, self.STATE_KEY_SPAM_CONTEXT) or {}
+		context = spam_lookup.get(member.id)
+		if context:
+			return context
+		if not create_if_missing:
+			return None
+		context = SpamContext(member)
+		spam_lookup[member.id] = context
+		Storage.set_state_value(member.guild, self.STATE_KEY_SPAM_CONTEXT, spam_lookup)
+		return context
+
+	@commands.Cog.listener()
+	def on_message(self, message: Message):
+		self.__record_message(message)
+		self.__check_for_spam(message.guild)

cogs/generalcog.py

 from discord.ext import commands
 from cogs.basecog import BaseCog
-from storage import StateKey, Storage
+from storage import ConfigKey, Storage
 
 class GeneralCog(BaseCog):
 	def __init__(self, bot: commands.Bot):
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def testwarn(self, context):
-		if Storage.get_state_value(context.guild, StateKey.WARNING_CHANNEL_ID) is None:
+		if Storage.get_config_value(context.guild, ConfigKey.WARNING_CHANNEL_ID) is None:
 			await context.message.reply(
 				'No warning channel set!',
 				mention_author=False)

cogs/joinraidcog.py

         """
         Returns the join rate configured for this guild.
         """
-        count: int = Storage.get_state_value(guild, self.STATE_KEY_RAID_COUNT) \
+        count: int = Storage.get_config_value(guild, self.STATE_KEY_RAID_COUNT) \
             or CONFIG['joinWarningCount']
-        seconds: float = Storage.get_state_value(guild, self.STATE_KEY_RAID_SECONDS) \
+        seconds: float = Storage.get_config_value(guild, self.STATE_KEY_RAID_SECONDS) \
             or CONFIG['joinWarningSeconds']
         return (count, seconds)
 
         """
         Returns whether join raid detection is enabled in this guild.
         """
-        return Storage.get_state_value(guild, self.STATE_KEY_ENABLED) or False
+        return Storage.get_config_value(guild, self.STATE_KEY_ENABLED) or False
 
     # -- Commands -----------------------------------------------------------
 
     async def joinraid_enable(self, context: commands.Context):
         'Command handler'
         guild = context.guild
-        Storage.set_state_value(guild, self.STATE_KEY_ENABLED, True)
+        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),
     async def joinraid_disable(self, context: commands.Context):
         'Command handler'
         guild = context.guild
-        Storage.set_state_value(guild, self.STATE_KEY_ENABLED, False)
+        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),
                 f'⚠️ `seconds` must be > 0',
                 mention_author=False)
             return
-        Storage.set_state_values(guild, {
+        Storage.set_config_values(guild, {
             self.STATE_KEY_RAID_COUNT: join_count,
             self.STATE_KEY_RAID_SECONDS: seconds,
         })

config.py.sample

 # Copy this file to config.py and fill in necessary values
 CONFIG = {
 	'clientToken': 'token',
-	'dbHost': 'localhost',
-	'dbUser': 'username',
-	'dbPassword': 'password',
-	'dbDatabase': 'databasename',
 	'joinWarningCount': 5,
 	'joinWarningSeconds': 5,
 	'commandPrefix': '$rb_',
 	'kickEmoji': '👢',
 	'banEmojiName': 'no_entry_sign',
 	'banEmoji': '🚫',
-	'statePath': 'state/',
+	'configPath': 'config/',
 }

storage.py

 
 from config import CONFIG
 
-class StateKey:
+class ConfigKey:
 	WARNING_CHANNEL_ID = 'warning_channel_id'
 	WARNING_MENTION = 'warning_mention'
 
 class Storage:
 	"""
-	Static class for managing persisted bot state.
+	Static class for managing persisted bot configuration and transient state
+	on a per-guild basis.
 	"""
 
-	# discord.Guild.id -> dict
+	# -- Transient state management -----------------------------------------
+
 	__guild_id_to_state = {}
 
 	@classmethod
 	def get_state(cls, guild: Guild) -> dict:
 		"""
-		Returns all persisted state for the given guild.
+		Returns transient state for the given guild. This state is not preserved
+		if the bot is restarted.
 		"""
 		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
-		cls.__trace(f'No loaded state for guild {guild.id}. Attempting to ' +
-			'load from disk.')
-		state = cls.__load_guild_state(guild)
 		if state is None:
-			return {}
-		cls.__guild_id_to_state[guild.id] = state
+			state = {}
+			cls.__guild_id_to_state[guild.id] = state
 		return state
 
 	@classmethod
 	def get_state_value(cls, guild: Guild, key: str):
 		"""
-		Returns a persisted state value stored under the given key. Returns
-		None if not present.
+		Returns a state value for the given guild and key, or `None` if not set.
 		"""
 		return cls.get_state(guild).get(key)
 
 	@classmethod
 	def set_state_value(cls, guild: Guild, key: str, value) -> None:
 		"""
-		Adds the given key-value pair to the persisted state for the given
-		Guild. If `value` is `None` the key will be removed from persisted
-		state.
+		Updates a transient value associated with the given guild and key name.
+		A value of `None` removes any previous value for that key.
 		"""
 		cls.set_state_values(guild, { key: value })
 
 	@classmethod
 	def set_state_values(cls, guild: Guild, vars: dict) -> None:
 		"""
-		Merges the given `vars` dict with the saved state for the given guild
-		and saves it to disk. `vars` must be JSON-encodable or a ValueError will
-		be raised. Keys with associated values of `None` will be removed from the
-		state.
+		Merges in a set of key-value pairs into the transient state for the
+		given guild. Any pairs with a value of `None` will be removed from the
+		transient state.
 		"""
 		if vars is None or len(vars) == 0:
 			return
 		state: dict = cls.get_state(guild)
+		for key, value in vars.items():
+			if value is None:
+				del state[key]
+			else:
+				state[key] = value
+		# XXX: Superstitious. Should update by ref already but saw weirdness once.
+		cls.__guild_id_to_state[guild.id] = state
+
+	# -- Persisted configuration management ---------------------------------
+
+	# discord.Guild.id -> dict
+	__guild_id_to_config = {}
+
+	@classmethod
+	def get_config(cls, guild: Guild) -> dict:
+		"""
+		Returns all persisted configuration for the given guild.
+		"""
+		config: dict = cls.__guild_id_to_config.get(guild.id)
+		if config is not None:
+			# Already in memory
+			return config
+		# Load from disk if possible
+		cls.__trace(f'No loaded config for guild {guild.id}. Attempting to ' +
+			'load from disk.')
+		config = cls.__read_guild_config(guild)
+		if config is None:
+			return {}
+		cls.__guild_id_to_config[guild.id] = config
+		return config
+
+	@classmethod
+	def get_config_value(cls, guild: Guild, key: str):
+		"""
+		Returns a persisted guild config value stored under the given key.
+		Returns `None` if not present.
+		"""
+		return cls.get_config(guild).get(key)
+
+	@classmethod
+	def set_config_value(cls, guild: Guild, key: str, value) -> None:
+		"""
+		Adds/updates the given key-value pair to the persisted config for the
+		given Guild. If `value` is `None` the key will be removed from persisted
+		config.
+		"""
+		cls.set_config_values(guild, { key: value })
+
+	@classmethod
+	def set_config_values(cls, guild: Guild, vars: dict) -> None:
+		"""
+		Merges the given `vars` dict with the saved config for the given guild
+		and writes it to disk. `vars` must be JSON-encodable or a `ValueError`
+		will be raised. Keys with associated values of `None` will be removed
+		from the persisted config.
+		"""
+		if vars is None or len(vars) == 0:
+			return
+		config: dict = cls.get_config(guild)
 		try:
 			json.dumps(vars)
 		except:
 			raise ValueError(f'vars not JSON encodable - {vars}')
 		for key, value in vars.items():
 			if value is None:
-				del state[key]
+				del config[key]
 			else:
-				state[key] = value
-		cls.__save_guild_state(guild, state)
+				config[key] = value
+		cls.__write_guild_config(guild, config)
 
 	@classmethod
-	def __save_guild_state(cls, guild: Guild, state: dict) -> None:
+	def __write_guild_config(cls, guild: Guild, config: dict) -> None:
 		"""
-		Saves state for a guild to a JSON file on disk.
+		Saves config for a guild to a JSON file on disk.
 		"""
-		path: str = cls.__guild_path(guild)
-		cls.__trace(f'Saving state for guild {guild.id} to {path}')
-		cls.__trace(f'state = {state}')
+		path: str = cls.__guild_config_path(guild)
+		cls.__trace(f'Saving config for guild {guild.id} to {path}')
+		cls.__trace(f'config = {config}')
 		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)
+			json.dump(config, file, indent='\t', sort_keys=True)
 		cls.__trace('State saved')
 
 	@classmethod
-	def __load_guild_state(cls, guild: Guild) -> dict:
+	def __read_guild_config(cls, guild: Guild) -> dict:
 		"""
-		Loads state for a guild from a JSON file on disk, or None if not found.
+		Loads config for a guild from a JSON file on disk, or `None` if not
+		found.
 		"""
-		path: str = cls.__guild_path(guild)
+		path: str = cls.__guild_config_path(guild)
 		if not exists(path):
-			cls.__trace(f'No state on disk for guild {guild.id}. Returning None.')
+			cls.__trace(f'No config on disk for guild {guild.id}. Returning None.')
 			return None
-		cls.__trace(f'Loading state from disk for guild {guild.id}')
+		cls.__trace(f'Loading config from disk for guild {guild.id}')
 		with open(path, 'r') as file:
-			state = json.load(file)
+			config = json.load(file)
 		cls.__trace('State loaded')
-		return state
+		return config
 
 	@classmethod
-	def __guild_path(cls, guild: Guild) -> str:
+	def __guild_config_path(cls, guild: Guild) -> str:
 		"""
-		Returns the JSON file path where guild state should be written.
+		Returns the JSON file path where guild config should be written.
 		"""
-		config_value: str = CONFIG['statePath']
+		config_value: str = CONFIG['configPath']
 		path: str = config_value if config_value.endswith('/') else f'{config_value}/'
 		return f'{path}guild_{guild.id}.json'
 
 	@classmethod
 	def __trace(cls, message: str) -> None:
-		print(f'{Storage.__name__}: {message}')
+		print(f'{cls.__name__}: {message}')