Making DeleteRepeats having a custom value per channel

redbot/cogs/mod/events.py

@@ -3,6 +3,7 @@
 from collections import defaultdict, deque
 
 import discord
+from redbot.cogs.mod.utils import create_new_cache
 from redbot.core import i18n, modlog, commands
 from redbot.core.utils.mod import is_mod_or_superior
 from .abc import MixinMeta
@@ -18,21 +19,20 @@ class Events(MixinMeta):
     """
 
     async def check_duplicates(self, message):
+        if not message.content:
+            return False
+
         guild = message.guild
-        author = message.author
+        author = message.author.id
+        channel = message.channel
 
         guild_cache = self.cache.get(guild.id, None)
         if guild_cache is None:
-            repeats = await self.config.guild(guild).delete_repeats()
-            if repeats == -1:
-                return False
-            guild_cache = self.cache[guild.id] = defaultdict(lambda: deque(maxlen=repeats))
-
-        if not message.content:
-            return False
+            # Cache is dict (channel -> dict (author -> messages))
+            guild_cache = self.cache[guild.id] = await create_new_cache(self.config, guild)
 
-        guild_cache[author].append(message.content)
-        msgs = guild_cache[author]
+        guild_cache[channel.id][author].append(message.content)
+        msgs = guild_cache[channel.id][author]
         if len(msgs) == msgs.maxlen and len(set(msgs)) == 1:
             try:
                 await message.delete()

redbot/cogs/mod/mod.py

@@ -64,7 +64,7 @@ class Mod(
         "track_nicknames": True,
     }
 
-    default_channel_settings = {"ignored": False}
+    default_channel_settings = {"ignored": False, "delete_repeats": 0}
 
     default_member_settings = {"past_nicks": [], "perms_cache": {}, "banned_until": False}
 

redbot/cogs/mod/settings.py

@@ -1,11 +1,13 @@
 import asyncio
+import discord
 from collections import defaultdict, deque
 from typing import Optional
 from datetime import timedelta
 
 from redbot.core import commands, i18n, checks
 from redbot.core.utils import AsyncIter
 from redbot.core.utils.chat_formatting import box, humanize_timedelta, inline
+from redbot.cogs.mod.utils import create_new_cache
 
 from .abc import MixinMeta
 
@@ -59,6 +61,17 @@ async def modset_showsettings(self, ctx: commands.Context):
             if delete_repeats != -1
             else _("No")
         )
+        custom = ""
+        channel_data = await self.config.all_channels()
+        for channel in ctx.guild.channels:
+            data = data = channel_data.get(channel.id, None)
+            if data is not None and data["delete_repeats"] != 0:
+                custom += f"\t{channel.name} - {data['delete_repeats']}\n"
+        msg += _(
+            "Delete repeats custom channels: \n{delete_repeat_channels}".format(
+                delete_repeat_channels=custom if len(custom) != 0 else "None\n"
+            )
+        )
         msg += _("Warn mention spam: {num_mentions}\n").format(
             num_mentions=_("{num} mentions").format(num=warn_mention_spam)
             if warn_mention_spam
@@ -283,33 +296,97 @@ async def mentionspam_ban(self, ctx: commands.Context, max_mentions: int):
 
     @modset.command()
     @commands.guild_only()
-    async def deleterepeats(self, ctx: commands.Context, repeats: int = None):
+    async def deleterepeats(self, ctx: commands.Context, repeats: int = None, *channels):
         """Enable auto-deletion of repeated messages.
 
         Must be between 2 and 20.
 
         Set to -1 to disable this feature.
+
+        Add channels if you want to custom the value for the channels (#name_of_channel)
+
+        Set to 0 if you want to use the default value for the channel selected
+
         """
+        test = 1
         guild = ctx.guild
+        # Create cache if not created
+        guild_cache = self.cache.get(guild.id, None)
+        if guild_cache is None:
+            guild_cache = self.cache[guild.id] = await create_new_cache(self.config, guild)
+
+        fails = set()
+        success = set()
+        for channel_id in channels:
+            # Removing every non-digit number
+            channel_id_digits = "".join(ch for ch in channel_id if ch.isdigit())
+            channel_id_digits
+            channel = ctx.guild.get_channel(
+                int(channel_id_digits) if len(channel_id_digits) != 0 else 0
+            )
+            if channel is None:
+                fails.add(channel_id)
+            else:
+                success.add(channel)
+
+        if len(fails) > 0:
+            msg = _("Discord failed to recognize the following channels : (")
+            for channel in fails:
+                msg += _(f"{channel},")
+            await ctx.send(msg + ")")
+
         if repeats is not None:
             if repeats == -1:
-                await self.config.guild(guild).delete_repeats.set(repeats)
-                self.cache.pop(guild.id, None)  # remove cache with old repeat limits
-                await ctx.send(_("Repeated messages will be ignored."))
+                if len(channels) != 0:
+                    channels_string = ""
+                    for channel in success:
+                        channels_string += _("{name}, ").format(name=channel.name)
+                        await self.config.channel(channel).delete_repeats.set(repeats)
+                    msg = _("Repeated messages will be ignored for the following channels : ( ")
+
+                    await ctx.send(_(msg + channels_string + ")"))
+                    self.cache[guild.id][channel.id] = defaultdict(lambda: deque(maxlen=0))
+                else:
+                    await self.config.guild(guild).delete_repeats.set(repeats)
+                    await ctx.send(_("Repeated messages will be ignored."))
+                    self.cache[guild.id] = await create_new_cache(self.config, guild)
             elif 2 <= repeats <= 20:
-                await self.config.guild(guild).delete_repeats.set(repeats)
-                # purge and update cache to new repeat limits
-                self.cache[guild.id] = defaultdict(lambda: deque(maxlen=repeats))
-                await ctx.send(
-                    _("Messages repeated up to {num} times will be deleted.").format(num=repeats)
-                )
+                if len(channels) != 0:
+                    channels_string = ""
+                    for channel in success:
+                        channels_string += _("{name}, ").format(name=channel.name)
+                        await self.config.channel(channel).delete_repeats.set(repeats)
+                        self.cache[guild.id][channel.id] = defaultdict(
+                            lambda: deque(maxlen=repeats)
+                        )
+                    msg = _(
+                        "Messages repeated up to {num} times will be deleted for the following channels : ( "
+                    ).format(num=repeats)
+                    await ctx.send(_(msg + channels_string + ")"))
+
+                else:
+                    await self.config.guild(guild).delete_repeats.set(repeats)
+                    await ctx.send(
+                        _("Messages repeated up to {num} times will be deleted.").format(
+                            num=repeats
+                        )
+                    )
+                    # purge and update cache to new repeat limits
+                    self.cache[guild.id] = await create_new_cache(self.config, guild)
+
             else:
-                await ctx.send(
-                    _(
-                        "Number of repeats must be between 2 and 20"
-                        " or equal to -1 if you want to disable this feature!"
+                if repeats == 0 and channels is not None:
+                    for channel in success:
+                        await self.config.channel(channel).delete_repeats.set(repeats)
+                        # reset the cache for this channel
+                        self.cache[guild.id].pop(channel.id, None)
+                else:
+                    await ctx.send(
+                        _(
+                            "Number of repeats must be between 2 and 20"
+                            " or equal to -1 if you want to disable this feature!"
+                        )
                     )
-                )
         else:
             repeats = await self.config.guild(guild).delete_repeats()
             if repeats != -1:

redbot/cogs/mod/utils.py

@@ -1,5 +1,7 @@
 import discord
 
+from collections import defaultdict, deque
+
 from redbot.core.bot import Red
 from redbot.core.config import Config
 
@@ -11,3 +13,21 @@ async def is_allowed_by_hierarchy(
         return True
     is_special = mod == guild.owner or await bot.is_owner(mod)
     return mod.top_role > user.top_role or is_special
+
+
+def lambda_cache(repeats_channel):
+    return lambda: deque(maxlen=repeats_channel if repeats_channel != -1 else 0)
+
+
+async def create_new_cache(config: Config, guild: discord.Guild):
+    repeats = await config.guild(guild).delete_repeats()
+    channel_data = await config.all_channels()
+    guild_cache = defaultdict(
+        lambda: defaultdict(lambda: deque(maxlen=repeats if repeats != -1 else 0))
+    )
+    # Create already keys for custom amount of repeated messages per channel
+    for channel in guild.channels:
+        data = channel_data.get(channel.id, None)
+        if data is not None and data["delete_repeats"]:
+            guild_cache[channel.id] = defaultdict(lambda_cache(data["delete_repeats"]))
+    return guild_cache