feat(implement:AutoMod): Added support for providing a reason when creating, editing and deleting an automod rule

Author: mccoderpy

discord/automod.py

@@ -42,7 +42,7 @@
 from . import utils
 from .role import Role
 from .object import Object
-from .abc import GuildChannel
+from .abc import GuildChannel, Snowflake
 from .utils import SnowflakeList
 from .errors import ClientException
 from .enums import AutoModEventType, AutoModKeywordPresetType, AutoModActionType, AutoModTriggerType, try_enum
@@ -342,6 +342,9 @@ def __init__(self,
         self._state: ConnectionState = state
         self.guild: Guild = guild
         self.id: int = int(data['id'])
+        self._update(data)
+
+    def _update(self, data) -> AutoModRule:
         self.name: str = data['name']
         self.creator_id: int = int(data['creator_id'])
         self.event_type: AutoModEventType = try_enum(AutoModEventType, data['event_type'])
@@ -351,6 +354,7 @@ def __init__(self,
         self.enabled: bool = data['enabled']
         self._exempt_roles: SnowflakeList = SnowflakeList(map(int, data['exempt_roles']))
         self._exempt_channels: SnowflakeList = SnowflakeList(map(int, data['exempt_channels']))
+        return self
 
     def __repr__(self) -> str:
         return f'<AutoModRule "{self.name}" guild_id={self.guild.id} creator_id={self.creator_id}>'
@@ -430,6 +434,126 @@ def created_at(self) -> datetime.datetime:
         """:class:`datetime.datetime`: When the rule was created in UTC"""
         return utils.snowflake_time(self.id)
 
+    async def delete(self, *, reason: Optional[str]) -> None:
+        """|coro|
+
+        Deletes the automod rule, this requires the :attr:`~Permissions.manage_server` permission.
+
+        Parameters
+        -----------
+        reason: Optional[:class:`str`]
+            The reason for deleting this rule. Shows up in the audit log.
+
+        Raises
+        ------
+        :exc:`discord.Forbidden`
+            The bot is missing permissions to delete the rule
+        :exc:`~discord.HTTPException`
+            Deleting the rule failed
+        """
+        await self._state.http.delete_automod_rule(self.guild.id, self.id, reason=reason)
+
+    async def edit(self, *, reason: Optional[str] = None, **payload) -> AutoModRule:
+        """|coro|
+
+        Edits the automod rule, this requires the :attr:`~Permissions.manage_server` permission.
+
+        Parameters
+        ----------
+        name: Optional[:class:`str`]
+            The name, the rule should have. Only valid if it's not a preset rule.
+        event_type: Optional[:class:`~discord.AutoModEventType`]
+            Indicates in what event context a rule should be checked
+        trigger_type: Optional[:class:`~discord.AutoModTriggerType`]
+            Characterizes the type of content which can trigger the rule
+        trigger_metadata: Optional[:class:`~discord.AutoModTriggerMetadata`]
+            Additional data used to determine whether a rule should be triggered.
+            Different fields are relevant based on the value of :attr:`~AutoModRule.trigger_type`.
+        actions: Optional[List[:class:`~discord.AutoModAction`]]
+            The actions which will execute when the rule is triggered.
+        enabled: Optional[:class:`bool`]
+            Whether the rule is enabled, default :obj:`True`.
+        exempt_roles: Optional[List[:class:`.Snowflake`]]
+            Up to 20 :class:`~discord.Role`'s, that should not be affected by the rule.
+        exempt_channels: Optional[List[:class:`.Snowflake`]]
+            Up to 50 :class:`~discord.TextChannel`/:class:`~discord.VoiceChannel`'s, that should not be affected by the rule.
+        reason: Optional[:class:`str`]
+            The reason for editing the rule. Shows up in the audit log.
+
+        Raises
+        -------
+        :exc:`discord.Forbidden`
+            The bot is missing permissions to edit the rule
+        :exc:`~discord.HTTPException`
+            Editing the rule failed
+
+        Returns
+        -------
+        :class:`AutoModRule`
+            The updated rule on success.
+        """
+        data = {}
+
+        try:
+            name: str = payload['name']
+        except KeyError:
+            pass
+        else:
+            data['name'] = name
+
+        try:
+            event_type: AutoModEventType = payload['event_type']
+        except KeyError:
+            pass
+        else:
+            data['event_type'] = int(event_type)
+
+        try:
+            trigger_type = payload['trigger_type']
+        except KeyError:
+            pass
+        else:
+            data['trigger_type'] = int(trigger_type)
+
+        try:
+            trigger_metadata: AutoModTriggerMetadata = payload['trigger_metadata']
+        except KeyError:
+            pass
+        else:
+            data['trigger_metadata'] = int(trigger_metadata)
+
+        try:
+            exempt_channels: List[Snowflake] = payload['exempt_channels']
+        except KeyError:
+            exempt_channels = self._exempt_channels
+        data['exempt_channels'] = exempt_channels = [str(c.id) for c in exempt_channels]
+        
+        try:
+            actions: List[AutoModAction] = payload['actions']
+        except KeyError:
+            pass
+        else:
+            for action in actions:  # Add the channels where messages should be logged to, to the exempted channels
+                if action.type.send_alert_message and str(action.channel_id) not in exempt_channels:
+                    exempt_channels.append(str(action.channel_id))
+            data['actions'] = [a.to_dict() for a in actions]
+
+        try:
+            enabled: bool = payload['enabled']
+        except KeyError:
+            pass
+        else:
+            data['enabled'] = enabled
+
+        try:
+            exempt_roles: List[Snowflake] = payload['exempt_roles']
+        except KeyError:
+            pass
+        else:
+            data['exempt_roles'] = [str(r.id) for r in exempt_roles]
+        data = await self._state.http.edit_automod_rule(self.guild.id, self.id, data=data, reason=reason)
+        return self._update(data)
+
 
 class AutoModActionPayload:
     """Represents the payload for an :func:`on_automod_action` event

discord/guild.py

@@ -2824,42 +2824,45 @@ async def create_automod_rule(self,
                                   actions: List[AutoModAction],
                                   enabled: bool = True,
                                   exempt_roles: List['Snowflake'] = [],
-                                  exempt_channels: List['Snowflake'] = []) -> AutoModRule:
+                                  exempt_channels: List['Snowflake'] = [],
+                                  *, reason: Optional[str] = None) -> AutoModRule:
         """|coro|
 
         Creates a new AutoMod rule for this guild
 
         Parameters
         -----------
         name: :class:`str`
-            The name, the rule should have
+            The name, the rule should have. Only valid if it's not a preset rule.
         event_type: :class:`~discord.AutoModEventType`
-            Indicates in what event context a rule should be checked
+            Indicates in what event context a rule should be checked.
         trigger_type: :class:`~discord.AutoModTriggerType`
-            Characterizes the type of content which can trigger the rule
+            Characterizes the type of content which can trigger the rule.
         trigger_metadata: :class:`~discord.AutoModTriggerMetadata`
             Additional data used to determine whether a rule should be triggered.
-            Different fields are relevant based on the value of :attr:`~Guild.create_automod_rule.trigger_type`.
+            Different fields are relevant based on the value of :attr:`~AutoModRule.trigger_type`.
         actions: List[:class:`~discord.AutoModAction`]
-            The actions which will execute when the rule is triggered
+            The actions which will execute when the rule is triggered.
         enabled: :class:`bool`
-            Whether the rule is enabled, default ``True``
+            Whether the rule is enabled, default :obj:`True`.
         exempt_roles: List[:class:`.Snowflake`]
-            Up to 20 :class:`~discord.Role`'s, that should not be affected by the rule
+            Up to 20 :class:`~discord.Role`'s, that should not be affected by the rule.
         exempt_channels: List[:class:`.Snowflake`]
-            Up to 50 :class:`~discord.TextChannel`/:class:`~discord.VoiceChannel`'s, that should not be affected by the rule
-
-        Returns
-        --------
-        :class:`~discord.AutoModRule`
-            The AutoMod rule created
+            Up to 50 :class:`~discord.TextChannel`/:class:`~discord.VoiceChannel`'s, that should not be affected by the rule.
+        reason: Optional[:class:`str`]
+            The reason for creating the rule. Shows up in the audit log.
 
         Raises
         ------
         :exc:`discord.Forbidden`
             The bot is missing permissions to create AutoMod rules
         :exc:`~discord.HTTPException`
             Creating the rule failed
+
+        Returns
+        --------
+        :class:`~discord.AutoModRule`
+            The AutoMod rule created
         """
         data = {
             'name': name,
@@ -2870,12 +2873,12 @@ async def create_automod_rule(self,
             'enabled': enabled,
             'exempt_roles': [str(r.id) for r in exempt_roles]
         }
-        except_channels = [str(c.id) for c in exempt_channels]
+        exempt_channels = [str(c.id) for c in exempt_channels]
         for action in actions:  # Add the channels where messages should be logged to, to the exempted channels
-            if action.type.send_alert_message and str(action.channel_id) not in except_channels:
-                except_channels.append(str(action.channel_id))
-        data['exempt_channels'] = except_channels
-        rule_data = await self._state.http.create_automod_rule(guild_id=self.id, data=data)
+            if action.type.send_alert_message and str(action.channel_id) not in exempt_channels:
+                exempt_channels.append(str(action.channel_id))
+        data['exempt_channels'] = exempt_channels
+        rule_data = await self._state.http.create_automod_rule(guild_id=self.id, data=data, reason=reason)
         rule = AutoModRule(state=self._state, guild=self, data=rule_data)
         self._add_automod_rule(rule)
         return rule

discord/http.py

@@ -1284,14 +1284,17 @@ def get_automod_rules(self, guild_id: int):
     def get_automod_rule(self, guild_id: int, rule_id: int):
         return self.request(Route('GET', '/guilds/{guild_id}/auto-moderation/rules/{rule_id}', guild_id=guild_id, rule_id=rule_id))
 
-    def create_automod_rule(self, guild_id: int, data: dict):
-        return self.request(Route('POST', '/guilds/{guild_id}/auto-moderation/rules', guild_id=guild_id), json=data)
+    def create_automod_rule(self, guild_id: int, data: dict, reason: str = None):
+        r = Route('POST', '/guilds/{guild_id}/auto-moderation/rules', guild_id=guild_id)
+        return self.request(r, json=data, reason=reason)
 
-    def edit_automod_rule(self, guild_id: int, rule_id: int, data: dict):
-        return self.request(Route('PATCH', '/guilds/{guild_id}/auto-moderation/rules/{rule_id}', guild_id=guild_id, rule_id=rule_id), json=data)
+    def edit_automod_rule(self, guild_id: int, rule_id: int, data: dict, reason: str = None):
+        r = Route('PATCH', '/guilds/{guild_id}/auto-moderation/rules/{rule_id}', guild_id=guild_id, rule_id=rule_id)
+        return self.request(r, json=data, reason=reason)
 
-    def delete_automod_rule(self, guild_id: int, rule_id: int):
-        return self.request(Route('DELETE', '/guilds/{guild_id}/auto-moderation/rules/{rule_id}', guild_id=guild_id, rule_id=rule_id))
+    def delete_automod_rule(self, guild_id: int, rule_id: int, reason: str = None):
+        r = Route('DELETE', '/guilds/{guild_id}/auto-moderation/rules/{rule_id}', guild_id=guild_id, rule_id=rule_id)
+        return self.request(r, reason=reason)
 
     # Misc
     def application_info(self):