Automated mod action immunity settings (#2129)

Refactors, and fixes some logic in filter which was encountered while
applying the settings to core

redbot/core/bot.py

@@ -5,6 +5,7 @@ from collections import Counter
 from enum import Enum
 from importlib.machinery import ModuleSpec
 from pathlib import Path
+from typing import Union
 
 import discord
 import sys
@@ -72,6 +73,7 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin):
             use_bot_color=False,
             fuzzy=False,
             disabled_commands=[],
+            autoimmune_ids=[],
         )
 
         self.db.register_user(embeds=None)
@@ -294,6 +296,41 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin):
             if pkg_name.startswith("redbot.cogs."):
                 del sys.modules["redbot.cogs"].__dict__[name]
 
+    async def is_automod_immune(
+        self, to_check: Union[discord.Message, commands.Context, discord.abc.User, discord.Role]
+    ) -> bool:
+        """
+        Checks if the user, message, context, or role should be considered immune from automated
+        moderation actions.
+
+        This will return ``False`` in direct messages.
+
+        Parameters
+        ----------
+        to_check : `discord.Message` or `commands.Context` or `discord.abc.User` or `discord.Role`
+            Something to check if it would be immune
+
+        Returns
+        -------
+        bool
+            ``True`` if immune
+
+        """
+        guild = to_check.guild
+        if not guild:
+            return False
+
+        if isinstance(to_check, discord.Role):
+            ids_to_check = [to_check.id]
+        else:
+            author = getattr(to_check, "author", to_check)
+            ids_to_check = [r.id for r in author.roles]
+            ids_to_check.append(author.id)
+
+        immune_ids = await self.db.guild(guild).autoimmune_ids()
+
+        return any(i in immune_ids for i in ids_to_check)
+
     @staticmethod
     async def send_filtered(
         destination: discord.abc.Messageable,

redbot/core/core_commands.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from random import SystemRandom
 from string import ascii_letters, digits
 from distutils.version import StrictVersion
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 
 import aiohttp
 import discord
@@ -1694,6 +1694,82 @@ class Core(CoreLogic):
         await ctx.bot.db.disabled_command_msg.set(message)
         await ctx.tick()
 
+    @commands.guild_only()
+    @checks.guildowner_or_permissions(manage_server=True)
+    @commands.group(name="autoimmune")
+    async def autoimmune_group(self, ctx: commands.Context):
+        """
+        Server settings for immunity from automated actions
+        """
+        pass
+
+    @autoimmune_group.command(name="list")
+    async def autoimmune_list(self, ctx: commands.Context):
+        """
+        Get's the current members and roles 
+        
+        configured for automatic moderation action immunity
+        """
+        ai_ids = await ctx.bot.db.guild(ctx.guild).autoimmune_ids()
+
+        roles = {r.name for r in ctx.guild.roles if r.id in ai_ids}
+        members = {str(m) for m in ctx.guild.members if m.id in ai_ids}
+
+        output = ""
+        if roles:
+            output += _("Roles immune from automated moderation actions:\n")
+            output += ", ".join(roles)
+        if members:
+            if roles:
+                output += "\n"
+            output += _("Members immune from automated moderation actions:\n")
+            output += ", ".join(members)
+
+        if not output:
+            output = _("No immunty settings here.")
+
+        for page in pagify(output):
+            await ctx.send(page)
+
+    @autoimmune_group.command(name="add")
+    async def autoimmune_add(
+        self, ctx: commands.Context, user_or_role: Union[discord.Member, discord.Role]
+    ):
+        """
+        Makes a user or roles immune from automated moderation actions
+        """
+        async with ctx.bot.db.guild(ctx.guild).autoimmune_ids() as ai_ids:
+            if user_or_role.id in ai_ids:
+                return await ctx.send(_("Already added."))
+            ai_ids.append(user_or_role.id)
+        await ctx.tick()
+
+    @autoimmune_group.command(name="remove")
+    async def autoimmune_remove(
+        self, ctx: commands.Context, user_or_role: Union[discord.Member, discord.Role]
+    ):
+        """
+        Makes a user or roles immune from automated moderation actions
+        """
+        async with ctx.bot.db.guild(ctx.guild).autoimmune_ids() as ai_ids:
+            if user_or_role.id not in ai_ids:
+                return await ctx.send(_("Not in list."))
+            ai_ids.remove(user_or_role.id)
+        await ctx.tick()
+
+    @autoimmune_group.command(name="isimmune")
+    async def autoimmune_checkimmune(
+        self, ctx: commands.Context, user_or_role: Union[discord.Member, discord.Role]
+    ):
+        """
+        Checks if a user or role would be considered immune from automated actions
+        """
+
+        if await ctx.bot.is_automod_immune(user_or_role):
+            await ctx.send(_("They are immune"))
+        else:
+            await ctx.send(_("They are not Immune"))
+
     # RPC handlers
     async def rpc_load(self, request):
         cog_name = request.params[0]