Crosspost cog now working

cogs/basecog.py

@@ -1,12 +1,59 @@
-from discord import Guild, Message, TextChannel
+from discord import Guild, Message, PartialEmoji, RawReactionActionEvent, TextChannel
 from discord.ext import commands
+from datetime import timedelta
 
+from rscollections import AgeBoundDict
 from storage import ConfigKey, Storage
 import json
 
 class BaseCog(commands.Cog):
 	def __init__(self, bot):
 		self.bot = bot
+		self.listened_mod_react_message_ids = AgeBoundDict(timedelta(minutes=5), lambda message_id, age : age)
+
+	def listen_for_reactions_to(self, message: Message) -> None:
+		self.listened_mod_react_message_ids[message.id] = message.created_at
+
+	@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
+			return
+		if self.listened_mod_react_message_ids.get(message.id) is None:
+			# Not a message we're listening for
+			return
+		await self.on_mod_react(message, payload.emoji)
+
+	async def on_mod_react(self, message: Message, emoji: PartialEmoji) -> None:
+		"""
+		Override point for getting a mod's emote on a bot message. Used to take
+		action on a warning, such as banning an offending user. This event is
+		only triggered for registered bot messages and reactions by members
+		with the proper permissions.
+		"""
+		pass
 
 	@classmethod
 	async def warn(cls, guild: Guild, message: str) -> Message:

cogs/crosspostcog.py

@@ -1,70 +1,169 @@
-from rscollections import SizeBoundList
-from discord import Guild, Message
+from discord import Guild, Message, PartialEmoji
+from discord.ext import commands
+from datetime import datetime, timedelta
+
+from rscollections import AgeBoundList, SizeBoundDict
 from cogs.basecog import BaseCog
+from storage import Storage
 
-class CrossPostCog(BaseCog):
-	class SpamContext:
-		def __init__(self, member):
-			self.member = member
-			self.age = timedate.now()
-			self.is_warned = False
+class SpamContext:
+	def __init__(self, member, message_hash):
+		self.member = member
+		self.message_hash = message_hash
+		self.age = datetime.now()
+		self.warning_message = None
+		self.is_kicked = False
+		self.is_banned = False
+		self.messages = set()
+		self.deleted_messages = set()
 
+class CrossPostCog(BaseCog):
 	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.max_recent_message_age = timedelta(minutes=2)
 		self.max_spam_contexts = 12
-		self.messages_per_user = 3
+		self.warn_messages_per_user = 3
+		self.ban_messages_per_user = 5
 		self.min_message_length = 10
 
-	def __record_message(self, message: Message) -> None:
+	async def __record_message(self, message: Message) -> None:
+		if message.author.permissions_in(message.channel).ban_members:
+			# User exempt from spam detection
+			return
 		recent_messages = Storage.get_state_value(message.guild, self.STATE_KEY_RECENT_MESSAGES) \
-			or SizeBoundList(self.max_recent_messages, lambda index, message : message.created_at)
+			or AgeBoundList(self.max_recent_message_age, lambda index, message : message.created_at)
 		recent_messages.append(message)
 		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:
+		# 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.warn_messages_per_user:
 			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, True)
-			if not context.is_warned:
-				self.__on_new_spam(context)
-
-	def __on_new_spam(self, context: SpamContext):
-		context.is_warned = True
-		# TODO
-
-	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) \
+
+		# Look for repeats
+		hash_to_count = {}
+		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.warn_messages_per_user:
+			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)
-		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
+		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.warn_messages_per_user:
+				continue
+			key = f'{message.author.id}|{message_hash}'
+			context = spam_lookup.get(key)
+			is_new = context is None
+			if context is None:
+				context = SpamContext(message.author, message_hash)
+				spam_lookup[key] = context
+				context.age = message.created_at
+			for m in member_messages:
+				if hash(m.content) == message_hash:
+					context.messages.add(m)
+			await self.__update_from_context(context)
+
+	async def __update_from_context(self, context: SpamContext):
+		content = next(iter(context.messages)).content
+		if len(context.messages) > self.ban_messages_per_user:
+			if not context.is_banned:
+				await context.member.ban(reason='Posting same message repeatedly', delete_message_days=1)
+				msg = f'User {context.member.mention} auto banned for ' + \
+					'crosspost spamming.\n' + \
+					'> {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('🚫')
+				else:
+					self.warning_message = await self.warn(context.member.guild, msg)
+		elif len(context.messages) > self.warn_messages_per_user:
+			content = next(iter(context.messages)).content
+			msg = f'User {context.member.mention} has posted the exact same ' + \
+				f'message {len(context.messages)} times.\n' + \
+				f'> {content}' + \
+				'\n'
+			can_delete = len(context.messages) > len(context.deleted_messages)
+			if can_delete:
+				msg += '\n🗑 to delete messages'
+			else:
+				msg += '\nAll messages deleted'
+			if not context.is_kicked:
+				msg += '\n👢 to kick user'
+			elif not context.is_banned:
+				msg += '\nUser kicked'
+			if context.is_banned:
+				msg += '\nUser banned'
+			else:
+				msg += '\n🚫 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)
+			if can_delete:
+				await context.warning_message.add_reaction('🗑')
+			else:
+				await context.warning_message.clear_reaction('🗑')
+			if not context.is_kicked:
+				await context.warning_message.add_reaction('👢')
+			else:
+				await context.warning_message.clear_reaction('👢')
+			if not context.is_banned:
+				await context.warning_message.add_reaction('🚫')
+			else:
+				await context.warning_message.clear_reaction('🚫')
+
+	def __context_for_warning_message(self, message: Message) -> SpamContext:
+		spam_lookup = Storage.get_state_value(message.guild, self.STATE_KEY_SPAM_CONTEXT)
+		if spam_lookup is None:
+			return
+		for _, context in spam_lookup.items():
+			if context.warning_message.id == message.id:
+				return context
+		return None
+
+	async def on_mod_react(self, message: Message, emoji: PartialEmoji) -> None:
+		context = self.__context_for_warning_message(message)
+		if context is None:
+			return
+
+		if emoji.name == '🗑':
+			await self.__delete_messages(context)
+		elif emoji.name == '👢':
+			await self.__kick(context)
+		elif emoji.name == '🚫':
+			await self.__ban(context)
+
+	async def __delete_messages(self, context: SpamContext) -> None:
+		for message in context.messages - context.deleted_messages:
+			await message.delete()
+			context.deleted_messages.add(message)
+		await self.__update_from_context(context)
+
+	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)
+
+	async def __ban(self, context: SpamContext) -> None:
+		await context.member.ban(reason='Posting same message repeatedly', delete_message_days=1)
+		context.deleted_messages |= context.messages
+		context.is_kicked = True
+		context.is_banned = True
+		await self.__update_from_context(context)
 
 	@commands.Cog.listener()
-	def on_message(self, message: Message):
-		self.__record_message(message)
-		self.__check_for_spam(message.guild)
+	async def on_message(self, message: Message):
+		await self.__record_message(message)

rocketbot.py

@@ -10,12 +10,13 @@ from discord.ext import commands
 
 from config import CONFIG
 from cogs.configcog import ConfigCog
+# from cogs.crosspostcog import CrossPostCog
 from cogs.generalcog import GeneralCog
 from cogs.joinraidcog import JoinRaidCog
 
 class Rocketbot(commands.Bot):
-    def __init__(self, command_prefix, **kwargs):
-        super().__init__(command_prefix, **kwargs)
+	def __init__(self, command_prefix, **kwargs):
+		super().__init__(command_prefix, **kwargs)
 
 intents = Intents.default()
 intents.messages = True
@@ -24,5 +25,6 @@ bot = Rocketbot(command_prefix=CONFIG['commandPrefix'], 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)
 print('\nBot aborted')

rscollections.py

@@ -407,7 +407,7 @@ class AgeBoundList(AbstractMutableList):
 	The `element_age` lambda takes two arguments: the element index and the
 	element value. It must return values that can be compared to one another
 	and be added and subtracted (e.g. int, float, datetime). If the lambda
-	returns `datetime`s, the `max_age` should be a `timespan`.
+	returns `datetime`s, the `max_age` should be a `timedelta`.
 
 	`self.element_age` and `self.max_age` can be modified at runtime,
 	however elements will only be discarded following the next mutating
@@ -466,7 +466,7 @@ class AgeBoundSet(AbstractMutableSet):
 	The `element_age` lambda takes one argument: the element value. It must
 	return values that can be compared to one another and be added and
 	subtracted (e.g. int, float, datetime). If the lambda returns `datetime`s,
-	the `max_age` should be a `timespan`.
+	the `max_age` should be a `timedelta`.
 
 	`self.element_age` and `self.max_age` can be modified at runtime,
 	however elements will only be discarded following the next mutating
@@ -524,7 +524,7 @@ class AgeBoundDict(AbstractMutableDict):
 	The `element_age` lambda takes two arguments: the key and value of a pair.
 	It must return values that can be compared to one another and be added and
 	subtracted (e.g. int, float, datetime). If the lambda returns `datetime`s,
-	the `max_age` should be a `timespan`.
+	the `max_age` should be a `timedelta`.
 
 	`self.element_age` and `self.max_age` can be modified at runtime,
 	however elements will only be discarded following the next mutating