From 61d652a32ce23373e67bb0e1cf985dd4ffc99a18 Mon Sep 17 00:00:00 2001
From: Chris Lovering <chris.lovering.95@gmail.com>
Date: Fri, 21 Jan 2022 21:30:41 +0000
Subject: Rename voice_ban type to voice_mute

This commit changes all of the back-end so that it is in line with the new site API (see this PR https://github.com/python-discord/site/pull/608).

This comes with no changes to commands, or functions definitions.
---
 bot/exts/moderation/infraction/_utils.py             |  2 +-
 bot/exts/moderation/infraction/infractions.py        | 20 ++++++++++----------
 bot/exts/moderation/voice_gate.py                    |  4 ++--
 .../exts/moderation/infraction/test_infractions.py   |  8 ++++----
 4 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/bot/exts/moderation/infraction/_utils.py b/bot/exts/moderation/infraction/_utils.py
index e683c9db4..4df833ffb 100644
--- a/bot/exts/moderation/infraction/_utils.py
+++ b/bot/exts/moderation/infraction/_utils.py
@@ -21,7 +21,7 @@ INFRACTION_ICONS = {
     "note": (Icons.user_warn, None),
     "superstar": (Icons.superstarify, Icons.unsuperstarify),
     "warning": (Icons.user_warn, None),
-    "voice_ban": (Icons.voice_state_red, Icons.voice_state_green),
+    "voice_mute": (Icons.voice_state_red, Icons.voice_state_green),
 }
 RULES_URL = "https://pythondiscord.com/pages/rules"
 
diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index e495a94b3..72e09cbf4 100644
--- a/bot/exts/moderation/infraction/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -27,7 +27,7 @@ class Infractions(InfractionScheduler, commands.Cog):
     category_description = "Server moderation tools."
 
     def __init__(self, bot: Bot):
-        super().__init__(bot, supported_infractions={"ban", "kick", "mute", "note", "warning", "voice_ban"})
+        super().__init__(bot, supported_infractions={"ban", "kick", "mute", "note", "warning", "voice_mute"})
 
         self.category = "Moderation"
         self._muted_role = discord.Object(constants.Roles.muted)
@@ -273,7 +273,7 @@ class Infractions(InfractionScheduler, commands.Cog):
     @command(aliases=("uvban",))
     async def unvoiceban(self, ctx: Context, user: UnambiguousMemberOrUser) -> None:
         """Prematurely end the active voice ban infraction for the user."""
-        await self.pardon_infraction(ctx, "voice_ban", user)
+        await self.pardon_infraction(ctx, "voice_mute", user)
 
     # endregion
     # region: Base apply functions
@@ -397,10 +397,10 @@ class Infractions(InfractionScheduler, commands.Cog):
     @respect_role_hierarchy(member_arg=2)
     async def apply_voice_ban(self, ctx: Context, user: MemberOrUser, reason: t.Optional[str], **kwargs) -> None:
         """Apply a voice ban infraction with kwargs passed to `post_infraction`."""
-        if await _utils.get_active_infraction(ctx, user, "voice_ban"):
+        if await _utils.get_active_infraction(ctx, user, "voice_mute"):
             return
 
-        infraction = await _utils.post_infraction(ctx, user, "voice_ban", reason, active=True, **kwargs)
+        infraction = await _utils.post_infraction(ctx, user, "voice_mute", reason, active=True, **kwargs)
         if infraction is None:
             return
 
@@ -414,7 +414,7 @@ class Infractions(InfractionScheduler, commands.Cog):
             if not isinstance(user, Member):
                 return
 
-            await user.move_to(None, reason="Disconnected from voice to apply voiceban.")
+            await user.move_to(None, reason="Disconnected from voice to apply voice mute.")
             await user.remove_roles(self._voice_verified_role, reason=reason)
 
         await self.apply_infraction(ctx, infraction, user, action())
@@ -487,9 +487,9 @@ class Infractions(InfractionScheduler, commands.Cog):
                 # DM user about infraction expiration
                 notified = await _utils.notify_pardon(
                     user=user,
-                    title="Voice ban ended",
-                    content="You have been unbanned and can verify yourself again in the server.",
-                    icon_url=_utils.INFRACTION_ICONS["voice_ban"][1]
+                    title="Voice mute ended",
+                    content="You have been unmuted and can verify yourself again in the server.",
+                    icon_url=_utils.INFRACTION_ICONS["voice_mute"][1]
                 )
                 log_text["DM"] = "Sent" if notified else "**Failed**"
 
@@ -514,8 +514,8 @@ class Infractions(InfractionScheduler, commands.Cog):
             return await self.pardon_mute(user_id, guild, reason, notify=notify)
         elif infraction["type"] == "ban":
             return await self.pardon_ban(user_id, guild, reason)
-        elif infraction["type"] == "voice_ban":
-            return await self.pardon_voice_ban(user_id, guild, notify=notify)
+        elif infraction["type"] == "voice_mute":
+            return await self.pardon_voice_mute(user_id, guild, notify=notify)
 
     # endregion
 
diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index a382b13d1..42505b8e7 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -30,7 +30,7 @@ FAILED_MESSAGE = (
 
 MESSAGE_FIELD_MAP = {
     "joined_at": f"have been on the server for less than {GateConf.minimum_days_member} days",
-    "voice_banned": "have an active voice ban infraction",
+    "voice_muted": "have an active voice mute infraction",
     "total_messages": f"have sent less than {GateConf.minimum_messages} messages",
     "activity_blocks": f"have been active for fewer than {GateConf.minimum_activity_blocks} ten-minute blocks",
 }
@@ -170,7 +170,7 @@ class VoiceGate(Cog):
                 ctx.author.joined_at > arrow.utcnow() - timedelta(days=GateConf.minimum_days_member)
             ),
             "total_messages": data["total_messages"] < GateConf.minimum_messages,
-            "voice_banned": data["voice_banned"],
+            "voice_muted": data["voice_muted"],
             "activity_blocks": data["activity_blocks"] < GateConf.minimum_activity_blocks,
         }
 
diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 4d01e18a5..a796fd049 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -89,7 +89,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         """Should call infraction pardoning function."""
         self.cog.pardon_infraction = AsyncMock()
         self.assertIsNone(await self.cog.unvoiceban(self.cog, self.ctx, self.user))
-        self.cog.pardon_infraction.assert_awaited_once_with(self.ctx, "voice_ban", self.user)
+        self.cog.pardon_infraction.assert_awaited_once_with(self.ctx, "voice_mute", self.user)
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
@@ -97,7 +97,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         """Should return early when user already have Voice Ban infraction."""
         get_active_infraction.return_value = {"foo": "bar"}
         self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
-        get_active_infraction.assert_awaited_once_with(self.ctx, self.user, "voice_ban")
+        get_active_infraction.assert_awaited_once_with(self.ctx, self.user, "voice_mute")
         post_infraction_mock.assert_not_awaited()
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
@@ -120,7 +120,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         post_infraction_mock.return_value = None
         self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar", my_kwarg=23))
         post_infraction_mock.assert_awaited_once_with(
-            self.ctx, self.user, "voice_ban", "foobar", active=True, my_kwarg=23
+            self.ctx, self.user, "voice_mute", "foobar", active=True, my_kwarg=23
         )
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
@@ -187,7 +187,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
         user = MockUser()
         await self.cog.voiceban(self.cog, self.ctx, user, reason=None)
-        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_ban", None, active=True, expires_at=None)
+        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_mute", None, active=True, expires_at=None)
         apply_infraction_mock.assert_called_once_with(self.cog, self.ctx, infraction, user, ANY)
 
         # Test action
-- 
cgit v1.2.3


From 32d77fa9839eb9d373106700dcc4927851d94635 Mon Sep 17 00:00:00 2001
From: Chris Lovering <chris.lovering.95@gmail.com>
Date: Fri, 21 Jan 2022 21:34:41 +0000
Subject: Refactor voice_ban function definitions to voice_mute

This changes all functions that reference voice_ban to voice_mute instead, which comes with breaking front-end changes.

These front end changes are desirable, so that moderators get used to use voice_mute now, rather than voice_ban, in preparation for when we roll out real voice_bans.
---
 bot/exts/moderation/infraction/infractions.py      | 42 ++++++------
 .../exts/moderation/infraction/test_infractions.py | 78 +++++++++++-----------
 2 files changed, 60 insertions(+), 60 deletions(-)

diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index 72e09cbf4..d6580bc14 100644
--- a/bot/exts/moderation/infraction/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -107,8 +107,8 @@ class Infractions(InfractionScheduler, commands.Cog):
         """
         await self.apply_ban(ctx, user, reason, 1, expires_at=duration)
 
-    @command(aliases=('vban',))
-    async def voiceban(
+    @command(aliases=("vmute",))
+    async def voicemute(
         self,
         ctx: Context,
         user: UnambiguousMemberOrUser,
@@ -117,11 +117,11 @@ class Infractions(InfractionScheduler, commands.Cog):
         reason: t.Optional[str]
     ) -> None:
         """
-        Permanently ban user from using voice channels.
+        Permanently mute user in voice channels.
 
-        If duration is specified, it temporarily voice bans that user for the given duration.
+        If duration is specified, it temporarily voice mutes that user for the given duration.
         """
-        await self.apply_voice_ban(ctx, user, reason, expires_at=duration)
+        await self.apply_voice_mute(ctx, user, reason, expires_at=duration)
 
     # endregion
     # region: Temporary infractions
@@ -185,17 +185,17 @@ class Infractions(InfractionScheduler, commands.Cog):
         """
         await self.apply_ban(ctx, user, reason, expires_at=duration)
 
-    @command(aliases=("tempvban", "tvban"))
-    async def tempvoiceban(
-            self,
-            ctx: Context,
-            user: UnambiguousMemberOrUser,
-            duration: Expiry,
-            *,
-            reason: t.Optional[str]
+    @command(aliases=("tempvmute", "tvmute"))
+    async def tempvoicemute(
+        self,
+        ctx: Context,
+        user: UnambiguousMemberOrUser,
+        duration: Expiry,
+        *,
+        reason: t.Optional[str]
     ) -> None:
         """
-        Temporarily voice ban a user for the given reason and duration.
+        Temporarily voice mute a user for the given reason and duration.
 
         A unit of time should be appended to the duration.
         Units (∗case-sensitive):
@@ -209,7 +209,7 @@ class Infractions(InfractionScheduler, commands.Cog):
 
         Alternatively, an ISO 8601 timestamp can be provided for the duration.
         """
-        await self.apply_voice_ban(ctx, user, reason, expires_at=duration)
+        await self.apply_voice_mute(ctx, user, reason, expires_at=duration)
 
     # endregion
     # region: Permanent shadow infractions
@@ -270,9 +270,9 @@ class Infractions(InfractionScheduler, commands.Cog):
         """Prematurely end the active ban infraction for the user."""
         await self.pardon_infraction(ctx, "ban", user)
 
-    @command(aliases=("uvban",))
-    async def unvoiceban(self, ctx: Context, user: UnambiguousMemberOrUser) -> None:
-        """Prematurely end the active voice ban infraction for the user."""
+    @command(aliases=("uvmute",))
+    async def unvoicemute(self, ctx: Context, user: UnambiguousMemberOrUser) -> None:
+        """Prematurely end the active voice mute infraction for the user."""
         await self.pardon_infraction(ctx, "voice_mute", user)
 
     # endregion
@@ -395,8 +395,8 @@ class Infractions(InfractionScheduler, commands.Cog):
         await bb_cog.apply_unwatch(ctx, user, bb_reason, send_message=False)
 
     @respect_role_hierarchy(member_arg=2)
-    async def apply_voice_ban(self, ctx: Context, user: MemberOrUser, reason: t.Optional[str], **kwargs) -> None:
-        """Apply a voice ban infraction with kwargs passed to `post_infraction`."""
+    async def apply_voice_mute(self, ctx: Context, user: MemberOrUser, reason: t.Optional[str], **kwargs) -> None:
+        """Apply a voice mute infraction with kwargs passed to `post_infraction`."""
         if await _utils.get_active_infraction(ctx, user, "voice_mute"):
             return
 
@@ -471,7 +471,7 @@ class Infractions(InfractionScheduler, commands.Cog):
 
         return log_text
 
-    async def pardon_voice_ban(
+    async def pardon_voice_mute(
         self,
         user_id: int,
         guild: discord.Guild,
diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index a796fd049..f89465f84 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -62,8 +62,8 @@ class TruncationTests(unittest.IsolatedAsyncioTestCase):
 
 
 @patch("bot.exts.moderation.infraction.infractions.constants.Roles.voice_verified", new=123456)
-class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
-    """Tests for voice ban related functions and commands."""
+class VoiceMuteTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for voice mute related functions and commands."""
 
     def setUp(self):
         self.bot = MockBot()
@@ -73,59 +73,59 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.ctx = MockContext(bot=self.bot, author=self.mod)
         self.cog = Infractions(self.bot)
 
-    async def test_permanent_voice_ban(self):
-        """Should call voice ban applying function without expiry."""
-        self.cog.apply_voice_ban = AsyncMock()
-        self.assertIsNone(await self.cog.voiceban(self.cog, self.ctx, self.user, reason="foobar"))
-        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at=None)
+    async def test_permanent_voice_mute(self):
+        """Should call voice mute applying function without expiry."""
+        self.cog.apply_voice_mute = AsyncMock()
+        self.assertIsNone(await self.cog.voicemute(self.cog, self.ctx, self.user, reason="foobar"))
+        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at=None)
 
-    async def test_temporary_voice_ban(self):
-        """Should call voice ban applying function with expiry."""
-        self.cog.apply_voice_ban = AsyncMock()
-        self.assertIsNone(await self.cog.tempvoiceban(self.cog, self.ctx, self.user, "baz", reason="foobar"))
-        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at="baz")
+    async def test_temporary_voice_mute(self):
+        """Should call voice mute applying function with expiry."""
+        self.cog.apply_voice_mute = AsyncMock()
+        self.assertIsNone(await self.cog.tempvoicemute(self.cog, self.ctx, self.user, "baz", reason="foobar"))
+        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at="baz")
 
-    async def test_voice_unban(self):
+    async def test_voice_unmute(self):
         """Should call infraction pardoning function."""
         self.cog.pardon_infraction = AsyncMock()
-        self.assertIsNone(await self.cog.unvoiceban(self.cog, self.ctx, self.user))
+        self.assertIsNone(await self.cog.unvoicemute(self.cog, self.ctx, self.user))
         self.cog.pardon_infraction.assert_awaited_once_with(self.ctx, "voice_mute", self.user)
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_user_have_active_infraction(self, get_active_infraction, post_infraction_mock):
-        """Should return early when user already have Voice Ban infraction."""
+    async def test_voice_mute_user_have_active_infraction(self, get_active_infraction, post_infraction_mock):
+        """Should return early when user already have Voice Mute infraction."""
         get_active_infraction.return_value = {"foo": "bar"}
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar"))
         get_active_infraction.assert_awaited_once_with(self.ctx, self.user, "voice_mute")
         post_infraction_mock.assert_not_awaited()
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_infraction_post_failed(self, get_active_infraction, post_infraction_mock):
+    async def test_voice_mute_infraction_post_failed(self, get_active_infraction, post_infraction_mock):
         """Should return early when posting infraction fails."""
         self.cog.mod_log.ignore = MagicMock()
         get_active_infraction.return_value = None
         post_infraction_mock.return_value = None
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar"))
         post_infraction_mock.assert_awaited_once()
         self.cog.mod_log.ignore.assert_not_called()
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_infraction_post_add_kwargs(self, get_active_infraction, post_infraction_mock):
-        """Should pass all kwargs passed to apply_voice_ban to post_infraction."""
+    async def test_voice_mute_infraction_post_add_kwargs(self, get_active_infraction, post_infraction_mock):
+        """Should pass all kwargs passed to apply_voice_mute to post_infraction."""
         get_active_infraction.return_value = None
         # We don't want that this continue yet
         post_infraction_mock.return_value = None
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar", my_kwarg=23))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar", my_kwarg=23))
         post_infraction_mock.assert_awaited_once_with(
             self.ctx, self.user, "voice_mute", "foobar", active=True, my_kwarg=23
         )
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_mod_log_ignore(self, get_active_infraction, post_infraction_mock):
+    async def test_voice_mute_mod_log_ignore(self, get_active_infraction, post_infraction_mock):
         """Should ignore Voice Verified role removing."""
         self.cog.mod_log.ignore = MagicMock()
         self.cog.apply_infraction = AsyncMock()
@@ -134,11 +134,11 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         get_active_infraction.return_value = None
         post_infraction_mock.return_value = {"foo": "bar"}
 
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar"))
         self.cog.mod_log.ignore.assert_called_once_with(Event.member_update, self.user.id)
 
     async def action_tester(self, action, reason: str) -> None:
-        """Helper method to test voice ban action."""
+        """Helper method to test voice mute action."""
         self.assertTrue(inspect.iscoroutine(action))
         await action
 
@@ -147,7 +147,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_apply_infraction(self, get_active_infraction, post_infraction_mock):
+    async def test_voice_mute_apply_infraction(self, get_active_infraction, post_infraction_mock):
         """Should ignore Voice Verified role removing."""
         self.cog.mod_log.ignore = MagicMock()
         self.cog.apply_infraction = AsyncMock()
@@ -156,22 +156,22 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         post_infraction_mock.return_value = {"foo": "bar"}
 
         reason = "foobar"
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, reason))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, reason))
         self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, ANY)
 
         await self.action_tester(self.cog.apply_infraction.call_args[0][-1], reason)
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_truncate_reason(self, get_active_infraction, post_infraction_mock):
-        """Should truncate reason for voice ban."""
+    async def test_voice_mute_truncate_reason(self, get_active_infraction, post_infraction_mock):
+        """Should truncate reason for voice mute."""
         self.cog.mod_log.ignore = MagicMock()
         self.cog.apply_infraction = AsyncMock()
 
         get_active_infraction.return_value = None
         post_infraction_mock.return_value = {"foo": "bar"}
 
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar" * 3000))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar" * 3000))
         self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, ANY)
 
         # Test action
@@ -180,13 +180,13 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
     @autospec(_utils, "post_infraction", "get_active_infraction", return_value=None)
     @autospec(Infractions, "apply_infraction")
-    async def test_voice_ban_user_left_guild(self, apply_infraction_mock, post_infraction_mock, _):
-        """Should voice ban user that left the guild without throwing an error."""
+    async def test_voice_mute_user_left_guild(self, apply_infraction_mock, post_infraction_mock, _):
+        """Should voice mute user that left the guild without throwing an error."""
         infraction = {"foo": "bar"}
         post_infraction_mock.return_value = {"foo": "bar"}
 
         user = MockUser()
-        await self.cog.voiceban(self.cog, self.ctx, user, reason=None)
+        await self.cog.voicemute(self.cog, self.ctx, user, reason=None)
         post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_mute", None, active=True, expires_at=None)
         apply_infraction_mock.assert_called_once_with(self.cog, self.ctx, infraction, user, ANY)
 
@@ -195,22 +195,22 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.assertTrue(inspect.iscoroutine(action))
         await action
 
-    async def test_voice_unban_user_not_found(self):
+    async def test_voice_unmute_user_not_found(self):
         """Should include info to return dict when user was not found from guild."""
         self.guild.get_member.return_value = None
         self.guild.fetch_member.side_effect = NotFound(Mock(status=404), "Not found")
-        result = await self.cog.pardon_voice_ban(self.user.id, self.guild)
+        result = await self.cog.pardon_voice_mute(self.user.id, self.guild)
         self.assertEqual(result, {"Info": "User was not found in the guild."})
 
     @patch("bot.exts.moderation.infraction.infractions._utils.notify_pardon")
     @patch("bot.exts.moderation.infraction.infractions.format_user")
-    async def test_voice_unban_user_found(self, format_user_mock, notify_pardon_mock):
+    async def test_voice_unmute_user_found(self, format_user_mock, notify_pardon_mock):
         """Should add role back with ignoring, notify user and return log dictionary.."""
         self.guild.get_member.return_value = self.user
         notify_pardon_mock.return_value = True
         format_user_mock.return_value = "my-user"
 
-        result = await self.cog.pardon_voice_ban(self.user.id, self.guild)
+        result = await self.cog.pardon_voice_mute(self.user.id, self.guild)
         self.assertEqual(result, {
             "Member": "my-user",
             "DM": "Sent"
@@ -219,13 +219,13 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
     @patch("bot.exts.moderation.infraction.infractions._utils.notify_pardon")
     @patch("bot.exts.moderation.infraction.infractions.format_user")
-    async def test_voice_unban_dm_fail(self, format_user_mock, notify_pardon_mock):
+    async def test_voice_unmute_dm_fail(self, format_user_mock, notify_pardon_mock):
         """Should add role back with ignoring, notify user and return log dictionary.."""
         self.guild.get_member.return_value = self.user
         notify_pardon_mock.return_value = False
         format_user_mock.return_value = "my-user"
 
-        result = await self.cog.pardon_voice_ban(self.user.id, self.guild)
+        result = await self.cog.pardon_voice_mute(self.user.id, self.guild)
         self.assertEqual(result, {
             "Member": "my-user",
             "DM": "**Failed**"
-- 
cgit v1.2.3


From 07211bb6eaec2b18a5e13fdfc08ed0f4697a72b6 Mon Sep 17 00:00:00 2001
From: Chris Lovering <chris.lovering.95@gmail.com>
Date: Fri, 21 Jan 2022 21:35:49 +0000
Subject: Add voice_ban stub commands

These stub commands are useful for moderators during the change over from voice_ban to voice_mute, to remind moderators that the command has been changed now.
---
 bot/exts/moderation/infraction/infractions.py | 29 +++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index d6580bc14..7c0259b8e 100644
--- a/bot/exts/moderation/infraction/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -107,6 +107,17 @@ class Infractions(InfractionScheduler, commands.Cog):
         """
         await self.apply_ban(ctx, user, reason, 1, expires_at=duration)
 
+    @command(aliases=("vban",))
+    async def voiceban(self, ctx: Context) -> None:
+        """
+        NOT IMPLEMENTED.
+
+        Permanently ban a user from joining voice channels.
+
+        If duration is specified, it temporarily voice bans that user for the given duration.
+        """
+        await ctx.send(":x: This command is not yet implemented. Maybe you meant to use `voicemute`?")
+
     @command(aliases=("vmute",))
     async def voicemute(
         self,
@@ -185,6 +196,15 @@ class Infractions(InfractionScheduler, commands.Cog):
         """
         await self.apply_ban(ctx, user, reason, expires_at=duration)
 
+    @command(aliases=("tempvban", "tvban"))
+    async def tempvoiceban(self, ctx: Context) -> None:
+        """
+        NOT IMPLEMENTED.
+
+        Temporarily voice bans that user for the given duration.
+        """
+        await ctx.send(":x: This command is not yet implemented. Maybe you meant to use `tempvoicemute`?")
+
     @command(aliases=("tempvmute", "tvmute"))
     async def tempvoicemute(
         self,
@@ -270,6 +290,15 @@ class Infractions(InfractionScheduler, commands.Cog):
         """Prematurely end the active ban infraction for the user."""
         await self.pardon_infraction(ctx, "ban", user)
 
+    @command(aliases=("uvban",))
+    async def unvoiceban(self, ctx: Context) -> None:
+        """
+        NOT IMPLEMENTED.
+
+        Temporarily voice bans that user for the given duration.
+        """
+        await ctx.send(":x: This command is not yet implemented. Maybe you meant to use `unvoicemute`?")
+
     @command(aliases=("uvmute",))
     async def unvoicemute(self, ctx: Context, user: UnambiguousMemberOrUser) -> None:
         """Prematurely end the active voice mute infraction for the user."""
-- 
cgit v1.2.3


From 30fee62d259e71619017420a356ed0f55bf21d2b Mon Sep 17 00:00:00 2001
From: minalike <sueminaoh@gmail.com>
Date: Thu, 27 Jan 2022 00:32:59 -0500
Subject: Add embed message mentioning help channel claimant

Update docstring
---
 bot/exts/help_channels/_cog.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 60209ba6e..541c791e5 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -105,10 +105,18 @@ class HelpChannels(commands.Cog):
         """
         Claim the channel in which the question `message` was sent.
 
-        Move the channel to the In Use category and pin the `message`. Add a cooldown to the
-        claimant to prevent them from asking another question. Lastly, make a new channel available.
+        Send an embed stating the claimant, move the channel to the In Use category, and pin the `message`.
+        Add a cooldown to the claimant to prevent them from asking another question.
+        Lastly, make a new channel available.
         """
         log.info(f"Channel #{message.channel} was claimed by `{message.author.id}`.")
+
+        embed = discord.Embed(
+            description=f"Channel claimed by {message.author.mention}.",
+            color=constants.Colours.bright_green,
+        )
+        await message.channel.send(embed=embed)
+
         await self.move_to_in_use(message.channel)
 
         # Handle odd edge case of `message.author` not being a `discord.Member` (see bot#1839)
-- 
cgit v1.2.3


From 01df37482ffa39138173070f97b7c9ec6e92a055 Mon Sep 17 00:00:00 2001
From: Chris Lovering <chris.lovering.95@gmail.com>
Date: Thu, 27 Jan 2022 20:31:23 +0000
Subject: Use `voice_gate_blocked` field from API for voice_gate

This new field is true when the user has any voice exception, which means the user is blocked from receiving the role.
---
 bot/exts/moderation/voice_gate.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 42505b8e7..fa66b00dd 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -30,7 +30,7 @@ FAILED_MESSAGE = (
 
 MESSAGE_FIELD_MAP = {
     "joined_at": f"have been on the server for less than {GateConf.minimum_days_member} days",
-    "voice_muted": "have an active voice mute infraction",
+    "voice_gate_blocked": "have an active voice infraction",
     "total_messages": f"have sent less than {GateConf.minimum_messages} messages",
     "activity_blocks": f"have been active for fewer than {GateConf.minimum_activity_blocks} ten-minute blocks",
 }
@@ -170,7 +170,7 @@ class VoiceGate(Cog):
                 ctx.author.joined_at > arrow.utcnow() - timedelta(days=GateConf.minimum_days_member)
             ),
             "total_messages": data["total_messages"] < GateConf.minimum_messages,
-            "voice_muted": data["voice_muted"],
+            "voice_gate_blocked": data["voice_gate_blocked"],
             "activity_blocks": data["activity_blocks"] < GateConf.minimum_activity_blocks,
         }
 
-- 
cgit v1.2.3


From 9f2d0839e4fb9d31d500db2c5bc5e22d59ed2cbb Mon Sep 17 00:00:00 2001
From: minalike <sueminaoh@gmail.com>
Date: Sat, 5 Feb 2022 11:06:01 -0500
Subject: Add reported message author's username and profile picture in embed

---
 bot/exts/moderation/incidents.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bot/exts/moderation/incidents.py b/bot/exts/moderation/incidents.py
index 77dfad255..b579416a6 100644
--- a/bot/exts/moderation/incidents.py
+++ b/bot/exts/moderation/incidents.py
@@ -229,6 +229,7 @@ async def make_message_link_embed(ctx: Context, message_link: str) -> Optional[d
             ),
             timestamp=message.created_at
         )
+        embed.set_author(name=message.author, icon_url=message.author.display_avatar.url)
         embed.add_field(
             name="Content",
             value=shorten_text(message.content) if message.content else "[No Message Content]"
-- 
cgit v1.2.3


From d8db2e5cfe9285350b286427c05a1781303e8443 Mon Sep 17 00:00:00 2001
From: Ben Soyka <bensoyka@icloud.com>
Date: Sun, 6 Feb 2022 17:34:26 -0700
Subject: Remove Coveralls dev dependency

---
 poetry.lock    | 34 ++--------------------------------
 pyproject.toml |  1 -
 2 files changed, 2 insertions(+), 33 deletions(-)

diff --git a/poetry.lock b/poetry.lock
index 9c9cc97ad..6d3bd44bb 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -155,6 +155,7 @@ python-versions = "3.9.*"
 [package.source]
 type = "url"
 url = "https://github.com/python-discord/bot-core/archive/511bcba1b0196cd498c707a525ea56921bd971db.zip"
+
 [[package]]
 name = "certifi"
 version = "2021.10.8"
@@ -234,22 +235,6 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"
 [package.extras]
 toml = ["toml"]
 
-[[package]]
-name = "coveralls"
-version = "2.2.0"
-description = "Show coverage stats online via coveralls.io"
-category = "dev"
-optional = false
-python-versions = ">= 3.5"
-
-[package.dependencies]
-coverage = ">=4.1,<6.0"
-docopt = ">=0.6.1"
-requests = ">=1.0.0"
-
-[package.extras]
-yaml = ["PyYAML (>=3.10)"]
-
 [[package]]
 name = "deepdiff"
 version = "4.3.2"
@@ -306,14 +291,6 @@ category = "dev"
 optional = false
 python-versions = "*"
 
-[[package]]
-name = "docopt"
-version = "0.6.2"
-description = "Pythonic argument parser, that will make you smile"
-category = "dev"
-optional = false
-python-versions = "*"
-
 [[package]]
 name = "emoji"
 version = "0.6.0"
@@ -1170,7 +1147,7 @@ multidict = ">=4.0"
 [metadata]
 lock-version = "1.1"
 python-versions = "3.9.*"
-content-hash = "d625aaae916c07c21080bf504831f5bf4d2bf4f0e3696e404448b43719eff201"
+content-hash = "0248fc7488c79af0cdb3a6db9528f4c3129db50b3a8d1dd3ba57dbc31b381c31"
 
 [metadata.files]
 aio-pika = [
@@ -1383,10 +1360,6 @@ coverage = [
     {file = "coverage-5.5-pp37-none-any.whl", hash = "sha256:2a3859cb82dcbda1cfd3e6f71c27081d18aa251d20a17d87d26d4cd216fb0af4"},
     {file = "coverage-5.5.tar.gz", hash = "sha256:ebe78fe9a0e874362175b02371bdfbee64d8edc42a044253ddf4ee7d3c15212c"},
 ]
-coveralls = [
-    {file = "coveralls-2.2.0-py2.py3-none-any.whl", hash = "sha256:2301a19500b06649d2ec4f2858f9c69638d7699a4c63027c5d53daba666147cc"},
-    {file = "coveralls-2.2.0.tar.gz", hash = "sha256:b990ba1f7bc4288e63340be0433698c1efe8217f78c689d254c2540af3d38617"},
-]
 deepdiff = [
     {file = "deepdiff-4.3.2-py3-none-any.whl", hash = "sha256:59fc1e3e7a28dd0147b0f2b00e3e27181f0f0ef4286b251d5f214a5bcd9a9bc4"},
     {file = "deepdiff-4.3.2.tar.gz", hash = "sha256:91360be1d9d93b1d9c13ae9c5048fa83d9cff17a88eb30afaa0d7ff2d0fee17d"},
@@ -1400,9 +1373,6 @@ distlib = [
     {file = "distlib-0.3.4-py2.py3-none-any.whl", hash = "sha256:6564fe0a8f51e734df6333d08b8b94d4ea8ee6b99b5ed50613f731fd4089f34b"},
     {file = "distlib-0.3.4.zip", hash = "sha256:e4b58818180336dc9c529bfb9a0b58728ffc09ad92027a3f30b7cd91e3458579"},
 ]
-docopt = [
-    {file = "docopt-0.6.2.tar.gz", hash = "sha256:49b3a825280bd66b3aa83585ef59c4a8c82f2c8a522dbe754a8bc8d08c85c491"},
-]
 emoji = [
     {file = "emoji-0.6.0.tar.gz", hash = "sha256:e42da4f8d648f8ef10691bc246f682a1ec6b18373abfd9be10ec0b398823bd11"},
 ]
diff --git a/pyproject.toml b/pyproject.toml
index 19e5f78a7..c764910c2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -36,7 +36,6 @@ tldextract = "^3.1.2"
 
 [tool.poetry.dev-dependencies]
 coverage = "~=5.0"
-coveralls = "~=2.1"
 flake8 = "~=3.8"
 flake8-annotations = "~=2.0"
 flake8-bugbear = "~=20.1"
-- 
cgit v1.2.3


From dd40e70db9c41c1a61faae5f2991cb841f2c6d10 Mon Sep 17 00:00:00 2001
From: Ben Soyka <bensoyka@icloud.com>
Date: Sun, 6 Feb 2022 17:41:43 -0700
Subject: Remove Coveralls badge from readme

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 9df905dc8..06df4fd9a 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,6 @@
 [![Lint & Test][1]][2]
 [![Build][3]][4]
 [![Deploy][5]][6]
-[![Coverage Status](https://coveralls.io/repos/github/python-discord/bot/badge.svg)](https://coveralls.io/github/python-discord/bot)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
 This project is a Discord bot specifically for use with the Python Discord server. It provides numerous utilities
-- 
cgit v1.2.3


From d7872d49f6355c811422ad39d299343c7fd7ef63 Mon Sep 17 00:00:00 2001
From: mbaruh <mbaruh@hotmail.com>
Date: Mon, 7 Feb 2022 05:45:34 +0200
Subject: Don't validate reminder author

Validation relies on the cache which might not be properly filled. This can cause reminders to be sent for users who are no longer in the server, which seems negligible.
---
 bot/exts/utils/reminders.py | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/bot/exts/utils/reminders.py b/bot/exts/utils/reminders.py
index 289d00356..ad82d49c9 100644
--- a/bot/exts/utils/reminders.py
+++ b/bot/exts/utils/reminders.py
@@ -66,20 +66,19 @@ class Reminders(Cog):
             else:
                 self.schedule_reminder(reminder)
 
-    def ensure_valid_reminder(self, reminder: dict) -> t.Tuple[bool, discord.User, discord.TextChannel]:
-        """Ensure reminder author and channel can be fetched otherwise delete the reminder."""
-        user = self.bot.get_user(reminder['author'])
+    def ensure_valid_reminder(self, reminder: dict) -> t.Tuple[bool, discord.TextChannel]:
+        """Ensure reminder channel can be fetched otherwise delete the reminder."""
         channel = self.bot.get_channel(reminder['channel_id'])
         is_valid = True
-        if not user or not channel:
+        if not channel:
             is_valid = False
             log.info(
                 f"Reminder {reminder['id']} invalid: "
-                f"User {reminder['author']}={user}, Channel {reminder['channel_id']}={channel}."
+                f"Channel {reminder['channel_id']}={channel}."
             )
             scheduling.create_task(self.bot.api_client.delete(f"bot/reminders/{reminder['id']}"))
 
-        return is_valid, user, channel
+        return is_valid, channel
 
     @staticmethod
     async def _send_confirmation(
@@ -170,7 +169,7 @@ class Reminders(Cog):
     @lock_arg(LOCK_NAMESPACE, "reminder", itemgetter("id"), raise_error=True)
     async def send_reminder(self, reminder: dict, expected_time: t.Optional[time.Timestamp] = None) -> None:
         """Send the reminder."""
-        is_valid, user, channel = self.ensure_valid_reminder(reminder)
+        is_valid, channel = self.ensure_valid_reminder(reminder)
         if not is_valid:
             # No need to cancel the task too; it'll simply be done once this coroutine returns.
             return
@@ -206,7 +205,7 @@ class Reminders(Cog):
                 f"There was an error when trying to reply to a reminder invocation message, {e}, "
                 "fall back to using jump_url"
             )
-            await channel.send(content=f"{user.mention} {additional_mentions}", embed=embed)
+            await channel.send(content=f"<@{reminder['author']}> {additional_mentions}", embed=embed)
 
         log.debug(f"Deleting reminder #{reminder['id']} (the user has been reminded).")
         await self.bot.api_client.delete(f"bot/reminders/{reminder['id']}")
-- 
cgit v1.2.3


From f037942d3b2ba77a568a12fc4fa703fee3274d90 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <hassan@hassanamr.com>
Date: Wed, 9 Feb 2022 07:58:04 +0200
Subject: Disable Reminders Cog (#2074)

---
 bot/exts/utils/reminders.py | 492 --------------------------------------------
 1 file changed, 492 deletions(-)
 delete mode 100644 bot/exts/utils/reminders.py

diff --git a/bot/exts/utils/reminders.py b/bot/exts/utils/reminders.py
deleted file mode 100644
index 289d00356..000000000
--- a/bot/exts/utils/reminders.py
+++ /dev/null
@@ -1,492 +0,0 @@
-import random
-import textwrap
-import typing as t
-from datetime import datetime, timezone
-from operator import itemgetter
-
-import discord
-from dateutil.parser import isoparse
-from discord.ext.commands import Cog, Context, Greedy, group
-
-from bot.bot import Bot
-from bot.constants import Guild, Icons, MODERATION_ROLES, POSITIVE_REPLIES, Roles, STAFF_PARTNERS_COMMUNITY_ROLES
-from bot.converters import Duration, UnambiguousUser
-from bot.log import get_logger
-from bot.pagination import LinePaginator
-from bot.utils import scheduling, time
-from bot.utils.checks import has_any_role_check, has_no_roles_check
-from bot.utils.lock import lock_arg
-from bot.utils.members import get_or_fetch_member
-from bot.utils.messages import send_denial
-from bot.utils.scheduling import Scheduler
-
-log = get_logger(__name__)
-
-LOCK_NAMESPACE = "reminder"
-WHITELISTED_CHANNELS = Guild.reminder_whitelist
-MAXIMUM_REMINDERS = 5
-
-Mentionable = t.Union[discord.Member, discord.Role]
-ReminderMention = t.Union[UnambiguousUser, discord.Role]
-
-
-class Reminders(Cog):
-    """Provide in-channel reminder functionality."""
-
-    def __init__(self, bot: Bot):
-        self.bot = bot
-        self.scheduler = Scheduler(self.__class__.__name__)
-
-        scheduling.create_task(self.reschedule_reminders(), event_loop=self.bot.loop)
-
-    def cog_unload(self) -> None:
-        """Cancel scheduled tasks."""
-        self.scheduler.cancel_all()
-
-    async def reschedule_reminders(self) -> None:
-        """Get all current reminders from the API and reschedule them."""
-        await self.bot.wait_until_guild_available()
-        response = await self.bot.api_client.get(
-            'bot/reminders',
-            params={'active': 'true'}
-        )
-
-        now = datetime.now(timezone.utc)
-
-        for reminder in response:
-            is_valid, *_ = self.ensure_valid_reminder(reminder)
-            if not is_valid:
-                continue
-
-            remind_at = isoparse(reminder['expiration'])
-
-            # If the reminder is already overdue ...
-            if remind_at < now:
-                await self.send_reminder(reminder, remind_at)
-            else:
-                self.schedule_reminder(reminder)
-
-    def ensure_valid_reminder(self, reminder: dict) -> t.Tuple[bool, discord.User, discord.TextChannel]:
-        """Ensure reminder author and channel can be fetched otherwise delete the reminder."""
-        user = self.bot.get_user(reminder['author'])
-        channel = self.bot.get_channel(reminder['channel_id'])
-        is_valid = True
-        if not user or not channel:
-            is_valid = False
-            log.info(
-                f"Reminder {reminder['id']} invalid: "
-                f"User {reminder['author']}={user}, Channel {reminder['channel_id']}={channel}."
-            )
-            scheduling.create_task(self.bot.api_client.delete(f"bot/reminders/{reminder['id']}"))
-
-        return is_valid, user, channel
-
-    @staticmethod
-    async def _send_confirmation(
-        ctx: Context,
-        on_success: str,
-        reminder_id: t.Union[str, int]
-    ) -> None:
-        """Send an embed confirming the reminder change was made successfully."""
-        embed = discord.Embed(
-            description=on_success,
-            colour=discord.Colour.green(),
-            title=random.choice(POSITIVE_REPLIES)
-        )
-
-        footer_str = f"ID: {reminder_id}"
-
-        embed.set_footer(text=footer_str)
-
-        await ctx.send(embed=embed)
-
-    @staticmethod
-    async def _check_mentions(ctx: Context, mentions: t.Iterable[Mentionable]) -> t.Tuple[bool, str]:
-        """
-        Returns whether or not the list of mentions is allowed.
-
-        Conditions:
-        - Role reminders are Mods+
-        - Reminders for other users are Helpers+
-
-        If mentions aren't allowed, also return the type of mention(s) disallowed.
-        """
-        if await has_no_roles_check(ctx, *STAFF_PARTNERS_COMMUNITY_ROLES):
-            return False, "members/roles"
-        elif await has_no_roles_check(ctx, *MODERATION_ROLES):
-            return all(isinstance(mention, (discord.User, discord.Member)) for mention in mentions), "roles"
-        else:
-            return True, ""
-
-    @staticmethod
-    async def validate_mentions(ctx: Context, mentions: t.Iterable[Mentionable]) -> bool:
-        """
-        Filter mentions to see if the user can mention, and sends a denial if not allowed.
-
-        Returns whether or not the validation is successful.
-        """
-        mentions_allowed, disallowed_mentions = await Reminders._check_mentions(ctx, mentions)
-
-        if not mentions or mentions_allowed:
-            return True
-        else:
-            await send_denial(ctx, f"You can't mention other {disallowed_mentions} in your reminder!")
-            return False
-
-    async def get_mentionables(self, mention_ids: t.List[int]) -> t.Iterator[Mentionable]:
-        """Converts Role and Member ids to their corresponding objects if possible."""
-        guild = self.bot.get_guild(Guild.id)
-        for mention_id in mention_ids:
-            member = await get_or_fetch_member(guild, mention_id)
-            if mentionable := (member or guild.get_role(mention_id)):
-                yield mentionable
-
-    def schedule_reminder(self, reminder: dict) -> None:
-        """A coroutine which sends the reminder once the time is reached, and cancels the running task."""
-        reminder_datetime = isoparse(reminder['expiration'])
-        self.scheduler.schedule_at(reminder_datetime, reminder["id"], self.send_reminder(reminder))
-
-    async def _edit_reminder(self, reminder_id: int, payload: dict) -> dict:
-        """
-        Edits a reminder in the database given the ID and payload.
-
-        Returns the edited reminder.
-        """
-        # Send the request to update the reminder in the database
-        reminder = await self.bot.api_client.patch(
-            'bot/reminders/' + str(reminder_id),
-            json=payload
-        )
-        return reminder
-
-    async def _reschedule_reminder(self, reminder: dict) -> None:
-        """Reschedule a reminder object."""
-        log.trace(f"Cancelling old task #{reminder['id']}")
-        self.scheduler.cancel(reminder["id"])
-
-        log.trace(f"Scheduling new task #{reminder['id']}")
-        self.schedule_reminder(reminder)
-
-    @lock_arg(LOCK_NAMESPACE, "reminder", itemgetter("id"), raise_error=True)
-    async def send_reminder(self, reminder: dict, expected_time: t.Optional[time.Timestamp] = None) -> None:
-        """Send the reminder."""
-        is_valid, user, channel = self.ensure_valid_reminder(reminder)
-        if not is_valid:
-            # No need to cancel the task too; it'll simply be done once this coroutine returns.
-            return
-        embed = discord.Embed()
-        if expected_time:
-            embed.colour = discord.Colour.red()
-            embed.set_author(
-                icon_url=Icons.remind_red,
-                name="Sorry, your reminder should have arrived earlier!"
-            )
-        else:
-            embed.colour = discord.Colour.og_blurple()
-            embed.set_author(
-                icon_url=Icons.remind_blurple,
-                name="It has arrived!"
-            )
-
-        # Let's not use a codeblock to keep emojis and mentions working. Embeds are safe anyway.
-        embed.description = f"Here's your reminder: {reminder['content']}"
-
-        # Here the jump URL is in the format of base_url/guild_id/channel_id/message_id
-        additional_mentions = ' '.join([
-            mentionable.mention async for mentionable in self.get_mentionables(reminder["mentions"])
-        ])
-
-        jump_url = reminder.get("jump_url")
-        embed.description += f"\n[Jump back to when you created the reminder]({jump_url})"
-        partial_message = channel.get_partial_message(int(jump_url.split("/")[-1]))
-        try:
-            await partial_message.reply(content=f"{additional_mentions}", embed=embed)
-        except discord.HTTPException as e:
-            log.info(
-                f"There was an error when trying to reply to a reminder invocation message, {e}, "
-                "fall back to using jump_url"
-            )
-            await channel.send(content=f"{user.mention} {additional_mentions}", embed=embed)
-
-        log.debug(f"Deleting reminder #{reminder['id']} (the user has been reminded).")
-        await self.bot.api_client.delete(f"bot/reminders/{reminder['id']}")
-
-    @group(name="remind", aliases=("reminder", "reminders", "remindme"), invoke_without_command=True)
-    async def remind_group(
-        self, ctx: Context, mentions: Greedy[ReminderMention], expiration: Duration, *, content: t.Optional[str] = None
-    ) -> None:
-        """
-        Commands for managing your reminders.
-
-        The `expiration` duration of `!remind new` supports the following symbols for each unit of time:
-        - years: `Y`, `y`, `year`, `years`
-        - months: `m`, `month`, `months`
-        - weeks: `w`, `W`, `week`, `weeks`
-        - days: `d`, `D`, `day`, `days`
-        - hours: `H`, `h`, `hour`, `hours`
-        - minutes: `M`, `minute`, `minutes`
-        - seconds: `S`, `s`, `second`, `seconds`
-
-        For example, to set a reminder that expires in 3 days and 1 minute, you can do `!remind new 3d1M Do something`.
-        """
-        await self.new_reminder(ctx, mentions=mentions, expiration=expiration, content=content)
-
-    @remind_group.command(name="new", aliases=("add", "create"))
-    async def new_reminder(
-        self, ctx: Context, mentions: Greedy[ReminderMention], expiration: Duration, *, content: t.Optional[str] = None
-    ) -> None:
-        """
-        Set yourself a simple reminder.
-
-        The `expiration` duration supports the following symbols for each unit of time:
-        - years: `Y`, `y`, `year`, `years`
-        - months: `m`, `month`, `months`
-        - weeks: `w`, `W`, `week`, `weeks`
-        - days: `d`, `D`, `day`, `days`
-        - hours: `H`, `h`, `hour`, `hours`
-        - minutes: `M`, `minute`, `minutes`
-        - seconds: `S`, `s`, `second`, `seconds`
-
-        For example, to set a reminder that expires in 3 days and 1 minute, you can do `!remind new 3d1M Do something`.
-        """
-        # If the user is not staff, partner or part of the python community,
-        # we need to verify whether or not to make a reminder at all.
-        if await has_no_roles_check(ctx, *STAFF_PARTNERS_COMMUNITY_ROLES):
-
-            # If they don't have permission to set a reminder in this channel
-            if ctx.channel.id not in WHITELISTED_CHANNELS:
-                await send_denial(ctx, "Sorry, you can't do that here!")
-                return
-
-            # Get their current active reminders
-            active_reminders = await self.bot.api_client.get(
-                'bot/reminders',
-                params={
-                    'author__id': str(ctx.author.id)
-                }
-            )
-
-            # Let's limit this, so we don't get 10 000
-            # reminders from kip or something like that :P
-            if len(active_reminders) > MAXIMUM_REMINDERS:
-                await send_denial(ctx, "You have too many active reminders!")
-                return
-
-        # Remove duplicate mentions
-        mentions = set(mentions)
-        mentions.discard(ctx.author)
-
-        # Filter mentions to see if the user can mention members/roles
-        if not await self.validate_mentions(ctx, mentions):
-            return
-
-        mention_ids = [mention.id for mention in mentions]
-
-        # If `content` isn't provided then we try to get message content of a replied message
-        if not content:
-            if reference := ctx.message.reference:
-                if isinstance((resolved_message := reference.resolved), discord.Message):
-                    content = resolved_message.content
-            # If we weren't able to get the content of a replied message
-            if content is None:
-                await send_denial(ctx, "Your reminder must have a content and/or reply to a message.")
-                return
-
-            # If the replied message has no content (e.g. only attachments/embeds)
-            if content == "":
-                content = "See referenced message."
-
-        # Now we can attempt to actually set the reminder.
-        reminder = await self.bot.api_client.post(
-            'bot/reminders',
-            json={
-                'author': ctx.author.id,
-                'channel_id': ctx.message.channel.id,
-                'jump_url': ctx.message.jump_url,
-                'content': content,
-                'expiration': expiration.isoformat(),
-                'mentions': mention_ids,
-            }
-        )
-
-        formatted_time = time.discord_timestamp(expiration, time.TimestampFormats.DAY_TIME)
-        mention_string = f"Your reminder will arrive on {formatted_time}"
-
-        if mentions:
-            mention_string += f" and will mention {len(mentions)} other(s)"
-        mention_string += "!"
-
-        # Confirm to the user that it worked.
-        await self._send_confirmation(
-            ctx,
-            on_success=mention_string,
-            reminder_id=reminder["id"]
-        )
-
-        self.schedule_reminder(reminder)
-
-    @remind_group.command(name="list")
-    async def list_reminders(self, ctx: Context) -> None:
-        """View a paginated embed of all reminders for your user."""
-        # Get all the user's reminders from the database.
-        data = await self.bot.api_client.get(
-            'bot/reminders',
-            params={'author__id': str(ctx.author.id)}
-        )
-
-        # Make a list of tuples so it can be sorted by time.
-        reminders = sorted(
-            (
-                (rem['content'], rem['expiration'], rem['id'], rem['mentions'])
-                for rem in data
-            ),
-            key=itemgetter(1)
-        )
-
-        lines = []
-
-        for content, remind_at, id_, mentions in reminders:
-            # Parse and humanize the time, make it pretty :D
-            expiry = time.format_relative(remind_at)
-
-            mentions = ", ".join([
-                # Both Role and User objects have the `name` attribute
-                mention.name async for mention in self.get_mentionables(mentions)
-            ])
-            mention_string = f"\n**Mentions:** {mentions}" if mentions else ""
-
-            text = textwrap.dedent(f"""
-            **Reminder #{id_}:** *expires {expiry}* (ID: {id_}){mention_string}
-            {content}
-            """).strip()
-
-            lines.append(text)
-
-        embed = discord.Embed()
-        embed.colour = discord.Colour.og_blurple()
-        embed.title = f"Reminders for {ctx.author}"
-
-        # Remind the user that they have no reminders :^)
-        if not lines:
-            embed.description = "No active reminders could be found."
-            await ctx.send(embed=embed)
-            return
-
-        # Construct the embed and paginate it.
-        embed.colour = discord.Colour.og_blurple()
-
-        await LinePaginator.paginate(
-            lines,
-            ctx, embed,
-            max_lines=3,
-            empty=True
-        )
-
-    @remind_group.group(name="edit", aliases=("change", "modify"), invoke_without_command=True)
-    async def edit_reminder_group(self, ctx: Context) -> None:
-        """
-        Commands for modifying your current reminders.
-
-        The `expiration` duration supports the following symbols for each unit of time:
-        - years: `Y`, `y`, `year`, `years`
-        - months: `m`, `month`, `months`
-        - weeks: `w`, `W`, `week`, `weeks`
-        - days: `d`, `D`, `day`, `days`
-        - hours: `H`, `h`, `hour`, `hours`
-        - minutes: `M`, `minute`, `minutes`
-        - seconds: `S`, `s`, `second`, `seconds`
-
-        For example, to edit a reminder to expire in 3 days and 1 minute, you can do `!remind edit duration 1234 3d1M`.
-        """
-        await ctx.send_help(ctx.command)
-
-    @edit_reminder_group.command(name="duration", aliases=("time",))
-    async def edit_reminder_duration(self, ctx: Context, id_: int, expiration: Duration) -> None:
-        """
-        Edit one of your reminder's expiration.
-
-        The `expiration` duration supports the following symbols for each unit of time:
-        - years: `Y`, `y`, `year`, `years`
-        - months: `m`, `month`, `months`
-        - weeks: `w`, `W`, `week`, `weeks`
-        - days: `d`, `D`, `day`, `days`
-        - hours: `H`, `h`, `hour`, `hours`
-        - minutes: `M`, `minute`, `minutes`
-        - seconds: `S`, `s`, `second`, `seconds`
-
-        For example, to edit a reminder to expire in 3 days and 1 minute, you can do `!remind edit duration 1234 3d1M`.
-        """
-        await self.edit_reminder(ctx, id_, {'expiration': expiration.isoformat()})
-
-    @edit_reminder_group.command(name="content", aliases=("reason",))
-    async def edit_reminder_content(self, ctx: Context, id_: int, *, content: str) -> None:
-        """Edit one of your reminder's content."""
-        await self.edit_reminder(ctx, id_, {"content": content})
-
-    @edit_reminder_group.command(name="mentions", aliases=("pings",))
-    async def edit_reminder_mentions(self, ctx: Context, id_: int, mentions: Greedy[ReminderMention]) -> None:
-        """Edit one of your reminder's mentions."""
-        # Remove duplicate mentions
-        mentions = set(mentions)
-        mentions.discard(ctx.author)
-
-        # Filter mentions to see if the user can mention members/roles
-        if not await self.validate_mentions(ctx, mentions):
-            return
-
-        mention_ids = [mention.id for mention in mentions]
-        await self.edit_reminder(ctx, id_, {"mentions": mention_ids})
-
-    @lock_arg(LOCK_NAMESPACE, "id_", raise_error=True)
-    async def edit_reminder(self, ctx: Context, id_: int, payload: dict) -> None:
-        """Edits a reminder with the given payload, then sends a confirmation message."""
-        if not await self._can_modify(ctx, id_):
-            return
-        reminder = await self._edit_reminder(id_, payload)
-
-        # Send a confirmation message to the channel
-        await self._send_confirmation(
-            ctx,
-            on_success="That reminder has been edited successfully!",
-            reminder_id=id_,
-        )
-        await self._reschedule_reminder(reminder)
-
-    @remind_group.command("delete", aliases=("remove", "cancel"))
-    @lock_arg(LOCK_NAMESPACE, "id_", raise_error=True)
-    async def delete_reminder(self, ctx: Context, id_: int) -> None:
-        """Delete one of your active reminders."""
-        if not await self._can_modify(ctx, id_):
-            return
-
-        await self.bot.api_client.delete(f"bot/reminders/{id_}")
-        self.scheduler.cancel(id_)
-
-        await self._send_confirmation(
-            ctx,
-            on_success="That reminder has been deleted successfully!",
-            reminder_id=id_
-        )
-
-    async def _can_modify(self, ctx: Context, reminder_id: t.Union[str, int]) -> bool:
-        """
-        Check whether the reminder can be modified by the ctx author.
-
-        The check passes when the user is an admin, or if they created the reminder.
-        """
-        if await has_any_role_check(ctx, Roles.admins):
-            return True
-
-        api_response = await self.bot.api_client.get(f"bot/reminders/{reminder_id}")
-        if not api_response["author"] == ctx.author.id:
-            log.debug(f"{ctx.author} is not the reminder author and does not pass the check.")
-            await send_denial(ctx, "You can't modify reminders of other users!")
-            return False
-
-        log.debug(f"{ctx.author} is the reminder author and passes the check.")
-        return True
-
-
-def setup(bot: Bot) -> None:
-    """Load the Reminders cog."""
-    bot.add_cog(Reminders(bot))
-- 
cgit v1.2.3


From 1296914615c72d597be1b0c4d00bfa84011c960c Mon Sep 17 00:00:00 2001
From: ChrisJL <ChrisLovering@users.noreply.github.com>
Date: Sun, 13 Feb 2022 15:07:11 +0000
Subject: Add unsubscribe alias to subscribe command

In quite a few places, such as #roles, we tell users to run the unsubscribe command to remove roles from them. However, this command no longer exists due to the rework of the subscribe command.

Since the subscribe commands allows tyou to remove as well as add roles, I have added this as an alias.
---
 bot/exts/info/subscribe.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/info/subscribe.py b/bot/exts/info/subscribe.py
index 1299d5d59..eff0c13b8 100644
--- a/bot/exts/info/subscribe.py
+++ b/bot/exts/info/subscribe.py
@@ -171,7 +171,7 @@ class Subscribe(commands.Cog):
         self.assignable_roles.sort(key=operator.methodcaller("is_currently_available"), reverse=True)
 
     @commands.cooldown(1, 10, commands.BucketType.member)
-    @commands.command(name="subscribe")
+    @commands.command(name="subscribe", aliases=("unsubscribe",))
     @redirect_output(
         destination_channel=constants.Channels.bot_commands,
         bypass_roles=constants.STAFF_PARTNERS_COMMUNITY_ROLES,
-- 
cgit v1.2.3


From 036fa718a64009ee37c6c8d0693ab9490ded3475 Mon Sep 17 00:00:00 2001
From: Steele Farnsworth <swfarnsworth@gmail.com>
Date: Sun, 13 Feb 2022 14:53:30 -0500
Subject: Traceback tag: Emphasize reason for sharing traceback (#2072)

---
 bot/resources/tags/traceback.md | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/bot/resources/tags/traceback.md b/bot/resources/tags/traceback.md
index 321737aac..a4fa8aba9 100644
--- a/bot/resources/tags/traceback.md
+++ b/bot/resources/tags/traceback.md
@@ -1,18 +1,16 @@
 Please provide the full traceback for your exception in order to help us identify your issue.
+While the last line of the error message tells us what kind of error you got,
+the full traceback will tell us which line, and other critical information to solve your problem.
+Please avoid screenshots so we can copy and paste parts of the message.
 
 A full traceback could look like:
 ```py
 Traceback (most recent call last):
-    File "tiny", line 3, in
-        do_something()
-    File "tiny", line 2, in do_something
-        a = 6 / b
-ZeroDivisionError: division by zero
+  File "my_file.py", line 5, in <module>
+    add_three("6")
+  File "my_file.py", line 2, in add_three
+    a = num + 3
+TypeError: can only concatenate str (not "int") to str
 ```
-The best way to read your traceback is bottom to top.
 
-• Identify the exception raised (in this case `ZeroDivisionError`)  
-• Make note of the line number (in this case `2`), and navigate there in your program.  
-• Try to understand why the error occurred (in this case because `b` is `0`).
-
-To read more about exceptions and errors, please refer to the [PyDis Wiki](https://pythondiscord.com/pages/guides/pydis-guides/asking-good-questions/#examining-tracebacks) or the [official Python tutorial](https://docs.python.org/3.7/tutorial/errors.html).
+If the traceback is long, use [our pastebin](https://paste.pythondiscord.com/).
-- 
cgit v1.2.3


From 6cdbd56005f3795bcc9bc993c96f640b4e678a1d Mon Sep 17 00:00:00 2001
From: Xithrius <15021300+Xithrius@users.noreply.github.com>
Date: Sun, 13 Feb 2022 12:42:07 -0800
Subject: Removed extra newline in the traceback tag. (#2083)

---
 bot/resources/tags/traceback.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/bot/resources/tags/traceback.md b/bot/resources/tags/traceback.md
index a4fa8aba9..e21fa6c6e 100644
--- a/bot/resources/tags/traceback.md
+++ b/bot/resources/tags/traceback.md
@@ -12,5 +12,4 @@ Traceback (most recent call last):
     a = num + 3
 TypeError: can only concatenate str (not "int") to str
 ```
-
 If the traceback is long, use [our pastebin](https://paste.pythondiscord.com/).
-- 
cgit v1.2.3


From d10b7d2c56d3530b69bf96c02e55ed0248a3f026 Mon Sep 17 00:00:00 2001
From: TizzySaurus <47674925+TizzySaurus@users.noreply.github.com>
Date: Mon, 14 Feb 2022 16:17:03 +0000
Subject: Fix ignoring of raw DM edits (#2085)

---
 bot/exts/moderation/modlog.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bot/exts/moderation/modlog.py b/bot/exts/moderation/modlog.py
index 2c01a4a21..54a08738c 100644
--- a/bot/exts/moderation/modlog.py
+++ b/bot/exts/moderation/modlog.py
@@ -729,6 +729,9 @@ class ModLog(Cog, name="ModLog"):
     @Cog.listener()
     async def on_raw_message_edit(self, event: discord.RawMessageUpdateEvent) -> None:
         """Log raw message edit event to message change log."""
+        if event.guild_id is None:
+            return  # ignore DM edits
+
         await self.bot.wait_until_guild_available()
         try:
             channel = self.bot.get_channel(int(event.data["channel_id"]))
-- 
cgit v1.2.3