- Autokick optionally bans after N rejoins

- Bot messages with lists of users are capped at 20 names to avoid 4kb request limit
- Redundant warnings should ping mods less

config.py.sample

 	'info_emoji': 'ℹ️',
 	'ignore_emoji': '👍',
 	'config_path': 'config/',
+	'max_members_per_message': 20,
+	'squelch_warning_seconds': 300,
 	'cog_defaults': {
+		'AutoKickCog': {
+			'bancount': 0
+		},
 		'CrossPostCog': {
 			'enabled': False,
 			'warncount': 3,

rocketbot/cogs/autokickcog.py

-import weakref
+from datetime import datetime, timedelta
 
 from discord import Guild, Member
 from discord.ext import commands
 
 from config import CONFIG
-from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
+from rocketbot.cogs.basecog import BaseCog, BotMessage, CogSetting
+from rocketbot.collections import AgeBoundDict
+from rocketbot.storage import Storage
+
+class AutoKickContext:
+	"""
+	Data about a join raid.
+	"""
+	def __init__(self, member: Member, first_kick: datetime):
+		self.member = member
+		self.first_kick = first_kick
+		self.last_kick = first_kick
+		self.kick_count = 1
+
+	def record_kick(self, time: datetime):
+		self.last_kick = time
+		self.kick_count += 1
 
 class AutoKickCog(BaseCog, name='Auto Kick'):
 	"""
 	SETTING_ENABLED = CogSetting('enabled', bool,
 		brief='autokick',
 		description='Whether this cog is enabled for a guild.')
+	SETTING_BAN_COUNT = CogSetting('bancount', int,
+			brief='number of repeat kicks before a ban',
+			description='The number of times a user can join and be kicked ' + \
+					'before the next rejoin will result in a ban. A value of 0 ' + \
+					'disables this feature (only kick, never ban).',
+			usage='<count:int>',
+			min_value=0)
+
+	STATE_KEY_RECENT_KICKS = "AutoKickCog.recent_joins"
 
 	def __init__(self, bot):
 		super().__init__(bot)
 		self.add_setting(AutoKickCog.SETTING_ENABLED)
+		self.add_setting(AutoKickCog.SETTING_BAN_COUNT)
 
 	@commands.group(
 		brief='Automatically kicks all new users as soon as they join',
 		guild: Guild = member.guild
 		if not self.get_guild_setting(guild, self.SETTING_ENABLED):
 			return
-		await member.kick(reason=f'Rocketbot: Autokick enabled.')
-		msg = BotMessage(guild,
-						text=f'Autokicked {member.mention} ({member.id}). To disable this feature: `{CONFIG["command_prefix"]}autokick disable`.',
-						type=BotMessage.TYPE_INFO,
-						context=None)
-		await self.post_message(msg)
-		self.log(guild, f'Autokicked {member.name}')
+		recent_kicks: AgeBoundDict = Storage.get_state_value(guild, AutoKickCog.STATE_KEY_RECENT_KICKS)
+		if recent_kicks is None:
+			recent_kicks = AgeBoundDict(timedelta(seconds=3600), lambda i, context : context.last_kick)
+			Storage.set_state_value(guild, self.STATE_KEY_RECENT_KICKS, recent_kicks)
+		context: AutoKickContext = recent_kicks.get(member.id)
+		if context is None:
+			context = AutoKickContext(member, datetime.now())
+			recent_kicks[member.id] = context
+		else:
+			context.record_kick(datetime.now())
+		max_kick_count: int = self.get_guild_setting(guild, self.SETTING_BAN_COUNT)
+		disable_help = f'To disable this feature: `{CONFIG["command_prefix"]}autokick disable`.'
+		ban_help = f'To configure ban threshold: `{CONFIG["command_prefix"]}autokick ' + \
+			'setbancount #` (0 to disable).'
+		if max_kick_count > 0 and context.kick_count > max_kick_count:
+			await member.ban(reason=f'Rocketbot: Ban after {context.kick_count} joins',
+				delete_message_days=0)
+			msg = BotMessage(guild,
+				text=f'Banned {member.mention} ({member.id}) after {context.kick_count} joins. ' + \
+					disable_help + ' ' + ban_help,
+				type=BotMessage.TYPE_INFO,
+				context=None)
+			await self.post_message(msg)
+			self.log(guild, f'Banned {member.name} after {context.kick_count} joins')
+		else:
+			await member.kick(reason='Rocketbot: Autokick enabled.')
+			msg = BotMessage(guild,
+							text=f'Autokicked {member.mention} ({member.id}) ' + \
+								f'({AutoKickCog.ordinal(context.kick_count)} time). ' + \
+								disable_help + ' ' + ban_help,
+							type=BotMessage.TYPE_INFO,
+							context=None)
+			await self.post_message(msg)
+			self.log(guild, f'Autokicked {member.name} ' + \
+				f'({AutoKickCog.ordinal(context.kick_count)} time)')
+
+	@staticmethod
+	def ordinal(val: int):
+		'Formats an integer with an ordinal suffix (English only)'
+		if val % 10 == 1:
+			return f'{val}st'
+		if val % 10 == 2:
+			return f'{val}nd'
+		if val % 10 == 3:
+			return f'{val}rd'
+		return f'{val}th'

rocketbot/cogs/basecog.py

 from rocketbot.storage import Storage
 from rocketbot.utils import bot_log
 
+class WarningContext:
+	def __init__(self, member: Member, warn_time: datetime):
+		self.member = member
+		self.last_warned = warn_time
+
 class BaseCog(commands.Cog):
+	STATE_KEY_RECENT_WARNINGS = "BaseCog.recent_warnings"
+
 	"""
 	Superclass for all Rocketbot cogs. Provides lots of conveniences for
 	common tasks.
 		Subclass override point for being notified when a CogSetting is edited.
 		"""
 
+	# Warning squelch
+
+	def was_warned_recently(self, member: Member) -> bool:
+		"""
+		Tests if a given member was included in a mod warning message recently.
+		Used to suppress redundant messages. Should be checked before pinging
+		mods for relatively minor warnings about single users, but warnings
+		about larger threats involving several members (e.g. join raids) should
+		issue warnings regardless. Call record_warning or record_warnings after
+		triggering a mod warning.
+		"""
+		recent_warns: AgeBoundDict = Storage.get_state_value(member.guild,
+			BaseCog.STATE_KEY_RECENT_WARNINGS)
+		if recent_warns is None:
+			return False
+		context: WarningContext = recent_warns.get(member.id)
+		if context is None:
+			return False
+		squelch_warning_seconds: int = CONFIG['squelch_warning_seconds']
+		return datetime.now - context.last_warned < timedelta(seconds=squelch_warning_seconds)
+
+	def record_warning(self, member: Member):
+		"""
+		Records that mods have been warned about a member and do not need to be
+		warned about them again for a short while.
+		"""
+		recent_warns: AgeBoundDict = Storage.get_state_value(member.guild,
+			BaseCog.STATE_KEY_RECENT_WARNINGS)
+		if recent_warns is None:
+			recent_warns = AgeBoundDict(timedelta(seconds=CONFIG['squelch_warning_seconds']),
+				lambda i, context : context.last_warned)
+			Storage.set_state_value(member.guild, BaseCog.STATE_KEY_RECENT_WARNINGS, recent_warns)
+		context: WarningContext = recent_warns.get(member.id)
+		if context is None:
+			context = WarningContext(member, datetime.now())
+			recent_warns[member.id] = context
+		else:
+			context.last_warned = datetime.now()
+
+	def record_warnings(self, members: list):
+		"""
+		Records that mods have been warned about some members and do not need to
+		be warned about them again for a short while.
+		"""
+		for member in members:
+			self.record_warning(member)
+
 	# Bot message handling
 
 	@classmethod

rocketbot/cogs/crosspostcog.py

 		deleted_count = len(context.spam_messages)
 		message = context.bot_message
 		if message is None:
-			message = BotMessage(context.member.guild, '',
-				BotMessage.TYPE_MOD_WARNING, context)
+			message_type: int = BotMessage.TYPE_INFO if self.was_warned_recently(context.member) \
+				else BotMessage.TYPE_MOD_WARNING
+			message = BotMessage(context.member.guild, '', message_type, context)
 			message.quote = discordutils.remove_markdown(first_spam_message.clean_content)
+			self.record_warning(context.member)
 		if context.is_autobanned:
 			text = f'User {context.member.mention} auto banned for ' + \
 				f'posting the same message in {channel_count} channels. ' + \

rocketbot/cogs/joinagecog.py

 			return
 		text = f'The following members joined in the last {context.timespan}\n\n'
 		if len(context.join_members) > 0:
-			for member in context.join_members:
+			max_members = CONFIG['max_members_per_message']
+			for member in context.join_members[:max_members]:
 				text += '\n• '
 				if member in context.banned_members:
 					text += f'~~{member.mention} ({member.id})~~ - banned'
 					text += f'~~{member.mention} ({member.id})~~ - kicked'
 				else:
 					text += f'{member.mention} ({member.id})'
+			if len(context.join_members) > max_members:
+				text += f'\n• {len(context.join_members) - max_members} more'
 		else:
 			text += 'No members found. If the bot was recently restarted ' + \
 				'or JoinAgeCog just enabled, only new joins will be tracked.'

rocketbot/cogs/joinraidcog.py

 				return
 			# Add join to existing raid
 			last_raid.join_members.append(member)
+			self.record_warning(member)
 			if len(last_raid.banned_members) > 0:
 				self.log(guild, f'Banning as part of last join raid: {member.name}')
 				await member.ban(
-					reason=f'Rocketbot: Part of join raid.',
+					reason='Rocketbot: Part of join raid.',
 					delete_message_days=0)
 				last_raid.banned_members.add(member)
 			elif len(last_raid.kicked_members) > 0:
 				self.log(guild, f'Kicking as part of last join raid: {member.name}')
 				await member.kick(
-					reason=f'Rocketbot: Part of join raid.')
+					reason='Rocketbot: Part of join raid.')
 				last_raid.kicked_members.add(member)
 			await self.__update_warning_message(last_raid)
 		else:
 						text='',
 						type=BotMessage.TYPE_MOD_WARNING,
 						context=last_raid)
+				self.record_warnings(recent_joins)
 				last_raid.warning_message_ref = weakref.ref(msg)
 				await self.__update_warning_message(last_raid)
 				await self.post_message(msg)
 			return
 		text = 'JOIN RAID DETECTED\n\n' + \
 			'The following members joined in close succession:\n'
-		for member in context.join_members:
+		max_members: int = CONFIG['max_members_per_message']
+		for member in context.join_members[:max_members]:
 			text += '\n• '
 			if member in context.banned_members:
 				text += f'~~{member.mention} ({member.id})~~ - banned'
 				text += f'~~{member.mention} ({member.id})~~ - kicked'
 			else:
 				text += f'{member.mention} ({member.id})'
+		if len(context.join_members) > max_members:
+			text += f'\n• {len(context.join_members) - max_members} more'
 		text += '\n_(list updates automatically)_'
 		await bot_message.set_text(text)
 		member_count = len(context.join_members)

rocketbot/cogs/patterncog.py

 				message_type = BotMessage.TYPE_INFO
 				action_descriptions.append('Message logged')
 			elif action.action == 'modwarn':
-				should_post_message = True
+				should_post_message = not self.was_warned_recently(message.author)
 				message_type = BotMessage.TYPE_MOD_WARNING
 				action_descriptions.append('Mods alerted')
 			elif action.action == 'reply':
 					('\n• '.join(action_descriptions)),
 				type=message_type,
 				context=context)
+			self.record_warning(message.author)
 			bm.quote = discordutils.remove_markdown(message.clean_content)
 			await bm.set_reactions(BotMessageReaction.standard_set(
 				did_delete=context.is_deleted,

rocketbot/cogs/urlspamcog.py

 			context = URLSpamContext(message)
 			needs_attention = False
 			if action == 'modwarn':
-				needs_attention = True
+				needs_attention = not self.was_warned_recently(message.author)
 				self.log(message.guild, f'New user {message.author.name} ' + \
 					f'({message.author.id}) posted URL {join_age_str} after ' + \
-					'joining. Mods alerted.')
+					'joining.' + (' Mods alerted.' if needs_attention else ''))
 			elif action == 'delete':
 				await message.delete()
 				context.is_deleted = True
 				did_kick=context.is_kicked,
 				did_ban=context.is_banned))
 			await self.post_message(bm)
+			if needs_attention:
+				self.record_warning(message.author)
 
 	async def on_mod_react(self,
 			bot_message: BotMessage,

rocketbot/cogs/usernamecog.py

 			member.guild,
 			f'User {member.mention} ({str(member.id)}, {member.display_name}) has ' +
 			f'username matching pattern `{pattern}`.',
-			BotMessage.TYPE_MOD_WARNING,
+			BotMessage.TYPE_INFO if self.was_warned_recently(member) else BotMessage.TYPE_MOD_WARNING,
 			context)
+		self.record_warning(member)
 		await bm.set_reactions(context.reactions())
 		await self.post_message(bm)