From db5cf7d18d6992165abc15cd27ed50a4713af124 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 24 Sep 2020 16:26:29 +0800
Subject: Add append subcommand for infraction group

---
 bot/exts/moderation/infraction/management.py | 50 ++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index de4fb4175..4e31947d4 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -45,6 +45,56 @@ class ModManagement(commands.Cog):
         """Infraction manipulation commands."""
         await ctx.send_help(ctx.command)
 
+    @infraction_group.command(name="append", aliases=("amend", "add"))
+    async def infraction_append(
+        self,
+        ctx: Context,
+        infraction_id: t.Union[int, allowed_strings("l", "last", "recent")],  # noqa: F821
+        duration: t.Union[Expiry, allowed_strings("p", "permanent"), None],   # noqa: F821
+        *,
+        reason: str = None
+    ) -> None:
+        """
+        Append text and/or edit the duration of an infraction.
+
+        Durations are relative to the time of updating and should be appended with a unit of time.
+        Units (∗case-sensitive):
+        \u2003`y` - years
+        \u2003`m` - months∗
+        \u2003`w` - weeks
+        \u2003`d` - days
+        \u2003`h` - hours
+        \u2003`M` - minutes∗
+        \u2003`s` - seconds
+
+        Use "l", "last", or "recent" as the infraction ID to specify that the most recent infraction
+        authored by the command invoker should be edited.
+
+        Use "p" or "permanent" to mark the infraction as permanent. Alternatively, an ISO 8601
+        timestamp can be provided for the duration.
+        """
+        if isinstance(infraction_id, str):
+            params = {
+                "actor__id": ctx.author.id,
+                "ordering": "-inserted_at"
+            }
+            infractions = await self.bot.api_client.get("bot/infractions", params=params)
+
+            if infractions:
+                old_infraction = infractions[0]
+                infraction_id = old_infraction["id"]
+            else:
+                await ctx.send(
+                    ":x: Couldn't find most recent infraction; you have never given an infraction."
+                )
+                return
+        else:
+            old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
+
+        reason = f"{old_infraction['reason']} **Edit:** {reason}"
+
+        await ctx.invoke(self.infraction_edit, infraction_id=infraction_id, duration=duration, reason=reason)
+
     @infraction_group.command(name='edit')
     async def infraction_edit(
         self,
-- 
cgit v1.2.3


From f9971be6251dc083332c2adc4bffb746f2c8ccf2 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 24 Sep 2020 17:05:22 +0800
Subject: Add get_latest_infraction utility function

---
 bot/exts/moderation/infraction/management.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 4e31947d4..7596d2ec1 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -338,6 +338,20 @@ class ModManagement(commands.Cog):
 
         return lines.strip()
 
+    async def get_latest_infraction(self, actor: int) -> t.Optional[dict]:
+        """Obtains the latest infraction from an actor."""
+        params = {
+            "actor__id": actor,
+            "ordering": "-inserted_at"
+        }
+
+        infractions = await self.bot.api_client.get("bot/infractions", params=params)
+
+        if infractions:
+            return infractions[0]
+
+        return None
+
     # endregion
 
     # This cannot be static (must have a __func__ attribute).
-- 
cgit v1.2.3


From 1ab0084581859a0d8e938b9292bdb86ce9caf523 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 24 Sep 2020 17:11:21 +0800
Subject: Refactor routine for obtaining latest infraction

---
 bot/exts/moderation/infraction/management.py | 36 +++++++++++-----------------
 1 file changed, 14 insertions(+), 22 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 7596d2ec1..b841b11c3 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -74,20 +74,16 @@ class ModManagement(commands.Cog):
         timestamp can be provided for the duration.
         """
         if isinstance(infraction_id, str):
-            params = {
-                "actor__id": ctx.author.id,
-                "ordering": "-inserted_at"
-            }
-            infractions = await self.bot.api_client.get("bot/infractions", params=params)
-
-            if infractions:
-                old_infraction = infractions[0]
-                infraction_id = old_infraction["id"]
-            else:
-                await ctx.send(
+            old_infraction = await self.get_latest_infraction(ctx.author.id)
+
+            if old_infraction is None:
+                ctx.send(
                     ":x: Couldn't find most recent infraction; you have never given an infraction."
                 )
                 return
+
+            infraction_id = old_infraction["id"]
+
         else:
             old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
 
@@ -129,20 +125,16 @@ class ModManagement(commands.Cog):
 
         # Retrieve the previous infraction for its information.
         if isinstance(infraction_id, str):
-            params = {
-                "actor__id": ctx.author.id,
-                "ordering": "-inserted_at"
-            }
-            infractions = await self.bot.api_client.get("bot/infractions", params=params)
-
-            if infractions:
-                old_infraction = infractions[0]
-                infraction_id = old_infraction["id"]
-            else:
-                await ctx.send(
+            old_infraction = await self.get_latest_infraction(ctx.author.id)
+
+            if old_infraction is None:
+                ctx.send(
                     ":x: Couldn't find most recent infraction; you have never given an infraction."
                 )
                 return
+
+            infraction_id = old_infraction["id"]
+
         else:
             old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
 
-- 
cgit v1.2.3


From 4ce59c673c035550ba4f2e55e79faba17002d40c Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 24 Sep 2020 17:46:10 +0800
Subject: Fix unawaited coroutine

---
 bot/exts/moderation/infraction/management.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index b841b11c3..e35ebcbef 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -77,7 +77,7 @@ class ModManagement(commands.Cog):
             old_infraction = await self.get_latest_infraction(ctx.author.id)
 
             if old_infraction is None:
-                ctx.send(
+                await ctx.send(
                     ":x: Couldn't find most recent infraction; you have never given an infraction."
                 )
                 return
@@ -128,7 +128,7 @@ class ModManagement(commands.Cog):
             old_infraction = await self.get_latest_infraction(ctx.author.id)
 
             if old_infraction is None:
-                ctx.send(
+                await ctx.send(
                     ":x: Couldn't find most recent infraction; you have never given an infraction."
                 )
                 return
-- 
cgit v1.2.3


From abbb62a0720f68cbd0a0226f4abeb9c3b337de3c Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 24 Sep 2020 17:47:50 +0800
Subject: Add "a" alias for append

---
 bot/exts/moderation/infraction/management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index e35ebcbef..78dc16b23 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -45,7 +45,7 @@ class ModManagement(commands.Cog):
         """Infraction manipulation commands."""
         await ctx.send_help(ctx.command)
 
-    @infraction_group.command(name="append", aliases=("amend", "add"))
+    @infraction_group.command(name="append", aliases=("amend", "add", "a"))
     async def infraction_append(
         self,
         ctx: Context,
-- 
cgit v1.2.3


From 1dd93784d09baf73a670621f22b96c24ffb6c762 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 24 Sep 2020 17:55:03 +0800
Subject: Add visual buffer for appended reason

---
 bot/exts/moderation/infraction/management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 78dc16b23..ba1485978 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -87,7 +87,7 @@ class ModManagement(commands.Cog):
         else:
             old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
 
-        reason = f"{old_infraction['reason']} **Edit:** {reason}"
+        reason = f"{old_infraction['reason']} || **Edit:** {reason}"
 
         await ctx.invoke(self.infraction_edit, infraction_id=infraction_id, duration=duration, reason=reason)
 
-- 
cgit v1.2.3


From b65c64575f12ddee57bd6bf9bfaffafe6131890a Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 24 Sep 2020 18:59:50 +0800
Subject: Make vertical bar separators escaped

---
 bot/exts/moderation/infraction/management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index ba1485978..bdb0e8ffa 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -87,7 +87,7 @@ class ModManagement(commands.Cog):
         else:
             old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
 
-        reason = f"{old_infraction['reason']} || **Edit:** {reason}"
+        reason = fr"{old_infraction['reason']} \|\| **Edit:** {reason}"
 
         await ctx.invoke(self.infraction_edit, infraction_id=infraction_id, duration=duration, reason=reason)
 
-- 
cgit v1.2.3


From 84671acaeb251939722a9b93f217b6256637a998 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sun, 27 Sep 2020 13:30:32 +0800
Subject: Remove prefix when appending a reason

---
 bot/exts/moderation/infraction/management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index bdb0e8ffa..6b3e701c7 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -87,7 +87,7 @@ class ModManagement(commands.Cog):
         else:
             old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
 
-        reason = fr"{old_infraction['reason']} \|\| **Edit:** {reason}"
+        reason = fr"{old_infraction['reason']} \|\| {reason}"
 
         await ctx.invoke(self.infraction_edit, infraction_id=infraction_id, duration=duration, reason=reason)
 
-- 
cgit v1.2.3


From e18893760b115600b7b03a60ce5bfb80e59fb882 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Thu, 1 Oct 2020 04:01:58 +0800
Subject: Add bold styling for vertical bar separators

---
 bot/exts/moderation/infraction/management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 6b3e701c7..1cdcf6568 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -87,7 +87,7 @@ class ModManagement(commands.Cog):
         else:
             old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
 
-        reason = fr"{old_infraction['reason']} \|\| {reason}"
+        reason = fr"{old_infraction['reason']} **\|\|** {reason}"
 
         await ctx.invoke(self.infraction_edit, infraction_id=infraction_id, duration=duration, reason=reason)
 
-- 
cgit v1.2.3


From 7d9cb7a7d7b42d1abb9cf42e8066994c9f979eb9 Mon Sep 17 00:00:00 2001
From: kosayoda <kieransiek@protonmail.com>
Date: Thu, 1 Oct 2020 16:48:47 +0800
Subject: Modify `!superstar` to use `apply_infraction`.

Using `apply_infraction` from `InfractionScheduler` rather than doing it
manually allows us to handle HTTP errors while reducing code
duplication.

Specifically, discord.Forbidden is handled when the bot tries to
superstar someone they do not have permissions to.

Resolves BOT-5Q.
---
 bot/exts/moderation/infraction/_scheduler.py   | 24 ++++++--
 bot/exts/moderation/infraction/superstarify.py | 77 +++++++++++---------------
 2 files changed, 52 insertions(+), 49 deletions(-)

diff --git a/bot/exts/moderation/infraction/_scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index 814b17830..b66fdc850 100644
--- a/bot/exts/moderation/infraction/_scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -81,15 +81,29 @@ class InfractionScheduler:
         ctx: Context,
         infraction: _utils.Infraction,
         user: UserSnowflake,
-        action_coro: t.Optional[t.Awaitable] = None
-    ) -> None:
-        """Apply an infraction to the user, log the infraction, and optionally notify the user."""
+        action_coro: t.Optional[t.Awaitable] = None,
+        reason_override: t.Optional[str] = None,
+        additional_info: t.Optional[str] = None,
+    ) -> bool:
+        """
+        Apply an infraction to the user, log the infraction, and optionally notify the user.
+
+        `reason_override`, if provided, will be sent to the user in place of the infraction reason.
+        `additional_info` will be attached to the text field in the mod-log embed.
+        Returns whether or not the infraction succeeded.
+        """
         infr_type = infraction["type"]
         icon = _utils.INFRACTION_ICONS[infr_type][0]
         reason = infraction["reason"]
         expiry = time.format_infraction_with_duration(infraction["expires_at"])
         id_ = infraction['id']
 
+        if reason_override is not None:
+            reason_override = reason
+
+        if additional_info is not None:
+            additional_info = ""
+
         log.trace(f"Applying {infr_type} infraction #{id_} to {user}.")
 
         # Default values for the confirmation message and mod log.
@@ -125,7 +139,7 @@ class InfractionScheduler:
                 log.error(f"Failed to DM {user.id}: could not fetch user (status {e.status})")
             else:
                 # Accordingly display whether the user was successfully notified via DM.
-                if await _utils.notify_infraction(user, infr_type, expiry, reason, icon):
+                if await _utils.notify_infraction(user, infr_type, expiry, reason_override, icon):
                     dm_result = ":incoming_envelope: "
                     dm_log_text = "\nDM: Sent"
 
@@ -201,12 +215,14 @@ class InfractionScheduler:
                 Member: {messages.format_user(user)}
                 Actor: {ctx.author.mention}{dm_log_text}{expiry_log_text}
                 Reason: {reason}
+                {additional_info}
             """),
             content=log_content,
             footer=f"ID {infraction['id']}"
         )
 
         log.info(f"Applied {infr_type} infraction #{id_} to {user}.")
+        return not failed
 
     async def pardon_infraction(
             self,
diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index eec63f5b3..3c96f7317 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -5,7 +5,7 @@ import textwrap
 import typing as t
 from pathlib import Path
 
-from discord import Colour, Embed, Member
+from discord import Embed, Member
 from discord.ext.commands import Cog, Context, command, has_any_role
 from discord.utils import escape_markdown
 
@@ -142,57 +142,44 @@ class Superstarify(InfractionScheduler, Cog):
         forced_nick = self.get_nick(id_, member.id)
         expiry_str = format_infraction(infraction["expires_at"])
 
-        # Apply the infraction and schedule the expiration task.
-        log.debug(f"Changing nickname of {member} to {forced_nick}.")
-        self.mod_log.ignore(constants.Event.member_update, member.id)
-        await member.edit(nick=forced_nick, reason=reason)
-        self.schedule_expiration(infraction)
+        # Apply the infraction
+        async def action() -> None:
+            log.debug(f"Changing nickname of {member} to {forced_nick}.")
+            self.mod_log.ignore(constants.Event.member_update, member.id)
+            await member.edit(nick=forced_nick, reason=reason)
 
         old_nick = escape_markdown(member.display_name)
         forced_nick = escape_markdown(forced_nick)
 
-        # Send a DM to the user to notify them of their new infraction.
-        await _utils.notify_infraction(
-            user=member,
-            infr_type="Superstarify",
-            expires_at=expiry_str,
-            icon_url=_utils.INFRACTION_ICONS["superstar"][0],
-            reason=f"Your nickname didn't comply with our [nickname policy]({NICKNAME_POLICY_URL})."
+        superstar_reason = f"Your nickname didn't comply with our [nickname policy]({NICKNAME_POLICY_URL})."
+        nickname_info = textwrap.dedent(f"""
+            Old nickname: `{old_nick}`
+            New nickname: `{forced_nick}`
+        """).strip()
+
+        successful = await self.apply_infraction(
+            ctx, infraction, member, action(),
+            reason_override=superstar_reason,
+            additional_info=nickname_info
         )
 
-        # Send an embed with the infraction information to the invoking context.
-        log.trace(f"Sending superstar #{id_} embed.")
-        embed = Embed(
-            title="Congratulations!",
-            colour=constants.Colours.soft_orange,
-            description=(
-                f"Your previous nickname, **{old_nick}**, "
-                f"was so bad that we have decided to change it. "
-                f"Your new nickname will be **{forced_nick}**.\n\n"
-                f"You will be unable to change your nickname until **{expiry_str}**.\n\n"
-                "If you're confused by this, please read our "
-                f"[official nickname policy]({NICKNAME_POLICY_URL})."
+        # Send an embed with the infraction information to the invoking context if
+        # superstar was successful.
+        if successful:
+            log.trace(f"Sending superstar #{id_} embed.")
+            embed = Embed(
+                title="Congratulations!",
+                colour=constants.Colours.soft_orange,
+                description=(
+                    f"Your previous nickname, **{old_nick}**, "
+                    f"was so bad that we have decided to change it. "
+                    f"Your new nickname will be **{forced_nick}**.\n\n"
+                    f"You will be unable to change your nickname until **{expiry_str}**.\n\n"
+                    "If you're confused by this, please read our "
+                    f"[official nickname policy]({NICKNAME_POLICY_URL})."
+                )
             )
-        )
-        await ctx.send(embed=embed)
-
-        # Log to the mod log channel.
-        log.trace(f"Sending apply mod log for superstar #{id_}.")
-        await self.mod_log.send_log_message(
-            icon_url=_utils.INFRACTION_ICONS["superstar"][0],
-            colour=Colour.gold(),
-            title="Member achieved superstardom",
-            thumbnail=member.avatar_url_as(static_format="png"),
-            text=textwrap.dedent(f"""
-                Member: {member.mention}
-                Actor: {ctx.message.author.mention}
-                Expires: {expiry_str}
-                Old nickname: `{old_nick}`
-                New nickname: `{forced_nick}`
-                Reason: {reason}
-            """),
-            footer=f"ID {id_}"
-        )
+            await ctx.send(embed=embed)
 
     @command(name="unsuperstarify", aliases=("release_nick", "unstar"))
     async def unsuperstarify(self, ctx: Context, member: Member) -> None:
-- 
cgit v1.2.3


From c1b46ecc916970ec95e267f017958d30e4773c2a Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sat, 3 Oct 2020 12:52:24 +0800
Subject: Invoke infraction_edit directly with method call

---
 bot/exts/moderation/infraction/management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 1cdcf6568..2cb9bce8b 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -89,7 +89,7 @@ class ModManagement(commands.Cog):
 
         reason = fr"{old_infraction['reason']} **\|\|** {reason}"
 
-        await ctx.invoke(self.infraction_edit, infraction_id=infraction_id, duration=duration, reason=reason)
+        await self.infraction_edit(infraction_id=infraction_id, duration=duration, reason=reason)
 
     @infraction_group.command(name='edit')
     async def infraction_edit(
-- 
cgit v1.2.3


From 2de1a6a4091234703d99a26ad2884b586d7204f4 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sat, 3 Oct 2020 15:42:23 +0800
Subject: Add Infraction converter

This adds the Infraction converter to be used in infraction_edit and
infraction_append.
---
 bot/converters.py | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/bot/converters.py b/bot/converters.py
index 2e118d476..962416238 100644
--- a/bot/converters.py
+++ b/bot/converters.py
@@ -549,6 +549,36 @@ def _snowflake_from_regex(pattern: t.Pattern, arg: str) -> int:
     return int(match.group(1))
 
 
+class Infraction(Converter):
+    """
+    Attempts to convert a given infraction ID into an infraction.
+
+    Alternatively, `l`, `last`, or `recent` can be passed in order to
+    obtain the most recent infraction by the actor.
+    """
+
+    async def convert(self, ctx: Context, arg: str) -> t.Optional[dict]:
+        """Attempts to convert `arg` into an infraction `dict`."""
+        if arg in ("l", "last", "recent"):
+            params = {
+                "actor__id": ctx.author.id,
+                "ordering": "-inserted_at"
+            }
+
+            infractions = await ctx.bot.api_client.get("bot/infractions", params=params)
+
+            if not infractions:
+                await ctx.send(
+                    ":x: Couldn't find most recent infraction; you have never given an infraction."
+                )
+                return None
+
+            return infractions[0]
+
+        else:
+            return ctx.bot.api_client.get(f"bot/infractions/{arg}")
+
+
 Expiry = t.Union[Duration, ISODateTime]
 FetchedMember = t.Union[discord.Member, FetchedUser]
 UserMention = partial(_snowflake_from_regex, RE_USER_MENTION)
-- 
cgit v1.2.3


From 1ae9b15d7718d7e2f96b4406de99b89f1778b971 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sat, 3 Oct 2020 15:43:51 +0800
Subject: Refactor infraction_edit and infraction_append

This refactors the infraction_edit and infraction_append commands to
utilize the Infraction converter.
---
 bot/exts/moderation/infraction/management.py | 47 +++++++++-------------------
 1 file changed, 15 insertions(+), 32 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 2cb9bce8b..8aeb45f96 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -10,7 +10,7 @@ from discord.utils import escape_markdown
 
 from bot import constants
 from bot.bot import Bot
-from bot.converters import Expiry, Snowflake, UserMention, allowed_strings, proxy_user
+from bot.converters import Expiry, Infraction, Snowflake, UserMention, allowed_strings, proxy_user
 from bot.exts.moderation.infraction.infractions import Infractions
 from bot.exts.moderation.modlog import ModLog
 from bot.pagination import LinePaginator
@@ -49,7 +49,7 @@ class ModManagement(commands.Cog):
     async def infraction_append(
         self,
         ctx: Context,
-        infraction_id: t.Union[int, allowed_strings("l", "last", "recent")],  # noqa: F821
+        infraction: Infraction,  # noqa: F821
         duration: t.Union[Expiry, allowed_strings("p", "permanent"), None],   # noqa: F821
         *,
         reason: str = None
@@ -73,29 +73,21 @@ class ModManagement(commands.Cog):
         Use "p" or "permanent" to mark the infraction as permanent. Alternatively, an ISO 8601
         timestamp can be provided for the duration.
         """
-        if isinstance(infraction_id, str):
-            old_infraction = await self.get_latest_infraction(ctx.author.id)
-
-            if old_infraction is None:
-                await ctx.send(
-                    ":x: Couldn't find most recent infraction; you have never given an infraction."
-                )
-                return
-
-            infraction_id = old_infraction["id"]
-
-        else:
-            old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
-
-        reason = fr"{old_infraction['reason']} **\|\|** {reason}"
+        if not infraction:
+            return
 
-        await self.infraction_edit(infraction_id=infraction_id, duration=duration, reason=reason)
+        await self.infraction_edit(
+            ctx=ctx,
+            infraction=infraction,
+            duration=duration,
+            reason=fr"{infraction['reason']} **\|\|** {reason}",
+        )
 
     @infraction_group.command(name='edit')
     async def infraction_edit(
         self,
         ctx: Context,
-        infraction_id: t.Union[int, allowed_strings("l", "last", "recent")],  # noqa: F821
+        infraction: Infraction,  # noqa: F821
         duration: t.Union[Expiry, allowed_strings("p", "permanent"), None],   # noqa: F821
         *,
         reason: str = None
@@ -123,20 +115,11 @@ class ModManagement(commands.Cog):
             # Unlike UserInputError, the error handler will show a specified message for BadArgument
             raise commands.BadArgument("Neither a new expiry nor a new reason was specified.")
 
-        # Retrieve the previous infraction for its information.
-        if isinstance(infraction_id, str):
-            old_infraction = await self.get_latest_infraction(ctx.author.id)
-
-            if old_infraction is None:
-                await ctx.send(
-                    ":x: Couldn't find most recent infraction; you have never given an infraction."
-                )
-                return
-
-            infraction_id = old_infraction["id"]
+        if not infraction:
+            return
 
-        else:
-            old_infraction = await self.bot.api_client.get(f"bot/infractions/{infraction_id}")
+        old_infraction = infraction
+        infraction_id = infraction["id"]
 
         request_data = {}
         confirm_messages = []
-- 
cgit v1.2.3


From 776825d09530be6b57759201795c436823002007 Mon Sep 17 00:00:00 2001
From: Thomas Petersson <thomas@petersson.priv.no>
Date: Mon, 5 Oct 2020 18:11:34 +0200
Subject: fix(statsd): Gracefully handle gaierro

Per issue #1185 the bot might go down if the statsd client fails to connect during instantiation. This can be caused by an outage on their part, or network issues.
If this happens getaddrinfo will raise a gaierror.
This PR catched the error, sets self.stats to None for the time being, and handles that elsewhere.
In addition a fallback logic was added to attempt to reconnect, in the off-chance it's a temporary outage
---
 bot/bot.py | 34 ++++++++++++++++++++++++++++++----
 1 file changed, 30 insertions(+), 4 deletions(-)

diff --git a/bot/bot.py b/bot/bot.py
index b2e5237fe..0b842d07a 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -46,7 +46,25 @@ class Bot(commands.Bot):
             # will effectively disable stats.
             statsd_url = "127.0.0.1"
 
-        self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
+        try:
+            self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
+        except socket.gaierror as socket_error:
+            self.stats = None
+            self.loop.call_later(30, self.retry_statsd_connection, statsd_url)
+            log.warning(f"Statsd client failed to instantiate with error:\n{socket_error}")
+
+    def retry_statsd_connection(self, statsd_url: str, retry_after: int = 30, attempt: int = 1) -> None:
+        """Callback used to retry a connection to statsd if it should fail."""
+        if attempt >= 10:
+            log.error("Reached 10 attempts trying to reconnect AsyncStatsClient. Aborting")
+            return
+
+        try:
+            self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
+        except socket.gaierror:
+            log.warning(f"Statsd client failed to reconnect (Retry attempt: {attempt})")
+            # Use a fallback strategy for retrying, up to 10 times.
+            self.loop.call_later(retry_after, self.retry_statsd_connection, statsd_url, retry_after * 2, attempt + 1)
 
     async def cache_filter_list_data(self) -> None:
         """Cache all the data in the FilterList on the site."""
@@ -146,7 +164,7 @@ class Bot(commands.Bot):
         if self._resolver:
             await self._resolver.close()
 
-        if self.stats._transport:
+        if self.stats and self.stats._transport:
             self.stats._transport.close()
 
         if self.redis_session:
@@ -168,7 +186,12 @@ class Bot(commands.Bot):
     async def login(self, *args, **kwargs) -> None:
         """Re-create the connector and set up sessions before logging into Discord."""
         self._recreate()
-        await self.stats.create_socket()
+
+        if self.stats:
+            await self.stats.create_socket()
+        else:
+            log.info("self.stats is not defined, skipping create_socket step in login")
+
         await super().login(*args, **kwargs)
 
     async def on_guild_available(self, guild: discord.Guild) -> None:
@@ -214,7 +237,10 @@ class Bot(commands.Bot):
 
     async def on_error(self, event: str, *args, **kwargs) -> None:
         """Log errors raised in event listeners rather than printing them to stderr."""
-        self.stats.incr(f"errors.event.{event}")
+        if self.stats:
+            self.stats.incr(f"errors.event.{event}")
+        else:
+            log.info(f"self.stats is not defined, skipping errors.event.{event} increment in on_error")
 
         with push_scope() as scope:
             scope.set_tag("event", event)
-- 
cgit v1.2.3


From ca761f04eb3353ae4e9a992d23d13d131d5a6ad0 Mon Sep 17 00:00:00 2001
From: Thomas Petersson <thomas@petersson.priv.no>
Date: Mon, 5 Oct 2020 19:30:58 +0200
Subject: fix(bot): Not assign stats to None

self.stats is referred to as bot.stats in the project, which was overlooked.
This should "disable" stats until it's successfully reconnected.
The retry attempts will continue until it stops throwing or fails 10x
---
 bot/bot.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/bot/bot.py b/bot/bot.py
index 0b842d07a..545efefe6 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -15,6 +15,7 @@ from bot import DEBUG_MODE, api, constants
 from bot.async_stats import AsyncStatsClient
 
 log = logging.getLogger('bot')
+LOCALHOST = "127.0.0.1"
 
 
 class Bot(commands.Bot):
@@ -44,12 +45,12 @@ class Bot(commands.Bot):
             # Since statsd is UDP, there are no errors for sending to a down port.
             # For this reason, setting the statsd host to 127.0.0.1 for development
             # will effectively disable stats.
-            statsd_url = "127.0.0.1"
+            statsd_url = LOCALHOST
 
         try:
             self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
         except socket.gaierror as socket_error:
-            self.stats = None
+            self.stats = AsyncStatsClient(self.loop, LOCALHOST)
             self.loop.call_later(30, self.retry_statsd_connection, statsd_url)
             log.warning(f"Statsd client failed to instantiate with error:\n{socket_error}")
 
-- 
cgit v1.2.3


From 897e714ec0ce8468f10e3c20b50e30bfc96e5c77 Mon Sep 17 00:00:00 2001
From: Thomas Petersson <thomas@petersson.priv.no>
Date: Mon, 5 Oct 2020 19:32:22 +0200
Subject: fix(bot): redundant false checks on self.stats

---
 bot/bot.py | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/bot/bot.py b/bot/bot.py
index 545efefe6..fbf5eb761 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -165,7 +165,7 @@ class Bot(commands.Bot):
         if self._resolver:
             await self._resolver.close()
 
-        if self.stats and self.stats._transport:
+        if self.stats._transport:
             self.stats._transport.close()
 
         if self.redis_session:
@@ -187,12 +187,7 @@ class Bot(commands.Bot):
     async def login(self, *args, **kwargs) -> None:
         """Re-create the connector and set up sessions before logging into Discord."""
         self._recreate()
-
-        if self.stats:
-            await self.stats.create_socket()
-        else:
-            log.info("self.stats is not defined, skipping create_socket step in login")
-
+        await self.stats.create_socket()
         await super().login(*args, **kwargs)
 
     async def on_guild_available(self, guild: discord.Guild) -> None:
@@ -238,10 +233,7 @@ class Bot(commands.Bot):
 
     async def on_error(self, event: str, *args, **kwargs) -> None:
         """Log errors raised in event listeners rather than printing them to stderr."""
-        if self.stats:
-            self.stats.incr(f"errors.event.{event}")
-        else:
-            log.info(f"self.stats is not defined, skipping errors.event.{event} increment in on_error")
+        self.stats.incr(f"errors.event.{event}")
 
         with push_scope() as scope:
             scope.set_tag("event", event)
-- 
cgit v1.2.3


From 7a817f8e088546b535c0a0d71c08f5abbeb4bb0c Mon Sep 17 00:00:00 2001
From: Thomas Petersson <thomas@petersson.priv.no>
Date: Mon, 5 Oct 2020 23:38:17 +0200
Subject: fix(bot): refactor of connect_statsd

---
 bot/bot.py | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/bot/bot.py b/bot/bot.py
index fbf5eb761..06827c7e6 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -47,14 +47,10 @@ class Bot(commands.Bot):
             # will effectively disable stats.
             statsd_url = LOCALHOST
 
-        try:
-            self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
-        except socket.gaierror as socket_error:
-            self.stats = AsyncStatsClient(self.loop, LOCALHOST)
-            self.loop.call_later(30, self.retry_statsd_connection, statsd_url)
-            log.warning(f"Statsd client failed to instantiate with error:\n{socket_error}")
+        self.stats = AsyncStatsClient(self.loop, LOCALHOST)
+        self.connect_statsd(statsd_url)
 
-    def retry_statsd_connection(self, statsd_url: str, retry_after: int = 30, attempt: int = 1) -> None:
+    def connect_statsd(self, statsd_url: str, retry_after: int = 30, attempt: int = 1) -> None:
         """Callback used to retry a connection to statsd if it should fail."""
         if attempt >= 10:
             log.error("Reached 10 attempts trying to reconnect AsyncStatsClient. Aborting")
@@ -63,9 +59,9 @@ class Bot(commands.Bot):
         try:
             self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
         except socket.gaierror:
-            log.warning(f"Statsd client failed to reconnect (Retry attempt: {attempt})")
+            log.warning(f"Statsd client failed to connect (Attempts: {attempt})")
             # Use a fallback strategy for retrying, up to 10 times.
-            self.loop.call_later(retry_after, self.retry_statsd_connection, statsd_url, retry_after * 2, attempt + 1)
+            self.loop.call_later(retry_after, self.retry_statsd_connection, statsd_url, retry_after ** 2, attempt + 1)
 
     async def cache_filter_list_data(self) -> None:
         """Cache all the data in the FilterList on the site."""
-- 
cgit v1.2.3


From 3e37bf88c86b0884b327d3eeb165b42860fa2fce Mon Sep 17 00:00:00 2001
From: Thomas Petersson <thomas@petersson.priv.no>
Date: Mon, 5 Oct 2020 23:39:54 +0200
Subject: fix(bot): better fallback logic

---
 bot/bot.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bot/bot.py b/bot/bot.py
index 06827c7e6..eee940637 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -50,9 +50,9 @@ class Bot(commands.Bot):
         self.stats = AsyncStatsClient(self.loop, LOCALHOST)
         self.connect_statsd(statsd_url)
 
-    def connect_statsd(self, statsd_url: str, retry_after: int = 30, attempt: int = 1) -> None:
+    def connect_statsd(self, statsd_url: str, retry_after: int = 2, attempt: int = 1) -> None:
         """Callback used to retry a connection to statsd if it should fail."""
-        if attempt >= 10:
+        if attempt > 5:
             log.error("Reached 10 attempts trying to reconnect AsyncStatsClient. Aborting")
             return
 
@@ -60,7 +60,7 @@ class Bot(commands.Bot):
             self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
         except socket.gaierror:
             log.warning(f"Statsd client failed to connect (Attempts: {attempt})")
-            # Use a fallback strategy for retrying, up to 10 times.
+            # Use a fallback strategy for retrying, up to 5 times.
             self.loop.call_later(retry_after, self.retry_statsd_connection, statsd_url, retry_after ** 2, attempt + 1)
 
     async def cache_filter_list_data(self) -> None:
-- 
cgit v1.2.3


From 54a0ad23786d50956ac43518bb698f6dcc43a4ad Mon Sep 17 00:00:00 2001
From: kosayoda <kieransiek@protonmail.com>
Date: Thu, 8 Oct 2020 17:06:36 +0800
Subject: Resolve logic error with reason override.

The reason override for the user message should be set to the infraction
reason *if* the override is None, not if it isn't.

The parameter is also renamed to `user_reason` for better clarity.
---
 bot/exts/moderation/infraction/_scheduler.py   | 11 ++++++-----
 bot/exts/moderation/infraction/superstarify.py |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/bot/exts/moderation/infraction/_scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index b66fdc850..b68921dad 100644
--- a/bot/exts/moderation/infraction/_scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -82,14 +82,15 @@ class InfractionScheduler:
         infraction: _utils.Infraction,
         user: UserSnowflake,
         action_coro: t.Optional[t.Awaitable] = None,
-        reason_override: t.Optional[str] = None,
+        user_reason: t.Optional[str] = None,
         additional_info: t.Optional[str] = None,
     ) -> bool:
         """
         Apply an infraction to the user, log the infraction, and optionally notify the user.
 
-        `reason_override`, if provided, will be sent to the user in place of the infraction reason.
+        `user_reason`, if provided, will be sent to the user in place of the infraction reason.
         `additional_info` will be attached to the text field in the mod-log embed.
+
         Returns whether or not the infraction succeeded.
         """
         infr_type = infraction["type"]
@@ -98,8 +99,8 @@ class InfractionScheduler:
         expiry = time.format_infraction_with_duration(infraction["expires_at"])
         id_ = infraction['id']
 
-        if reason_override is not None:
-            reason_override = reason
+        if user_reason is None:
+            user_reason = reason
 
         if additional_info is not None:
             additional_info = ""
@@ -139,7 +140,7 @@ class InfractionScheduler:
                 log.error(f"Failed to DM {user.id}: could not fetch user (status {e.status})")
             else:
                 # Accordingly display whether the user was successfully notified via DM.
-                if await _utils.notify_infraction(user, infr_type, expiry, reason_override, icon):
+                if await _utils.notify_infraction(user, infr_type, expiry, user_reason, icon):
                     dm_result = ":incoming_envelope: "
                     dm_log_text = "\nDM: Sent"
 
diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index 3c96f7317..f17214c75 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -159,7 +159,7 @@ class Superstarify(InfractionScheduler, Cog):
 
         successful = await self.apply_infraction(
             ctx, infraction, member, action(),
-            reason_override=superstar_reason,
+            user_reason=superstar_reason,
             additional_info=nickname_info
         )
 
-- 
cgit v1.2.3


From 11283adc3858e88bfbf69e1751f9cc6fccbb8c18 Mon Sep 17 00:00:00 2001
From: kosayoda <kieransiek@protonmail.com>
Date: Thu, 8 Oct 2020 17:18:06 +0800
Subject: Improve default argument.

---
 bot/exts/moderation/infraction/_scheduler.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/bot/exts/moderation/infraction/_scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index b68921dad..5c3e445f6 100644
--- a/bot/exts/moderation/infraction/_scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -83,7 +83,7 @@ class InfractionScheduler:
         user: UserSnowflake,
         action_coro: t.Optional[t.Awaitable] = None,
         user_reason: t.Optional[str] = None,
-        additional_info: t.Optional[str] = None,
+        additional_info: t.Optional[str] = "",
     ) -> bool:
         """
         Apply an infraction to the user, log the infraction, and optionally notify the user.
@@ -102,9 +102,6 @@ class InfractionScheduler:
         if user_reason is None:
             user_reason = reason
 
-        if additional_info is not None:
-            additional_info = ""
-
         log.trace(f"Applying {infr_type} infraction #{id_} to {user}.")
 
         # Default values for the confirmation message and mod log.
-- 
cgit v1.2.3


From 952f30f7cce351337c36655f4ff81e7e86d02b00 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 14:42:09 -0700
Subject: Add global bot instance

Is **very** convenient when writing utility functions that rely on the
bot's state, but aren't in cogs and therefore lack the typical way to
access the instance. No more passing around of the instance as an arg!
---
 bot/__init__.py | 6 ++++++
 bot/__main__.py | 7 ++++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/bot/__init__.py b/bot/__init__.py
index 3ee70c4e9..0642b2c5d 100644
--- a/bot/__init__.py
+++ b/bot/__init__.py
@@ -5,12 +5,16 @@ import sys
 from functools import partial, partialmethod
 from logging import Logger, handlers
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import coloredlogs
 from discord.ext import commands
 
 from bot.command import Command
 
+if TYPE_CHECKING:
+    from bot.bot import Bot
+
 TRACE_LEVEL = logging.TRACE = 5
 logging.addLevelName(TRACE_LEVEL, "TRACE")
 
@@ -76,3 +80,5 @@ if os.name == "nt":
 # Must be patched before any cogs are added.
 commands.command = partial(commands.command, cls=Command)
 commands.GroupMixin.command = partialmethod(commands.GroupMixin.command, cls=Command)
+
+instance: "Bot" = None  # Global Bot instance.
diff --git a/bot/__main__.py b/bot/__main__.py
index 367be1300..9d48c9092 100644
--- a/bot/__main__.py
+++ b/bot/__main__.py
@@ -9,6 +9,7 @@ from sentry_sdk.integrations.aiohttp import AioHttpIntegration
 from sentry_sdk.integrations.logging import LoggingIntegration
 from sentry_sdk.integrations.redis import RedisIntegration
 
+import bot
 from bot import constants
 from bot.bot import Bot
 from bot.utils.extensions import EXTENSIONS
@@ -54,7 +55,7 @@ intents.dm_reactions = False
 intents.invites = False
 intents.webhooks = False
 intents.integrations = False
-bot = Bot(
+bot.instance = Bot(
     redis_session=redis_session,
     loop=loop,
     command_prefix=when_mentioned_or(constants.Bot.prefix),
@@ -71,6 +72,6 @@ if not constants.HelpChannels.enable:
     extensions.remove("bot.exts.help_channels")
 
 for extension in extensions:
-    bot.load_extension(extension)
+    bot.instance.load_extension(extension)
 
-bot.run(constants.Bot.token)
+bot.instance.run(constants.Bot.token)
-- 
cgit v1.2.3


From e059c32d10997e22b508c04031c19999f3185f7d Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 14:53:18 -0700
Subject: Use global bot instance in send_to_paste_service

---
 bot/exts/utils/internal.py           |  2 +-
 bot/exts/utils/snekbox.py            |  2 +-
 bot/utils/services.py                |  8 ++++----
 tests/bot/exts/utils/test_snekbox.py |  4 +---
 tests/bot/utils/test_services.py     | 39 +++++++++++++++++++-----------------
 5 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/bot/exts/utils/internal.py b/bot/exts/utils/internal.py
index 1b4900f42..a6bc60026 100644
--- a/bot/exts/utils/internal.py
+++ b/bot/exts/utils/internal.py
@@ -195,7 +195,7 @@ async def func():  # (None,) -> Any
             truncate_index = newline_truncate_index
 
         if len(out) > truncate_index:
-            paste_link = await send_to_paste_service(self.bot.http_session, out, extension="py")
+            paste_link = await send_to_paste_service(out, extension="py")
             if paste_link is not None:
                 paste_text = f"full contents at {paste_link}"
             else:
diff --git a/bot/exts/utils/snekbox.py b/bot/exts/utils/snekbox.py
index 59a27a2be..e727be39e 100644
--- a/bot/exts/utils/snekbox.py
+++ b/bot/exts/utils/snekbox.py
@@ -72,7 +72,7 @@ class Snekbox(Cog):
         if len(output) > MAX_PASTE_LEN:
             log.info("Full output is too long to upload")
             return "too long to upload"
-        return await send_to_paste_service(self.bot.http_session, output, extension="txt")
+        return await send_to_paste_service(output, extension="txt")
 
     @staticmethod
     def prepare_input(code: str) -> str:
diff --git a/bot/utils/services.py b/bot/utils/services.py
index 087b9f969..5949c9e48 100644
--- a/bot/utils/services.py
+++ b/bot/utils/services.py
@@ -1,8 +1,9 @@
 import logging
 from typing import Optional
 
-from aiohttp import ClientConnectorError, ClientSession
+from aiohttp import ClientConnectorError
 
+import bot
 from bot.constants import URLs
 
 log = logging.getLogger(__name__)
@@ -10,11 +11,10 @@ log = logging.getLogger(__name__)
 FAILED_REQUEST_ATTEMPTS = 3
 
 
-async def send_to_paste_service(http_session: ClientSession, contents: str, *, extension: str = "") -> Optional[str]:
+async def send_to_paste_service(contents: str, *, extension: str = "") -> Optional[str]:
     """
     Upload `contents` to the paste service.
 
-    `http_session` should be the current running ClientSession from aiohttp
     `extension` is added to the output URL
 
     When an error occurs, `None` is returned, otherwise the generated URL with the suffix.
@@ -24,7 +24,7 @@ async def send_to_paste_service(http_session: ClientSession, contents: str, *, e
     paste_url = URLs.paste_service.format(key="documents")
     for attempt in range(1, FAILED_REQUEST_ATTEMPTS + 1):
         try:
-            async with http_session.post(paste_url, data=contents) as response:
+            async with bot.instance.http_session.post(paste_url, data=contents) as response:
                 response_json = await response.json()
         except ClientConnectorError:
             log.warning(
diff --git a/tests/bot/exts/utils/test_snekbox.py b/tests/bot/exts/utils/test_snekbox.py
index 6601fad2c..9d3e07e7c 100644
--- a/tests/bot/exts/utils/test_snekbox.py
+++ b/tests/bot/exts/utils/test_snekbox.py
@@ -42,9 +42,7 @@ class SnekboxTests(unittest.IsolatedAsyncioTestCase):
     async def test_upload_output(self, mock_paste_util):
         """Upload the eval output to the URLs.paste_service.format(key="documents") endpoint."""
         await self.cog.upload_output("Test output.")
-        mock_paste_util.assert_called_once_with(
-            self.bot.http_session, "Test output.", extension="txt"
-        )
+        mock_paste_util.assert_called_once_with("Test output.", extension="txt")
 
     def test_prepare_input(self):
         cases = (
diff --git a/tests/bot/utils/test_services.py b/tests/bot/utils/test_services.py
index 5e0855704..1b48f6560 100644
--- a/tests/bot/utils/test_services.py
+++ b/tests/bot/utils/test_services.py
@@ -5,11 +5,14 @@ from unittest.mock import AsyncMock, MagicMock, Mock, patch
 from aiohttp import ClientConnectorError
 
 from bot.utils.services import FAILED_REQUEST_ATTEMPTS, send_to_paste_service
+from tests.helpers import MockBot
 
 
 class PasteTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
-        self.http_session = MagicMock()
+        patcher = patch("bot.instance", new=MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
 
     @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
     async def test_url_and_sent_contents(self):
@@ -17,10 +20,10 @@ class PasteTests(unittest.IsolatedAsyncioTestCase):
         response = MagicMock(
             json=AsyncMock(return_value={"key": ""})
         )
-        self.http_session.post().__aenter__.return_value = response
-        self.http_session.post.reset_mock()
-        await send_to_paste_service(self.http_session, "Content")
-        self.http_session.post.assert_called_once_with("https://paste_service.com/documents", data="Content")
+        self.bot.http_session.post.return_value.__aenter__.return_value = response
+        self.bot.http_session.post.reset_mock()
+        await send_to_paste_service("Content")
+        self.bot.http_session.post.assert_called_once_with("https://paste_service.com/documents", data="Content")
 
     @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
     async def test_paste_returns_correct_url_on_success(self):
@@ -34,41 +37,41 @@ class PasteTests(unittest.IsolatedAsyncioTestCase):
         response = MagicMock(
             json=AsyncMock(return_value={"key": key})
         )
-        self.http_session.post().__aenter__.return_value = response
+        self.bot.http_session.post.return_value.__aenter__.return_value = response
 
         for expected_output, extension in test_cases:
             with self.subTest(msg=f"Send contents with extension {repr(extension)}"):
                 self.assertEqual(
-                    await send_to_paste_service(self.http_session, "", extension=extension),
+                    await send_to_paste_service("", extension=extension),
                     expected_output
                 )
 
     async def test_request_repeated_on_json_errors(self):
         """Json with error message and invalid json are handled as errors and requests repeated."""
         test_cases = ({"message": "error"}, {"unexpected_key": None}, {})
-        self.http_session.post().__aenter__.return_value = response = MagicMock()
-        self.http_session.post.reset_mock()
+        self.bot.http_session.post.return_value.__aenter__.return_value = response = MagicMock()
+        self.bot.http_session.post.reset_mock()
 
         for error_json in test_cases:
             with self.subTest(error_json=error_json):
                 response.json = AsyncMock(return_value=error_json)
-                result = await send_to_paste_service(self.http_session, "")
-                self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+                result = await send_to_paste_service("")
+                self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
                 self.assertIsNone(result)
 
-            self.http_session.post.reset_mock()
+            self.bot.http_session.post.reset_mock()
 
     async def test_request_repeated_on_connection_errors(self):
         """Requests are repeated in the case of connection errors."""
-        self.http_session.post = MagicMock(side_effect=ClientConnectorError(Mock(), Mock()))
-        result = await send_to_paste_service(self.http_session, "")
-        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.bot.http_session.post = MagicMock(side_effect=ClientConnectorError(Mock(), Mock()))
+        result = await send_to_paste_service("")
+        self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
         self.assertIsNone(result)
 
     async def test_general_error_handled_and_request_repeated(self):
         """All `Exception`s are handled, logged and request repeated."""
-        self.http_session.post = MagicMock(side_effect=Exception)
-        result = await send_to_paste_service(self.http_session, "")
-        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.bot.http_session.post = MagicMock(side_effect=Exception)
+        result = await send_to_paste_service("")
+        self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
         self.assertLogs("bot.utils", logging.ERROR)
         self.assertIsNone(result)
-- 
cgit v1.2.3


From a75e306504a0372d987639966844e0827410a317 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 14:56:24 -0700
Subject: Use global bot instance in wait_for_deletion

---
 bot/exts/info/codeblock/_cog.py | 2 +-
 bot/exts/info/doc.py            | 2 +-
 bot/exts/info/help.py           | 6 +++---
 bot/exts/info/tags.py           | 2 --
 bot/exts/utils/snekbox.py       | 2 +-
 bot/utils/messages.py           | 4 ++--
 6 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/bot/exts/info/codeblock/_cog.py b/bot/exts/info/codeblock/_cog.py
index 1e0feab0d..9094d9d15 100644
--- a/bot/exts/info/codeblock/_cog.py
+++ b/bot/exts/info/codeblock/_cog.py
@@ -114,7 +114,7 @@ class CodeBlockCog(Cog, name="Code Block"):
         bot_message = await message.channel.send(f"Hey {message.author.mention}!", embed=embed)
         self.codeblock_message_ids[message.id] = bot_message.id
 
-        self.bot.loop.create_task(wait_for_deletion(bot_message, (message.author.id,), self.bot))
+        self.bot.loop.create_task(wait_for_deletion(bot_message, (message.author.id,)))
 
         # Increase amount of codeblock correction in stats
         self.bot.stats.incr("codeblock_corrections")
diff --git a/bot/exts/info/doc.py b/bot/exts/info/doc.py
index c16a99225..aba7f7e48 100644
--- a/bot/exts/info/doc.py
+++ b/bot/exts/info/doc.py
@@ -392,7 +392,7 @@ class Doc(commands.Cog):
                     await ctx.message.delete(delay=NOT_FOUND_DELETE_DELAY)
             else:
                 msg = await ctx.send(embed=doc_embed)
-                await wait_for_deletion(msg, (ctx.author.id,), client=self.bot)
+                await wait_for_deletion(msg, (ctx.author.id,))
 
     @docs_group.command(name='set', aliases=('s',))
     @commands.has_any_role(*MODERATION_ROLES)
diff --git a/bot/exts/info/help.py b/bot/exts/info/help.py
index 599c5d5c0..461ff82fd 100644
--- a/bot/exts/info/help.py
+++ b/bot/exts/info/help.py
@@ -186,7 +186,7 @@ class CustomHelpCommand(HelpCommand):
         """Send help for a single command."""
         embed = await self.command_formatting(command)
         message = await self.context.send(embed=embed)
-        await wait_for_deletion(message, (self.context.author.id,), self.context.bot)
+        await wait_for_deletion(message, (self.context.author.id,))
 
     @staticmethod
     def get_commands_brief_details(commands_: List[Command], return_as_list: bool = False) -> Union[List[str], str]:
@@ -225,7 +225,7 @@ class CustomHelpCommand(HelpCommand):
             embed.description += f"\n**Subcommands:**\n{command_details}"
 
         message = await self.context.send(embed=embed)
-        await wait_for_deletion(message, (self.context.author.id,), self.context.bot)
+        await wait_for_deletion(message, (self.context.author.id,))
 
     async def send_cog_help(self, cog: Cog) -> None:
         """Send help for a cog."""
@@ -241,7 +241,7 @@ class CustomHelpCommand(HelpCommand):
             embed.description += f"\n\n**Commands:**\n{command_details}"
 
         message = await self.context.send(embed=embed)
-        await wait_for_deletion(message, (self.context.author.id,), self.context.bot)
+        await wait_for_deletion(message, (self.context.author.id,))
 
     @staticmethod
     def _category_key(command: Command) -> str:
diff --git a/bot/exts/info/tags.py b/bot/exts/info/tags.py
index ae95ac1ef..8f15f932b 100644
--- a/bot/exts/info/tags.py
+++ b/bot/exts/info/tags.py
@@ -236,7 +236,6 @@ class Tags(Cog):
                 await wait_for_deletion(
                     await ctx.send(embed=Embed.from_dict(tag['embed'])),
                     [ctx.author.id],
-                    self.bot
                 )
             elif founds and len(tag_name) >= 3:
                 await wait_for_deletion(
@@ -247,7 +246,6 @@ class Tags(Cog):
                         )
                     ),
                     [ctx.author.id],
-                    self.bot
                 )
 
         else:
diff --git a/bot/exts/utils/snekbox.py b/bot/exts/utils/snekbox.py
index e727be39e..bde1684d8 100644
--- a/bot/exts/utils/snekbox.py
+++ b/bot/exts/utils/snekbox.py
@@ -212,7 +212,7 @@ class Snekbox(Cog):
                 response = await ctx.send("Attempt to circumvent filter detected. Moderator team has been alerted.")
             else:
                 response = await ctx.send(msg)
-            self.bot.loop.create_task(wait_for_deletion(response, (ctx.author.id,), ctx.bot))
+            self.bot.loop.create_task(wait_for_deletion(response, (ctx.author.id,)))
 
             log.info(f"{ctx.author}'s job had a return code of {results['returncode']}")
         return response
diff --git a/bot/utils/messages.py b/bot/utils/messages.py
index b6c7cab50..42bde358d 100644
--- a/bot/utils/messages.py
+++ b/bot/utils/messages.py
@@ -10,6 +10,7 @@ import discord
 from discord.errors import HTTPException
 from discord.ext.commands import Context
 
+import bot
 from bot.constants import Emojis, NEGATIVE_REPLIES
 
 log = logging.getLogger(__name__)
@@ -18,7 +19,6 @@ log = logging.getLogger(__name__)
 async def wait_for_deletion(
     message: discord.Message,
     user_ids: Sequence[discord.abc.Snowflake],
-    client: discord.Client,
     deletion_emojis: Sequence[str] = (Emojis.trashcan,),
     timeout: float = 60 * 5,
     attach_emojis: bool = True,
@@ -49,7 +49,7 @@ async def wait_for_deletion(
         )
 
     with contextlib.suppress(asyncio.TimeoutError):
-        await client.wait_for('reaction_add', check=check, timeout=timeout)
+        await bot.instance.wait_for('reaction_add', check=check, timeout=timeout)
         await message.delete()
 
 
-- 
cgit v1.2.3


From 14e753209800716559ed0f8724ba9cde37ad09e6 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 14:58:45 -0700
Subject: Use global bot instance in try_get_channel

---
 bot/exts/help_channels.py | 11 ++++-------
 bot/utils/channel.py      |  7 ++++---
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index 062d4fcfe..f5a8b251b 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -380,16 +380,13 @@ class HelpChannels(commands.Cog):
 
         try:
             self.available_category = await channel_utils.try_get_channel(
-                constants.Categories.help_available,
-                self.bot
+                constants.Categories.help_available
             )
             self.in_use_category = await channel_utils.try_get_channel(
-                constants.Categories.help_in_use,
-                self.bot
+                constants.Categories.help_in_use
             )
             self.dormant_category = await channel_utils.try_get_channel(
-                constants.Categories.help_dormant,
-                self.bot
+                constants.Categories.help_dormant
             )
         except discord.HTTPException:
             log.exception("Failed to get a category; cog will be removed")
@@ -500,7 +497,7 @@ class HelpChannels(commands.Cog):
         options should be avoided, as it may interfere with the category move we perform.
         """
         # Get a fresh copy of the category from the bot to avoid the cache mismatch issue we had.
-        category = await channel_utils.try_get_channel(category_id, self.bot)
+        category = await channel_utils.try_get_channel(category_id)
 
         payload = [{"id": c.id, "position": c.position} for c in category.channels]
 
diff --git a/bot/utils/channel.py b/bot/utils/channel.py
index 851f9e1fe..d9d1b4b86 100644
--- a/bot/utils/channel.py
+++ b/bot/utils/channel.py
@@ -2,6 +2,7 @@ import logging
 
 import discord
 
+import bot
 from bot.constants import Categories
 
 log = logging.getLogger(__name__)
@@ -20,14 +21,14 @@ def is_in_category(channel: discord.TextChannel, category_id: int) -> bool:
     return getattr(channel, "category_id", None) == category_id
 
 
-async def try_get_channel(channel_id: int, client: discord.Client) -> discord.abc.GuildChannel:
+async def try_get_channel(channel_id: int) -> discord.abc.GuildChannel:
     """Attempt to get or fetch a channel and return it."""
     log.trace(f"Getting the channel {channel_id}.")
 
-    channel = client.get_channel(channel_id)
+    channel = bot.instance.get_channel(channel_id)
     if not channel:
         log.debug(f"Channel {channel_id} is not in cache; fetching from API.")
-        channel = await client.fetch_channel(channel_id)
+        channel = await bot.instance.fetch_channel(channel_id)
 
     log.trace(f"Channel #{channel} ({channel_id}) retrieved.")
     return channel
-- 
cgit v1.2.3


From 09d559fe60f450ce1b3e11b341971df1d12b1562 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 15:11:14 -0700
Subject: Use global bot instance in Interpreter

---
 bot/exts/utils/internal.py | 2 +-
 bot/interpreter.py         | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/bot/exts/utils/internal.py b/bot/exts/utils/internal.py
index a6bc60026..3521c8fd4 100644
--- a/bot/exts/utils/internal.py
+++ b/bot/exts/utils/internal.py
@@ -30,7 +30,7 @@ class Internal(Cog):
         self.ln = 0
         self.stdout = StringIO()
 
-        self.interpreter = Interpreter(bot)
+        self.interpreter = Interpreter()
 
         self.socket_since = datetime.utcnow()
         self.socket_event_total = 0
diff --git a/bot/interpreter.py b/bot/interpreter.py
index 8b7268746..b58f7a6b0 100644
--- a/bot/interpreter.py
+++ b/bot/interpreter.py
@@ -4,7 +4,7 @@ from typing import Any
 
 from discord.ext.commands import Context
 
-from bot.bot import Bot
+import bot
 
 CODE_TEMPLATE = """
 async def _func():
@@ -21,8 +21,8 @@ class Interpreter(InteractiveInterpreter):
 
     write_callable = None
 
-    def __init__(self, bot: Bot):
-        locals_ = {"bot": bot}
+    def __init__(self):
+        locals_ = {"bot": bot.instance}
         super().__init__(locals_)
 
     async def run(self, code: str, ctx: Context, io: StringIO, *args, **kwargs) -> Any:
-- 
cgit v1.2.3


From f3f4b2acc2500e37ed7d1007c40a125b3442c5f0 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 15:51:04 -0700
Subject: Use global bot instance in syncers

They're pretty close to being fully static classes, but it's difficult
to make the name attribute a static abstract property.
---
 bot/exts/backend/sync/_cog.py             |  4 +--
 bot/exts/backend/sync/_syncers.py         | 42 +++++++++++++++++--------------
 tests/bot/exts/backend/sync/test_base.py  | 12 ++++-----
 tests/bot/exts/backend/sync/test_cog.py   | 20 +++++++--------
 tests/bot/exts/backend/sync/test_roles.py | 14 ++++++++---
 tests/bot/exts/backend/sync/test_users.py | 15 ++++++++---
 6 files changed, 62 insertions(+), 45 deletions(-)

diff --git a/bot/exts/backend/sync/_cog.py b/bot/exts/backend/sync/_cog.py
index 6e85e2b7d..b71ed3e69 100644
--- a/bot/exts/backend/sync/_cog.py
+++ b/bot/exts/backend/sync/_cog.py
@@ -18,8 +18,8 @@ class Sync(Cog):
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
-        self.role_syncer = _syncers.RoleSyncer(self.bot)
-        self.user_syncer = _syncers.UserSyncer(self.bot)
+        self.role_syncer = _syncers.RoleSyncer()
+        self.user_syncer = _syncers.UserSyncer()
 
         self.bot.loop.create_task(self.sync_guild())
 
diff --git a/bot/exts/backend/sync/_syncers.py b/bot/exts/backend/sync/_syncers.py
index 38468c2b1..bdd76806b 100644
--- a/bot/exts/backend/sync/_syncers.py
+++ b/bot/exts/backend/sync/_syncers.py
@@ -6,8 +6,8 @@ from collections import namedtuple
 from discord import Guild
 from discord.ext.commands import Context
 
+import bot
 from bot.api import ResponseCodeError
-from bot.bot import Bot
 
 log = logging.getLogger(__name__)
 
@@ -20,22 +20,21 @@ _Diff = namedtuple('Diff', ('created', 'updated', 'deleted'))
 class Syncer(abc.ABC):
     """Base class for synchronising the database with objects in the Discord cache."""
 
-    def __init__(self, bot: Bot) -> None:
-        self.bot = bot
-
     @property
     @abc.abstractmethod
     def name(self) -> str:
         """The name of the syncer; used in output messages and logging."""
         raise NotImplementedError  # pragma: no cover
 
+    @staticmethod
     @abc.abstractmethod
-    async def _get_diff(self, guild: Guild) -> _Diff:
+    async def _get_diff(guild: Guild) -> _Diff:
         """Return the difference between the cache of `guild` and the database."""
         raise NotImplementedError  # pragma: no cover
 
+    @staticmethod
     @abc.abstractmethod
-    async def _sync(self, diff: _Diff) -> None:
+    async def _sync(diff: _Diff) -> None:
         """Perform the API calls for synchronisation."""
         raise NotImplementedError  # pragma: no cover
 
@@ -78,10 +77,11 @@ class RoleSyncer(Syncer):
 
     name = "role"
 
-    async def _get_diff(self, guild: Guild) -> _Diff:
+    @staticmethod
+    async def _get_diff(guild: Guild) -> _Diff:
         """Return the difference of roles between the cache of `guild` and the database."""
         log.trace("Getting the diff for roles.")
-        roles = await self.bot.api_client.get('bot/roles')
+        roles = await bot.instance.api_client.get('bot/roles')
 
         # Pack DB roles and guild roles into one common, hashable format.
         # They're hashable so that they're easily comparable with sets later.
@@ -110,19 +110,20 @@ class RoleSyncer(Syncer):
 
         return _Diff(roles_to_create, roles_to_update, roles_to_delete)
 
-    async def _sync(self, diff: _Diff) -> None:
+    @staticmethod
+    async def _sync(diff: _Diff) -> None:
         """Synchronise the database with the role cache of `guild`."""
         log.trace("Syncing created roles...")
         for role in diff.created:
-            await self.bot.api_client.post('bot/roles', json=role._asdict())
+            await bot.instance.api_client.post('bot/roles', json=role._asdict())
 
         log.trace("Syncing updated roles...")
         for role in diff.updated:
-            await self.bot.api_client.put(f'bot/roles/{role.id}', json=role._asdict())
+            await bot.instance.api_client.put(f'bot/roles/{role.id}', json=role._asdict())
 
         log.trace("Syncing deleted roles...")
         for role in diff.deleted:
-            await self.bot.api_client.delete(f'bot/roles/{role.id}')
+            await bot.instance.api_client.delete(f'bot/roles/{role.id}')
 
 
 class UserSyncer(Syncer):
@@ -130,7 +131,8 @@ class UserSyncer(Syncer):
 
     name = "user"
 
-    async def _get_diff(self, guild: Guild) -> _Diff:
+    @staticmethod
+    async def _get_diff(guild: Guild) -> _Diff:
         """Return the difference of users between the cache of `guild` and the database."""
         log.trace("Getting the diff for users.")
 
@@ -138,7 +140,7 @@ class UserSyncer(Syncer):
         users_to_update = []
         seen_guild_users = set()
 
-        async for db_user in self._get_users():
+        async for db_user in UserSyncer._get_users():
             # Store user fields which are to be updated.
             updated_fields = {}
 
@@ -185,24 +187,26 @@ class UserSyncer(Syncer):
 
         return _Diff(users_to_create, users_to_update, None)
 
-    async def _get_users(self) -> t.AsyncIterable:
+    @staticmethod
+    async def _get_users() -> t.AsyncIterable:
         """GET users from database."""
         query_params = {
             "page": 1
         }
         while query_params["page"]:
-            res = await self.bot.api_client.get("bot/users", params=query_params)
+            res = await bot.instance.api_client.get("bot/users", params=query_params)
             for user in res["results"]:
                 yield user
 
             query_params["page"] = res["next_page_no"]
 
-    async def _sync(self, diff: _Diff) -> None:
+    @staticmethod
+    async def _sync(diff: _Diff) -> None:
         """Synchronise the database with the user cache of `guild`."""
         log.trace("Syncing created users...")
         if diff.created:
-            await self.bot.api_client.post("bot/users", json=diff.created)
+            await bot.instance.api_client.post("bot/users", json=diff.created)
 
         log.trace("Syncing updated users...")
         if diff.updated:
-            await self.bot.api_client.patch("bot/users/bulk_patch", json=diff.updated)
+            await bot.instance.api_client.patch("bot/users/bulk_patch", json=diff.updated)
diff --git a/tests/bot/exts/backend/sync/test_base.py b/tests/bot/exts/backend/sync/test_base.py
index 4953550f9..157d42452 100644
--- a/tests/bot/exts/backend/sync/test_base.py
+++ b/tests/bot/exts/backend/sync/test_base.py
@@ -18,21 +18,21 @@ class TestSyncer(Syncer):
 class SyncerBaseTests(unittest.TestCase):
     """Tests for the syncer base class."""
 
-    def setUp(self):
-        self.bot = helpers.MockBot()
-
     def test_instantiation_fails_without_abstract_methods(self):
         """The class must have abstract methods implemented."""
         with self.assertRaisesRegex(TypeError, "Can't instantiate abstract class"):
-            Syncer(self.bot)
+            Syncer()
 
 
 class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for main function orchestrating the sync."""
 
     def setUp(self):
-        self.bot = helpers.MockBot(user=helpers.MockMember(bot=True))
-        self.syncer = TestSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot(user=helpers.MockMember(bot=True)))
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = TestSyncer()
         self.guild = helpers.MockGuild()
 
         # Make sure `_get_diff` returns a MagicMock, not an AsyncMock
diff --git a/tests/bot/exts/backend/sync/test_cog.py b/tests/bot/exts/backend/sync/test_cog.py
index 063a82754..1e1883558 100644
--- a/tests/bot/exts/backend/sync/test_cog.py
+++ b/tests/bot/exts/backend/sync/test_cog.py
@@ -29,24 +29,24 @@ class SyncCogTestCase(unittest.IsolatedAsyncioTestCase):
     def setUp(self):
         self.bot = helpers.MockBot()
 
-        self.role_syncer_patcher = mock.patch(
+        role_syncer_patcher = mock.patch(
             "bot.exts.backend.sync._syncers.RoleSyncer",
             autospec=Syncer,
             spec_set=True
         )
-        self.user_syncer_patcher = mock.patch(
+        user_syncer_patcher = mock.patch(
             "bot.exts.backend.sync._syncers.UserSyncer",
             autospec=Syncer,
             spec_set=True
         )
-        self.RoleSyncer = self.role_syncer_patcher.start()
-        self.UserSyncer = self.user_syncer_patcher.start()
 
-        self.cog = Sync(self.bot)
+        self.RoleSyncer = role_syncer_patcher.start()
+        self.UserSyncer = user_syncer_patcher.start()
 
-    def tearDown(self):
-        self.role_syncer_patcher.stop()
-        self.user_syncer_patcher.stop()
+        self.addCleanup(role_syncer_patcher.stop)
+        self.addCleanup(user_syncer_patcher.stop)
+
+        self.cog = Sync(self.bot)
 
     @staticmethod
     def response_error(status: int) -> ResponseCodeError:
@@ -73,8 +73,8 @@ class SyncCogTests(SyncCogTestCase):
 
         Sync(self.bot)
 
-        self.RoleSyncer.assert_called_once_with(self.bot)
-        self.UserSyncer.assert_called_once_with(self.bot)
+        self.RoleSyncer.assert_called_once_with()
+        self.UserSyncer.assert_called_once_with()
         sync_guild.assert_called_once_with()
         self.bot.loop.create_task.assert_called_once_with(mock_sync_guild_coro)
 
diff --git a/tests/bot/exts/backend/sync/test_roles.py b/tests/bot/exts/backend/sync/test_roles.py
index 7b9f40cad..fb63a4ae0 100644
--- a/tests/bot/exts/backend/sync/test_roles.py
+++ b/tests/bot/exts/backend/sync/test_roles.py
@@ -22,8 +22,11 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
     """Tests for determining differences between roles in the DB and roles in the Guild cache."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = RoleSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = RoleSyncer()
 
     @staticmethod
     def get_guild(*roles):
@@ -108,8 +111,11 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the API requests that sync roles."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = RoleSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = RoleSyncer()
 
     async def test_sync_created_roles(self):
         """Only POST requests should be made with the correct payload."""
diff --git a/tests/bot/exts/backend/sync/test_users.py b/tests/bot/exts/backend/sync/test_users.py
index 9f380a15d..9f28d0162 100644
--- a/tests/bot/exts/backend/sync/test_users.py
+++ b/tests/bot/exts/backend/sync/test_users.py
@@ -1,4 +1,5 @@
 import unittest
+from unittest import mock
 
 from bot.exts.backend.sync._syncers import UserSyncer, _Diff
 from tests import helpers
@@ -19,8 +20,11 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
     """Tests for determining differences between users in the DB and users in the Guild cache."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = UserSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = UserSyncer()
 
     @staticmethod
     def get_guild(*members):
@@ -186,8 +190,11 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the API requests that sync users."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = UserSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = UserSyncer()
 
     async def test_sync_created_users(self):
         """Only POST requests should be made with the correct payload."""
-- 
cgit v1.2.3


From cc3805e0ca378ccaa3d025947c0982d0c8cb4e9f Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 17 Oct 2020 13:33:55 -0700
Subject: Syncers: make functions static

The classes no longer hold any state since they can use the global bot
instance.
---
 bot/exts/backend/sync/_cog.py             |  9 +++------
 bot/exts/backend/sync/_syncers.py         | 24 ++++++++++++++----------
 tests/bot/exts/backend/sync/test_base.py  | 21 +++++++--------------
 tests/bot/exts/backend/sync/test_cog.py   | 18 ++++++++----------
 tests/bot/exts/backend/sync/test_roles.py | 20 ++++++++------------
 tests/bot/exts/backend/sync/test_users.py | 22 +++++++++-------------
 6 files changed, 49 insertions(+), 65 deletions(-)

diff --git a/bot/exts/backend/sync/_cog.py b/bot/exts/backend/sync/_cog.py
index b71ed3e69..48d2b6f02 100644
--- a/bot/exts/backend/sync/_cog.py
+++ b/bot/exts/backend/sync/_cog.py
@@ -18,9 +18,6 @@ class Sync(Cog):
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
-        self.role_syncer = _syncers.RoleSyncer()
-        self.user_syncer = _syncers.UserSyncer()
-
         self.bot.loop.create_task(self.sync_guild())
 
     async def sync_guild(self) -> None:
@@ -31,7 +28,7 @@ class Sync(Cog):
         if guild is None:
             return
 
-        for syncer in (self.role_syncer, self.user_syncer):
+        for syncer in (_syncers.RoleSyncer, _syncers.UserSyncer):
             await syncer.sync(guild)
 
     async def patch_user(self, user_id: int, json: Dict[str, Any], ignore_404: bool = False) -> None:
@@ -171,10 +168,10 @@ class Sync(Cog):
     @commands.has_permissions(administrator=True)
     async def sync_roles_command(self, ctx: Context) -> None:
         """Manually synchronise the guild's roles with the roles on the site."""
-        await self.role_syncer.sync(ctx.guild, ctx)
+        await _syncers.RoleSyncer.sync(ctx.guild, ctx)
 
     @sync_group.command(name='users')
     @commands.has_permissions(administrator=True)
     async def sync_users_command(self, ctx: Context) -> None:
         """Manually synchronise the guild's users with the users on the site."""
-        await self.user_syncer.sync(ctx.guild, ctx)
+        await _syncers.UserSyncer.sync(ctx.guild, ctx)
diff --git a/bot/exts/backend/sync/_syncers.py b/bot/exts/backend/sync/_syncers.py
index bdd76806b..2eb9f9971 100644
--- a/bot/exts/backend/sync/_syncers.py
+++ b/bot/exts/backend/sync/_syncers.py
@@ -17,12 +17,15 @@ _Role = namedtuple('Role', ('id', 'name', 'colour', 'permissions', 'position'))
 _Diff = namedtuple('Diff', ('created', 'updated', 'deleted'))
 
 
+# Implementation of static abstract methods are not enforced if the subclass is never instantiated.
+# However, methods are kept abstract to at least symbolise that they should be abstract.
 class Syncer(abc.ABC):
     """Base class for synchronising the database with objects in the Discord cache."""
 
+    @staticmethod
     @property
     @abc.abstractmethod
-    def name(self) -> str:
+    def name() -> str:
         """The name of the syncer; used in output messages and logging."""
         raise NotImplementedError  # pragma: no cover
 
@@ -38,35 +41,36 @@ class Syncer(abc.ABC):
         """Perform the API calls for synchronisation."""
         raise NotImplementedError  # pragma: no cover
 
-    async def sync(self, guild: Guild, ctx: t.Optional[Context] = None) -> None:
+    @classmethod
+    async def sync(cls, guild: Guild, ctx: t.Optional[Context] = None) -> None:
         """
         Synchronise the database with the cache of `guild`.
 
         If `ctx` is given, send a message with the results.
         """
-        log.info(f"Starting {self.name} syncer.")
+        log.info(f"Starting {cls.name} syncer.")
 
         if ctx:
-            message = await ctx.send(f"📊 Synchronising {self.name}s.")
+            message = await ctx.send(f"📊 Synchronising {cls.name}s.")
         else:
             message = None
-        diff = await self._get_diff(guild)
+        diff = await cls._get_diff(guild)
 
         try:
-            await self._sync(diff)
+            await cls._sync(diff)
         except ResponseCodeError as e:
-            log.exception(f"{self.name} syncer failed!")
+            log.exception(f"{cls.name} syncer failed!")
 
             # Don't show response text because it's probably some really long HTML.
             results = f"status {e.status}\n```{e.response_json or 'See log output for details'}```"
-            content = f":x: Synchronisation of {self.name}s failed: {results}"
+            content = f":x: Synchronisation of {cls.name}s failed: {results}"
         else:
             diff_dict = diff._asdict()
             results = (f"{name} `{len(val)}`" for name, val in diff_dict.items() if val is not None)
             results = ", ".join(results)
 
-            log.info(f"{self.name} syncer finished: {results}.")
-            content = f":ok_hand: Synchronisation of {self.name}s complete: {results}"
+            log.info(f"{cls.name} syncer finished: {results}.")
+            content = f":ok_hand: Synchronisation of {cls.name}s complete: {results}"
 
         if message:
             await message.edit(content=content)
diff --git a/tests/bot/exts/backend/sync/test_base.py b/tests/bot/exts/backend/sync/test_base.py
index 157d42452..3ad9db9c3 100644
--- a/tests/bot/exts/backend/sync/test_base.py
+++ b/tests/bot/exts/backend/sync/test_base.py
@@ -15,15 +15,6 @@ class TestSyncer(Syncer):
     _sync = mock.AsyncMock()
 
 
-class SyncerBaseTests(unittest.TestCase):
-    """Tests for the syncer base class."""
-
-    def test_instantiation_fails_without_abstract_methods(self):
-        """The class must have abstract methods implemented."""
-        with self.assertRaisesRegex(TypeError, "Can't instantiate abstract class"):
-            Syncer()
-
-
 class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for main function orchestrating the sync."""
 
@@ -32,11 +23,13 @@ class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = TestSyncer()
         self.guild = helpers.MockGuild()
 
+        TestSyncer._get_diff.reset_mock(return_value=True, side_effect=True)
+        TestSyncer._sync.reset_mock(return_value=True, side_effect=True)
+
         # Make sure `_get_diff` returns a MagicMock, not an AsyncMock
-        self.syncer._get_diff.return_value = mock.MagicMock()
+        TestSyncer._get_diff.return_value = mock.MagicMock()
 
     async def test_sync_message_edited(self):
         """The message should be edited if one was sent, even if the sync has an API error."""
@@ -48,11 +41,11 @@ class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         for message, side_effect, should_edit in subtests:
             with self.subTest(message=message, side_effect=side_effect, should_edit=should_edit):
-                self.syncer._sync.side_effect = side_effect
+                TestSyncer._sync.side_effect = side_effect
                 ctx = helpers.MockContext()
                 ctx.send.return_value = message
 
-                await self.syncer.sync(self.guild, ctx)
+                await TestSyncer.sync(self.guild, ctx)
 
                 if should_edit:
                     message.edit.assert_called_once()
@@ -67,7 +60,7 @@ class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         for ctx, message in subtests:
             with self.subTest(ctx=ctx, message=message):
-                await self.syncer.sync(self.guild, ctx)
+                await TestSyncer.sync(self.guild, ctx)
 
                 if ctx is not None:
                     ctx.send.assert_called_once()
diff --git a/tests/bot/exts/backend/sync/test_cog.py b/tests/bot/exts/backend/sync/test_cog.py
index 1e1883558..22a07313e 100644
--- a/tests/bot/exts/backend/sync/test_cog.py
+++ b/tests/bot/exts/backend/sync/test_cog.py
@@ -73,8 +73,6 @@ class SyncCogTests(SyncCogTestCase):
 
         Sync(self.bot)
 
-        self.RoleSyncer.assert_called_once_with()
-        self.UserSyncer.assert_called_once_with()
         sync_guild.assert_called_once_with()
         self.bot.loop.create_task.assert_called_once_with(mock_sync_guild_coro)
 
@@ -83,8 +81,8 @@ class SyncCogTests(SyncCogTestCase):
         for guild in (helpers.MockGuild(), None):
             with self.subTest(guild=guild):
                 self.bot.reset_mock()
-                self.cog.role_syncer.reset_mock()
-                self.cog.user_syncer.reset_mock()
+                self.RoleSyncer.reset_mock()
+                self.UserSyncer.reset_mock()
 
                 self.bot.get_guild = mock.MagicMock(return_value=guild)
 
@@ -94,11 +92,11 @@ class SyncCogTests(SyncCogTestCase):
                 self.bot.get_guild.assert_called_once_with(constants.Guild.id)
 
                 if guild is None:
-                    self.cog.role_syncer.sync.assert_not_called()
-                    self.cog.user_syncer.sync.assert_not_called()
+                    self.RoleSyncer.sync.assert_not_called()
+                    self.UserSyncer.sync.assert_not_called()
                 else:
-                    self.cog.role_syncer.sync.assert_called_once_with(guild)
-                    self.cog.user_syncer.sync.assert_called_once_with(guild)
+                    self.RoleSyncer.sync.assert_called_once_with(guild)
+                    self.UserSyncer.sync.assert_called_once_with(guild)
 
     async def patch_user_helper(self, side_effect: BaseException) -> None:
         """Helper to set a side effect for bot.api_client.patch and then assert it is called."""
@@ -394,14 +392,14 @@ class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
         ctx = helpers.MockContext()
         await self.cog.sync_roles_command(self.cog, ctx)
 
-        self.cog.role_syncer.sync.assert_called_once_with(ctx.guild, ctx)
+        self.RoleSyncer.sync.assert_called_once_with(ctx.guild, ctx)
 
     async def test_sync_users_command(self):
         """sync() should be called on the UserSyncer."""
         ctx = helpers.MockContext()
         await self.cog.sync_users_command(self.cog, ctx)
 
-        self.cog.user_syncer.sync.assert_called_once_with(ctx.guild, ctx)
+        self.UserSyncer.sync.assert_called_once_with(ctx.guild, ctx)
 
     async def test_commands_require_admin(self):
         """The sync commands should only run if the author has the administrator permission."""
diff --git a/tests/bot/exts/backend/sync/test_roles.py b/tests/bot/exts/backend/sync/test_roles.py
index fb63a4ae0..541074336 100644
--- a/tests/bot/exts/backend/sync/test_roles.py
+++ b/tests/bot/exts/backend/sync/test_roles.py
@@ -26,8 +26,6 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = RoleSyncer()
-
     @staticmethod
     def get_guild(*roles):
         """Fixture to return a guild object with the given roles."""
@@ -47,7 +45,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role()]
         guild = self.get_guild(fake_role())
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = (set(), set(), set())
 
         self.assertEqual(actual_diff, expected_diff)
@@ -59,7 +57,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role(id=41, name="old"), fake_role()]
         guild = self.get_guild(updated_role, fake_role())
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = (set(), {_Role(**updated_role)}, set())
 
         self.assertEqual(actual_diff, expected_diff)
@@ -71,7 +69,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role()]
         guild = self.get_guild(fake_role(), new_role)
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = ({_Role(**new_role)}, set(), set())
 
         self.assertEqual(actual_diff, expected_diff)
@@ -83,7 +81,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role(), deleted_role]
         guild = self.get_guild(fake_role())
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = (set(), set(), {_Role(**deleted_role)})
 
         self.assertEqual(actual_diff, expected_diff)
@@ -101,7 +99,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         ]
         guild = self.get_guild(fake_role(), new, updated)
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = ({_Role(**new)}, {_Role(**updated)}, {_Role(**deleted)})
 
         self.assertEqual(actual_diff, expected_diff)
@@ -115,15 +113,13 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = RoleSyncer()
-
     async def test_sync_created_roles(self):
         """Only POST requests should be made with the correct payload."""
         roles = [fake_role(id=111), fake_role(id=222)]
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(role_tuples, set(), set())
-        await self.syncer._sync(diff)
+        await RoleSyncer._sync(diff)
 
         calls = [mock.call("bot/roles", json=role) for role in roles]
         self.bot.api_client.post.assert_has_calls(calls, any_order=True)
@@ -138,7 +134,7 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(set(), role_tuples, set())
-        await self.syncer._sync(diff)
+        await RoleSyncer._sync(diff)
 
         calls = [mock.call(f"bot/roles/{role['id']}", json=role) for role in roles]
         self.bot.api_client.put.assert_has_calls(calls, any_order=True)
@@ -153,7 +149,7 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(set(), set(), role_tuples)
-        await self.syncer._sync(diff)
+        await RoleSyncer._sync(diff)
 
         calls = [mock.call(f"bot/roles/{role['id']}") for role in roles]
         self.bot.api_client.delete.assert_has_calls(calls, any_order=True)
diff --git a/tests/bot/exts/backend/sync/test_users.py b/tests/bot/exts/backend/sync/test_users.py
index 9f28d0162..61673e1bb 100644
--- a/tests/bot/exts/backend/sync/test_users.py
+++ b/tests/bot/exts/backend/sync/test_users.py
@@ -24,8 +24,6 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = UserSyncer()
-
     @staticmethod
     def get_guild(*members):
         """Fixture to return a guild object with the given members."""
@@ -61,7 +59,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         }
         guild = self.get_guild()
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -77,7 +75,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         guild = self.get_guild(fake_user())
 
         guild.get_member.return_value = self.get_mock_member(fake_user())
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -98,7 +96,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             self.get_mock_member(fake_user())
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [{"id": 99, "name": "new"}], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -118,7 +116,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             self.get_mock_member(fake_user()),
             self.get_mock_member(new_user)
         ]
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([new_user], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -137,7 +135,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             None
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [{"id": 63, "in_guild": False}], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -161,7 +159,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             None
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([new_user], [{"id": 55, "name": "updated"}, {"id": 63, "in_guild": False}], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -180,7 +178,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             None
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -194,14 +192,12 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = UserSyncer()
-
     async def test_sync_created_users(self):
         """Only POST requests should be made with the correct payload."""
         users = [fake_user(id=111), fake_user(id=222)]
 
         diff = _Diff(users, [], None)
-        await self.syncer._sync(diff)
+        await UserSyncer._sync(diff)
 
         self.bot.api_client.post.assert_called_once_with("bot/users", json=diff.created)
 
@@ -213,7 +209,7 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         users = [fake_user(id=111), fake_user(id=222)]
 
         diff = _Diff([], users, None)
-        await self.syncer._sync(diff)
+        await UserSyncer._sync(diff)
 
         self.bot.api_client.patch.assert_called_once_with("bot/users/bulk_patch", json=diff.updated)
 
-- 
cgit v1.2.3


From 2bfe55cf484e9e2d6065ea693590d45653820821 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 17 Oct 2020 19:10:15 -0700
Subject: Move logging set up to a separate module

---
 .gitignore       |  1 +
 bot/__init__.py  | 64 ++---------------------------------------
 bot/__main__.py  | 19 -------------
 bot/bot.py       |  4 +--
 bot/constants.py |  2 +-
 bot/log.py       | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 93 insertions(+), 83 deletions(-)
 create mode 100644 bot/log.py

diff --git a/.gitignore b/.gitignore
index 2074887ad..9186dbe06 100644
--- a/.gitignore
+++ b/.gitignore
@@ -111,6 +111,7 @@ ENV/
 # Logfiles
 log.*
 *.log.*
+!log.py
 
 # Custom user configuration
 config.yml
diff --git a/bot/__init__.py b/bot/__init__.py
index 0642b2c5d..d2fd107a0 100644
--- a/bot/__init__.py
+++ b/bot/__init__.py
@@ -1,81 +1,23 @@
 import asyncio
-import logging
 import os
-import sys
 from functools import partial, partialmethod
-from logging import Logger, handlers
-from pathlib import Path
 from typing import TYPE_CHECKING
 
-import coloredlogs
 from discord.ext import commands
 
+from bot import log
 from bot.command import Command
 
 if TYPE_CHECKING:
     from bot.bot import Bot
 
-TRACE_LEVEL = logging.TRACE = 5
-logging.addLevelName(TRACE_LEVEL, "TRACE")
-
-
-def monkeypatch_trace(self: logging.Logger, msg: str, *args, **kwargs) -> None:
-    """
-    Log 'msg % args' with severity 'TRACE'.
-
-    To pass exception information, use the keyword argument exc_info with
-    a true value, e.g.
-
-    logger.trace("Houston, we have an %s", "interesting problem", exc_info=1)
-    """
-    if self.isEnabledFor(TRACE_LEVEL):
-        self._log(TRACE_LEVEL, msg, args, **kwargs)
-
-
-Logger.trace = monkeypatch_trace
-
-DEBUG_MODE = 'local' in os.environ.get("SITE_URL", "local")
-
-log_level = TRACE_LEVEL if DEBUG_MODE else logging.INFO
-format_string = "%(asctime)s | %(name)s | %(levelname)s | %(message)s"
-log_format = logging.Formatter(format_string)
-
-log_file = Path("logs", "bot.log")
-log_file.parent.mkdir(exist_ok=True)
-file_handler = handlers.RotatingFileHandler(log_file, maxBytes=5242880, backupCount=7, encoding="utf8")
-file_handler.setFormatter(log_format)
-
-root_log = logging.getLogger()
-root_log.setLevel(log_level)
-root_log.addHandler(file_handler)
-
-if "COLOREDLOGS_LEVEL_STYLES" not in os.environ:
-    coloredlogs.DEFAULT_LEVEL_STYLES = {
-        **coloredlogs.DEFAULT_LEVEL_STYLES,
-        "trace": {"color": 246},
-        "critical": {"background": "red"},
-        "debug": coloredlogs.DEFAULT_LEVEL_STYLES["info"]
-    }
-
-if "COLOREDLOGS_LOG_FORMAT" not in os.environ:
-    coloredlogs.DEFAULT_LOG_FORMAT = format_string
-
-if "COLOREDLOGS_LOG_LEVEL" not in os.environ:
-    coloredlogs.DEFAULT_LOG_LEVEL = log_level
-
-coloredlogs.install(logger=root_log, stream=sys.stdout)
-
-logging.getLogger("discord").setLevel(logging.WARNING)
-logging.getLogger("websockets").setLevel(logging.WARNING)
-logging.getLogger("chardet").setLevel(logging.WARNING)
-logging.getLogger(__name__)
-
+log.setup()
+log.setup_sentry()
 
 # On Windows, the selector event loop is required for aiodns.
 if os.name == "nt":
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
-
 # Monkey-patch discord.py decorators to use the Command subclass which supports root aliases.
 # Must be patched before any cogs are added.
 commands.command = partial(commands.command, cls=Command)
diff --git a/bot/__main__.py b/bot/__main__.py
index 9d48c9092..f3204c18a 100644
--- a/bot/__main__.py
+++ b/bot/__main__.py
@@ -1,33 +1,14 @@
 import asyncio
-import logging
 
 import discord
-import sentry_sdk
 from async_rediscache import RedisSession
 from discord.ext.commands import when_mentioned_or
-from sentry_sdk.integrations.aiohttp import AioHttpIntegration
-from sentry_sdk.integrations.logging import LoggingIntegration
-from sentry_sdk.integrations.redis import RedisIntegration
 
 import bot
 from bot import constants
 from bot.bot import Bot
 from bot.utils.extensions import EXTENSIONS
 
-# Set up Sentry.
-sentry_logging = LoggingIntegration(
-    level=logging.DEBUG,
-    event_level=logging.WARNING
-)
-
-sentry_sdk.init(
-    dsn=constants.Bot.sentry_dsn,
-    integrations=[
-        sentry_logging,
-        AioHttpIntegration(),
-        RedisIntegration(),
-    ]
-)
 
 # Create the redis session instance.
 redis_session = RedisSession(
diff --git a/bot/bot.py b/bot/bot.py
index b2e5237fe..892bb3325 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -11,7 +11,7 @@ from async_rediscache import RedisSession
 from discord.ext import commands
 from sentry_sdk import push_scope
 
-from bot import DEBUG_MODE, api, constants
+from bot import api, constants
 from bot.async_stats import AsyncStatsClient
 
 log = logging.getLogger('bot')
@@ -40,7 +40,7 @@ class Bot(commands.Bot):
 
         statsd_url = constants.Stats.statsd_host
 
-        if DEBUG_MODE:
+        if constants.DEBUG_MODE:
             # Since statsd is UDP, there are no errors for sending to a down port.
             # For this reason, setting the statsd host to 127.0.0.1 for development
             # will effectively disable stats.
diff --git a/bot/constants.py b/bot/constants.py
index 6c8b933af..3bc25e767 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -614,7 +614,7 @@ class Event(Enum):
 
 
 # Debug mode
-DEBUG_MODE = True if 'local' in os.environ.get("SITE_URL", "local") else False
+DEBUG_MODE = 'local' in os.environ.get("SITE_URL", "local")
 
 # Paths
 BOT_DIR = os.path.dirname(__file__)
diff --git a/bot/log.py b/bot/log.py
new file mode 100644
index 000000000..5583c7070
--- /dev/null
+++ b/bot/log.py
@@ -0,0 +1,86 @@
+import logging
+import os
+import sys
+from logging import Logger, handlers
+from pathlib import Path
+
+import coloredlogs
+import sentry_sdk
+from sentry_sdk.integrations.aiohttp import AioHttpIntegration
+from sentry_sdk.integrations.logging import LoggingIntegration
+from sentry_sdk.integrations.redis import RedisIntegration
+
+from bot import constants
+
+TRACE_LEVEL = 5
+
+
+def setup() -> None:
+    """Set up loggers."""
+    logging.TRACE = TRACE_LEVEL
+    logging.addLevelName(TRACE_LEVEL, "TRACE")
+    Logger.trace = _monkeypatch_trace
+
+    log_level = TRACE_LEVEL if constants.DEBUG_MODE else logging.INFO
+    format_string = "%(asctime)s | %(name)s | %(levelname)s | %(message)s"
+    log_format = logging.Formatter(format_string)
+
+    log_file = Path("logs", "bot.log")
+    log_file.parent.mkdir(exist_ok=True)
+    file_handler = handlers.RotatingFileHandler(log_file, maxBytes=5242880, backupCount=7, encoding="utf8")
+    file_handler.setFormatter(log_format)
+
+    root_log = logging.getLogger()
+    root_log.setLevel(log_level)
+    root_log.addHandler(file_handler)
+
+    if "COLOREDLOGS_LEVEL_STYLES" not in os.environ:
+        coloredlogs.DEFAULT_LEVEL_STYLES = {
+            **coloredlogs.DEFAULT_LEVEL_STYLES,
+            "trace": {"color": 246},
+            "critical": {"background": "red"},
+            "debug": coloredlogs.DEFAULT_LEVEL_STYLES["info"]
+        }
+
+    if "COLOREDLOGS_LOG_FORMAT" not in os.environ:
+        coloredlogs.DEFAULT_LOG_FORMAT = format_string
+
+    if "COLOREDLOGS_LOG_LEVEL" not in os.environ:
+        coloredlogs.DEFAULT_LOG_LEVEL = log_level
+
+    coloredlogs.install(logger=root_log, stream=sys.stdout)
+
+    logging.getLogger("discord").setLevel(logging.WARNING)
+    logging.getLogger("websockets").setLevel(logging.WARNING)
+    logging.getLogger("chardet").setLevel(logging.WARNING)
+    logging.getLogger(__name__)
+
+
+def setup_sentry() -> None:
+    """Set up the Sentry logging integrations."""
+    sentry_logging = LoggingIntegration(
+        level=logging.DEBUG,
+        event_level=logging.WARNING
+    )
+
+    sentry_sdk.init(
+        dsn=constants.Bot.sentry_dsn,
+        integrations=[
+            sentry_logging,
+            AioHttpIntegration(),
+            RedisIntegration(),
+        ]
+    )
+
+
+def _monkeypatch_trace(self: logging.Logger, msg: str, *args, **kwargs) -> None:
+    """
+    Log 'msg % args' with severity 'TRACE'.
+
+    To pass exception information, use the keyword argument exc_info with
+    a true value, e.g.
+
+    logger.trace("Houston, we have an %s", "interesting problem", exc_info=1)
+    """
+    if self.isEnabledFor(TRACE_LEVEL):
+        self._log(TRACE_LEVEL, msg, args, **kwargs)
-- 
cgit v1.2.3


From 9676866990523266d39fc26c4fe6bfa28a8ca9e4 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 17 Oct 2020 19:57:29 -0700
Subject: Move bot creation code from __main__.py to bot.py

---
 bot/__main__.py | 55 ++-----------------------------------------------------
 bot/bot.py      | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 53 deletions(-)

diff --git a/bot/__main__.py b/bot/__main__.py
index f3204c18a..9847c1849 100644
--- a/bot/__main__.py
+++ b/bot/__main__.py
@@ -1,58 +1,7 @@
-import asyncio
-
-import discord
-from async_rediscache import RedisSession
-from discord.ext.commands import when_mentioned_or
-
 import bot
 from bot import constants
 from bot.bot import Bot
-from bot.utils.extensions import EXTENSIONS
-
-
-# Create the redis session instance.
-redis_session = RedisSession(
-    address=(constants.Redis.host, constants.Redis.port),
-    password=constants.Redis.password,
-    minsize=1,
-    maxsize=20,
-    use_fakeredis=constants.Redis.use_fakeredis,
-    global_namespace="bot",
-)
-
-# Connect redis session to ensure it's connected before we try to access Redis
-# from somewhere within the bot. We create the event loop in the same way
-# discord.py normally does and pass it to the bot's __init__.
-loop = asyncio.get_event_loop()
-loop.run_until_complete(redis_session.connect())
-
-
-# Instantiate the bot.
-allowed_roles = [discord.Object(id_) for id_ in constants.MODERATION_ROLES]
-intents = discord.Intents().all()
-intents.presences = False
-intents.dm_typing = False
-intents.dm_reactions = False
-intents.invites = False
-intents.webhooks = False
-intents.integrations = False
-bot.instance = Bot(
-    redis_session=redis_session,
-    loop=loop,
-    command_prefix=when_mentioned_or(constants.Bot.prefix),
-    activity=discord.Game(name=f"Commands: {constants.Bot.prefix}help"),
-    case_insensitive=True,
-    max_messages=10_000,
-    allowed_mentions=discord.AllowedMentions(everyone=False, roles=allowed_roles),
-    intents=intents,
-)
-
-# Load extensions.
-extensions = set(EXTENSIONS)  # Create a mutable copy.
-if not constants.HelpChannels.enable:
-    extensions.remove("bot.exts.help_channels")
-
-for extension in extensions:
-    bot.instance.load_extension(extension)
 
+bot.instance = Bot.create()
+bot.instance.load_extensions()
 bot.instance.run(constants.Bot.token)
diff --git a/bot/bot.py b/bot/bot.py
index 892bb3325..36cf7d30a 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -95,6 +95,43 @@ class Bot(commands.Bot):
         # Build the FilterList cache
         self.loop.create_task(self.cache_filter_list_data())
 
+    @classmethod
+    def create(cls) -> "Bot":
+        """Create and return an instance of a Bot."""
+        loop = asyncio.get_event_loop()
+        allowed_roles = [discord.Object(id_) for id_ in constants.MODERATION_ROLES]
+
+        intents = discord.Intents().all()
+        intents.presences = False
+        intents.dm_typing = False
+        intents.dm_reactions = False
+        intents.invites = False
+        intents.webhooks = False
+        intents.integrations = False
+
+        return cls(
+            redis_session=_create_redis_session(loop),
+            loop=loop,
+            command_prefix=commands.when_mentioned_or(constants.Bot.prefix),
+            activity=discord.Game(name=f"Commands: {constants.Bot.prefix}help"),
+            case_insensitive=True,
+            max_messages=10_000,
+            allowed_mentions=discord.AllowedMentions(everyone=False, roles=allowed_roles),
+            intents=intents,
+        )
+
+    def load_extensions(self) -> None:
+        """Load all enabled extensions."""
+        # Must be done here to avoid a circular import.
+        from bot.utils.extensions import EXTENSIONS
+
+        extensions = set(EXTENSIONS)  # Create a mutable copy.
+        if not constants.HelpChannels.enable:
+            extensions.remove("bot.exts.help_channels")
+
+        for extension in extensions:
+            self.load_extension(extension)
+
     def add_cog(self, cog: commands.Cog) -> None:
         """Adds a "cog" to the bot and logs the operation."""
         super().add_cog(cog)
@@ -243,3 +280,22 @@ class Bot(commands.Bot):
 
         for alias in getattr(command, "root_aliases", ()):
             self.all_commands.pop(alias, None)
+
+
+def _create_redis_session(loop: asyncio.AbstractEventLoop) -> RedisSession:
+    """
+    Create and connect to a redis session.
+
+    Ensure the connection is established before returning to prevent race conditions.
+    `loop` is the event loop on which to connect. The Bot should use this same event loop.
+    """
+    redis_session = RedisSession(
+        address=(constants.Redis.host, constants.Redis.port),
+        password=constants.Redis.password,
+        minsize=1,
+        maxsize=20,
+        use_fakeredis=constants.Redis.use_fakeredis,
+        global_namespace="bot",
+    )
+    loop.run_until_complete(redis_session.connect())
+    return redis_session
-- 
cgit v1.2.3


From e18b5903d13f0bfd98e71627fde32d0a79397981 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 17 Oct 2020 20:33:10 -0700
Subject: Set up Sentry when running rather than upon import

It was causing an error if a DSN was not configured. It also feels wrong
and confusing to attempt to make a connection just upon import.
---
 bot/__init__.py | 1 -
 bot/__main__.py | 3 +++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/bot/__init__.py b/bot/__init__.py
index d2fd107a0..8f880b8e6 100644
--- a/bot/__init__.py
+++ b/bot/__init__.py
@@ -12,7 +12,6 @@ if TYPE_CHECKING:
     from bot.bot import Bot
 
 log.setup()
-log.setup_sentry()
 
 # On Windows, the selector event loop is required for aiodns.
 if os.name == "nt":
diff --git a/bot/__main__.py b/bot/__main__.py
index 9847c1849..257216fa7 100644
--- a/bot/__main__.py
+++ b/bot/__main__.py
@@ -1,6 +1,9 @@
 import bot
 from bot import constants
 from bot.bot import Bot
+from bot.log import setup_sentry
+
+setup_sentry()
 
 bot.instance = Bot.create()
 bot.instance.load_extensions()
-- 
cgit v1.2.3


From acb6d737736409d0659aa474b44b7389f1915f34 Mon Sep 17 00:00:00 2001
From: kosayoda <kieransiek@protonmail.com>
Date: Tue, 20 Oct 2020 15:08:45 +0800
Subject: Make `additional_info` non-optional.

The `Optional` typehint suggests allowing None as a value, which does not
make sense as a message in the logs.
---
 bot/exts/moderation/infraction/_scheduler.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/_scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index 5c3e445f6..dd19195bf 100644
--- a/bot/exts/moderation/infraction/_scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -83,7 +83,7 @@ class InfractionScheduler:
         user: UserSnowflake,
         action_coro: t.Optional[t.Awaitable] = None,
         user_reason: t.Optional[str] = None,
-        additional_info: t.Optional[str] = "",
+        additional_info: str = "",
     ) -> bool:
         """
         Apply an infraction to the user, log the infraction, and optionally notify the user.
-- 
cgit v1.2.3


From 9bc3e5b522ea7c7d6889337f347447e98db07d2e Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Fri, 30 Oct 2020 15:09:21 -0500
Subject: Added method definition and needed imports.

Signed-off-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index c2743e136..4753719ce 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -5,7 +5,7 @@ from datetime import datetime, timedelta
 
 import discord
 from dateutil import parser
-from discord import Colour
+from discord import Colour, Member, VoiceState
 from discord.ext.commands import Cog, Context, command
 
 from bot.api import ResponseCodeError
@@ -157,6 +157,10 @@ class VoiceGate(Cog):
         with suppress(discord.NotFound):
             await message.delete()
 
+    @Cog.listener()
+    async def on_voice_state_update(self, member: Member, before: VoiceState, after: VoiceState):
+        pass
+
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
         if isinstance(error, InWhitelistCheckFailure):
-- 
cgit v1.2.3


From 4eccdefc415bf4da4fbf4fbe6a70c3b3abff4fc8 Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Mon, 2 Nov 2020 15:43:35 -0600
Subject: Added RedisCache and event

- Added RedisCache instance as a class attribute of the VoiceGate cog.
- Added voice_gate channel as an attribute to use it later in the cog.
- Added cache type hint.

Signed-off-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 4753719ce..6636bc3ce 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -4,8 +4,9 @@ from contextlib import suppress
 from datetime import datetime, timedelta
 
 import discord
+from async_rediscache import RedisCache
 from dateutil import parser
-from discord import Colour, Member, VoiceState
+from discord import Colour, Member
 from discord.ext.commands import Cog, Context, command
 
 from bot.api import ResponseCodeError
@@ -31,8 +32,16 @@ MESSAGE_FIELD_MAP = {
 class VoiceGate(Cog):
     """Voice channels verification management."""
 
-    def __init__(self, bot: Bot):
+    # RedisCache[t.Union[discord.User.id, discord.Member.id], t.Optional[discord.Message.id]]
+    redis_cache = RedisCache()
+
+    def __init__(self, bot: Bot) -> None:
         self.bot = bot
+        self._init_task = self.bot.loop.create_task(self._async_init())
+
+    async def _aysnc_init(self) -> None:
+        await self.bot.wait_until_guild_available()
+        self._voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
 
     @property
     def mod_log(self) -> ModLog:
@@ -158,8 +167,18 @@ class VoiceGate(Cog):
             await message.delete()
 
     @Cog.listener()
-    async def on_voice_state_update(self, member: Member, before: VoiceState, after: VoiceState):
-        pass
+    async def on_voice_state_update(self, member: Member, *_) -> None:
+        """Pings a user if they've never joined the voice chat before and aren't verified"""
+
+        in_cache = await self.redis_cache.get(member.id)
+
+        # member.voice will return None if the user is not in a voice channel
+        if not in_cache and member.voice is not None:
+            log.trace("User not in cache and is in a voice channel")
+            verified = any(Roles.voice_verified == role.id for role in member.roles)
+            if verified:
+                await self.redis_cache.set(member.id, None)
+                return
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
-- 
cgit v1.2.3


From 2a31370dfd0b03fdd117a1457fd691ac644cb470 Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Mon, 2 Nov 2020 17:09:57 -0600
Subject: Added ping message, message id storage and message deletion

- Users who have never joined the voice channels before (and are currently unverified) will receive a ping in the #voice_verification channel

- If user is unverified, the message id is stored in the cache along with the user id.

- Added a message deletion to the voiceverify command, which removes the ping message if one exists. Also sets stored message ID to None so that it doesn't attempt to delete messages that aren't there

- Set timed message deletion for 5 minutes.
---
 bot/exts/moderation/voice_gate.py | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 6636bc3ce..9fc77e5bb 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -60,6 +60,13 @@ class VoiceGate(Cog):
         - You must have accepted our rules over a certain number of days ago
         - You must not be actively banned from using our voice channels
         """
+
+        # If user has received a ping in voice_verification, delete the message
+        if message_id := self.redis_cache.get(ctx.author.id, None) is not None:
+            ping_message = await ctx.channel.fetch_message(message_id)
+            await ping_message.delete()
+            await self.redis_cache.update(ctx.author.id, None)
+
         try:
             data = await self.bot.api_client.get(f"bot/users/{ctx.author.id}/metricity_data")
         except ResponseCodeError as e:
@@ -170,6 +177,10 @@ class VoiceGate(Cog):
     async def on_voice_state_update(self, member: Member, *_) -> None:
         """Pings a user if they've never joined the voice chat before and aren't verified"""
 
+        if member.bot:
+            log.trace("User is a bot. Ignore.")
+            return
+
         in_cache = await self.redis_cache.get(member.id)
 
         # member.voice will return None if the user is not in a voice channel
@@ -177,9 +188,21 @@ class VoiceGate(Cog):
             log.trace("User not in cache and is in a voice channel")
             verified = any(Roles.voice_verified == role.id for role in member.roles)
             if verified:
+                log.trace("User is verified, add to the cache and ignore")
                 await self.redis_cache.set(member.id, None)
                 return
 
+            log.trace("User is unverified. Send ping.")
+            message = self._voice_verification_channel.send(
+                f"Hello, {member.mention}! Wondering why you can't talk in the voice channels? "
+                "Use the `!voiceverify` command in here to verify. "
+                "If you don't yet qualify, you'll be told why!"
+            )
+            await self.redis_cache.set(member.id, message.id)
+
+            # Message will try to be deleted after 5 minutes. If it fails, it'll do so silently
+            await message.delete(delay=300)
+
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
         if isinstance(error, InWhitelistCheckFailure):
-- 
cgit v1.2.3


From a6a2ba631be9865bef8832fa29dc949f7255b1c8 Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Tue, 3 Nov 2020 16:00:27 -0600
Subject: Bug fixes, including improper cache calls, typos and more

- Corrected spelling on _async_init call
- Changed the None value stored in the cache if the user is already verified to False, as RedisCache doesn't support None.
- Changed RedisCache type hint to reflect change made in storage style
- Suppress NotFound errors when the ping_message can't be retrieved.
- Corrected lack of await on send call

More fixes to come.

Signed-off-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 9fc77e5bb..95130fbfc 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -32,14 +32,14 @@ MESSAGE_FIELD_MAP = {
 class VoiceGate(Cog):
     """Voice channels verification management."""
 
-    # RedisCache[t.Union[discord.User.id, discord.Member.id], t.Optional[discord.Message.id]]
+    # RedisCache[t.Union[discord.User.id, discord.Member.id], t.Union[discord.Message.id, bool]]
     redis_cache = RedisCache()
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
         self._init_task = self.bot.loop.create_task(self._async_init())
 
-    async def _aysnc_init(self) -> None:
+    async def _async_init(self) -> None:
         await self.bot.wait_until_guild_available()
         self._voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
 
@@ -62,10 +62,11 @@ class VoiceGate(Cog):
         """
 
         # If user has received a ping in voice_verification, delete the message
-        if message_id := self.redis_cache.get(ctx.author.id, None) is not None:
-            ping_message = await ctx.channel.fetch_message(message_id)
-            await ping_message.delete()
-            await self.redis_cache.update(ctx.author.id, None)
+        if message_id := await self.redis_cache.get(ctx.author.id, None):
+            with suppress(discord.NotFound):
+                ping_message = await ctx.channel.fetch_message(message_id)
+                await ping_message.delete()
+            await self.redis_cache.set(ctx.author.id, False)
 
         try:
             data = await self.bot.api_client.get(f"bot/users/{ctx.author.id}/metricity_data")
@@ -181,19 +182,20 @@ class VoiceGate(Cog):
             log.trace("User is a bot. Ignore.")
             return
 
-        in_cache = await self.redis_cache.get(member.id)
+        in_cache = await self.redis_cache.get(member.id, None)
 
         # member.voice will return None if the user is not in a voice channel
-        if not in_cache and member.voice is not None:
+        if in_cache is not None and member.voice is not None:
             log.trace("User not in cache and is in a voice channel")
             verified = any(Roles.voice_verified == role.id for role in member.roles)
             if verified:
                 log.trace("User is verified, add to the cache and ignore")
-                await self.redis_cache.set(member.id, None)
+                #  redis cache does not accept None, so False is used to signify no message
+                await self.redis_cache.set(member.id, False)
                 return
 
             log.trace("User is unverified. Send ping.")
-            message = self._voice_verification_channel.send(
+            message = await self._voice_verification_channel.send(
                 f"Hello, {member.mention}! Wondering why you can't talk in the voice channels? "
                 "Use the `!voiceverify` command in here to verify. "
                 "If you don't yet qualify, you'll be told why!"
-- 
cgit v1.2.3


From bf7916a3e197540420167fd82cd2de269ff52624 Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Thu, 5 Nov 2020 14:08:45 -0600
Subject: - Added ping deletion time to config file. - Added ping message
 constant to the top of the voice_gate.py file. - Corrected logic error in
 checking if a user is cached and in a voice channel. - Reduced default
 message deletion time to 1 minute from 5 minutes. - Adjusted on_message event
 to ignore the verification ping message.

Signed-off-by: Daniel Brown <browndj3@gmail.com>
---
 bot/constants.py                  |  1 +
 bot/exts/moderation/voice_gate.py | 26 +++++++++++++++++---------
 config-default.yml                |  1 +
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/bot/constants.py b/bot/constants.py
index 23d5b4304..db8b5f0a0 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -600,6 +600,7 @@ class VoiceGate(metaclass=YAMLGetter):
     minimum_days_verified: int
     minimum_messages: int
     bot_message_delete_delay: int
+    voice_ping_delete_delay: int
 
 
 class Event(Enum):
diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 95130fbfc..56e0149e0 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -28,6 +28,12 @@ MESSAGE_FIELD_MAP = {
     "total_messages": f"have sent less than {GateConf.minimum_messages} messages",
 }
 
+VOICE_PING = (
+    "Hello, {}! Wondering why you can't talk in the voice channels? "
+    "Use the `!voiceverify` command in here to verify. "
+    "If you don't yet qualify, you'll be told why!"
+)
+
 
 class VoiceGate(Cog):
     """Voice channels verification management."""
@@ -158,6 +164,10 @@ class VoiceGate(Cog):
 
         # When it's bot sent message, delete it after some time
         if message.author.bot:
+            # Comparing the message with the voice ping constant
+            if message.content.endswith(VOICE_PING[-45:]):
+                log.trace("Message is the voice verification ping. Ignore.")
+                return
             with suppress(discord.NotFound):
                 await message.delete(delay=GateConf.bot_message_delete_delay)
                 return
@@ -177,7 +187,6 @@ class VoiceGate(Cog):
     @Cog.listener()
     async def on_voice_state_update(self, member: Member, *_) -> None:
         """Pings a user if they've never joined the voice chat before and aren't verified"""
-
         if member.bot:
             log.trace("User is a bot. Ignore.")
             return
@@ -185,7 +194,7 @@ class VoiceGate(Cog):
         in_cache = await self.redis_cache.get(member.id, None)
 
         # member.voice will return None if the user is not in a voice channel
-        if in_cache is not None and member.voice is not None:
+        if in_cache is None and member.voice is not None:
             log.trace("User not in cache and is in a voice channel")
             verified = any(Roles.voice_verified == role.id for role in member.roles)
             if verified:
@@ -195,15 +204,14 @@ class VoiceGate(Cog):
                 return
 
             log.trace("User is unverified. Send ping.")
-            message = await self._voice_verification_channel.send(
-                f"Hello, {member.mention}! Wondering why you can't talk in the voice channels? "
-                "Use the `!voiceverify` command in here to verify. "
-                "If you don't yet qualify, you'll be told why!"
-            )
+            message = await self._voice_verification_channel.send(VOICE_PING.format(member.mention))
             await self.redis_cache.set(member.id, message.id)
 
-            # Message will try to be deleted after 5 minutes. If it fails, it'll do so silently
-            await message.delete(delay=300)
+            # Message will try to be deleted after 1 minutes. If it fails, it'll do so silently
+            await message.delete(delay=GateConf.voice_ping_delete_delay)
+        else:
+            log.trace("User is either in the cache or not in a voice channel. Ignore.")
+            return
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
diff --git a/config-default.yml b/config-default.yml
index 071f6e1ec..058efa9ad 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -521,6 +521,7 @@ voice_gate:
     minimum_days_verified: 3  # How many days the user must have been verified for
     minimum_messages: 50  # How many messages a user must have to be eligible for voice
     bot_message_delete_delay: 10  # Seconds before deleting bot's response in Voice Gate
+    voice_ping_delete_delay: 60 # Seconds before deleting the bot's ping to user in Voice Gate
 
 
 config:
-- 
cgit v1.2.3


From 30d38743aeffd1cb3bab508bb5f4e4ffd9c0a650 Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Thu, 5 Nov 2020 15:53:23 -0600
Subject: Corrected linting errors.

Signed-off-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 56e0149e0..d3187fdbf 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -29,7 +29,7 @@ MESSAGE_FIELD_MAP = {
 }
 
 VOICE_PING = (
-    "Hello, {}! Wondering why you can't talk in the voice channels? "
+    "Hello, {0}! Wondering why you can't talk in the voice channels? "
     "Use the `!voiceverify` command in here to verify. "
     "If you don't yet qualify, you'll be told why!"
 )
@@ -66,7 +66,6 @@ class VoiceGate(Cog):
         - You must have accepted our rules over a certain number of days ago
         - You must not be actively banned from using our voice channels
         """
-
         # If user has received a ping in voice_verification, delete the message
         if message_id := await self.redis_cache.get(ctx.author.id, None):
             with suppress(discord.NotFound):
@@ -186,7 +185,7 @@ class VoiceGate(Cog):
 
     @Cog.listener()
     async def on_voice_state_update(self, member: Member, *_) -> None:
-        """Pings a user if they've never joined the voice chat before and aren't verified"""
+        """Pings a user if they've never joined the voice chat before and aren't verified."""
         if member.bot:
             log.trace("User is a bot. Ignore.")
             return
-- 
cgit v1.2.3


From ec019d5d012f178acc2d9de756f694d534d71e1f Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Fri, 6 Nov 2020 13:28:04 -0600
Subject: Requested fixes - Various restructures of code.

- Changed `VOICE_PING` constant to not contain the format brackets.
- Added more detailed description of what the `redis_cache` will hold.
- Changed message content verification to use the whole newly formatted `VOICE_PING` constant instead of a slice of it.
- Added remaining parameters for the `on_voice_state_update` event for clarity.
- Reorganized the logic of the `on_voice_state_update` for better clarity and better logging purposes.
- Removed `_async_init` in favor of checking if the guild is ready inside the `on_voice_state_update` event. Verification channel is now loaded each time when needed, reducing risk of the object becoming stale or erroring out due to the not being ready before an event was triggered.

Signed-off-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 64 ++++++++++++++++++++++-----------------
 config-default.yml                |  2 +-
 2 files changed, 37 insertions(+), 29 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 6bcca2874..eba05901f 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -30,7 +30,7 @@ MESSAGE_FIELD_MAP = {
 }
 
 VOICE_PING = (
-    "Hello, {0}! Wondering why you can't talk in the voice channels? "
+    "Wondering why you can't talk in the voice channels? "
     "Use the `!voiceverify` command in here to verify. "
     "If you don't yet qualify, you'll be told why!"
 )
@@ -40,15 +40,12 @@ class VoiceGate(Cog):
     """Voice channels verification management."""
 
     # RedisCache[t.Union[discord.User.id, discord.Member.id], t.Union[discord.Message.id, bool]]
+    # The cache's keys are the IDs of members who are verified or have joined a voice channel
+    # The cache's values are either the message ID of the ping message or False if no message is present
     redis_cache = RedisCache()
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
-        self._init_task = self.bot.loop.create_task(self._async_init())
-
-    async def _async_init(self) -> None:
-        await self.bot.wait_until_guild_available()
-        self._voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
 
     @property
     def mod_log(self) -> ModLog:
@@ -164,10 +161,10 @@ class VoiceGate(Cog):
         ctx = await self.bot.get_context(message)
         is_verify_command = ctx.command is not None and ctx.command.name == "voice_verify"
 
-        # When it's bot sent message, delete it after some time
+        # When it's a bot sent message, delete it after some time
         if message.author.bot:
             # Comparing the message with the voice ping constant
-            if message.content.endswith(VOICE_PING[-45:]):
+            if message.content.endswith(VOICE_PING):
                 log.trace("Message is the voice verification ping. Ignore.")
                 return
             with suppress(discord.NotFound):
@@ -187,33 +184,44 @@ class VoiceGate(Cog):
             await message.delete()
 
     @Cog.listener()
-    async def on_voice_state_update(self, member: Member, *_) -> None:
+    async def on_voice_state_update(
+            self,
+            member: Member,
+            before: discord.VoiceState,
+            after: discord.VoiceState
+    ) -> None:
         """Pings a user if they've never joined the voice chat before and aren't verified."""
         if member.bot:
             log.trace("User is a bot. Ignore.")
             return
 
-        in_cache = await self.redis_cache.get(member.id, None)
-
         # member.voice will return None if the user is not in a voice channel
-        if in_cache is None and member.voice is not None:
-            log.trace("User not in cache and is in a voice channel")
-            verified = any(Roles.voice_verified == role.id for role in member.roles)
-            if verified:
-                log.trace("User is verified, add to the cache and ignore")
-                #  redis cache does not accept None, so False is used to signify no message
-                await self.redis_cache.set(member.id, False)
-                return
-
-            log.trace("User is unverified. Send ping.")
-            message = await self._voice_verification_channel.send(VOICE_PING.format(member.mention))
-            await self.redis_cache.set(member.id, message.id)
-
-            # Message will try to be deleted after 1 minutes. If it fails, it'll do so silently
-            await message.delete(delay=GateConf.voice_ping_delete_delay)
-        else:
-            log.trace("User is either in the cache or not in a voice channel. Ignore.")
+        if member.voice is None:
+            log.trace("User not in a voice channel. Ignore.")
             return
+        else:
+            in_cache = await self.redis_cache.get(member.id, None)
+            if in_cache:
+                log.trace("User already in cache. Ignore.")
+                return
+            else:
+                log.trace("User not in cache and is in a voice channel")
+                verified = any(Roles.voice_verified == role.id for role in member.roles)
+                if verified:
+                    log.trace("User is verified, add to the cache and ignore")
+                    # redis cache does not accept None, so False is used to signify no message
+                    await self.redis_cache.set(member.id, False)
+                    return
+
+                log.trace("User is unverified. Send ping.")
+                await self.bot.wait_until_guild_available()
+                voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
+
+                message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
+                await self.redis_cache.set(member.id, message.id)
+
+                # Message will try to be deleted after 1 minutes. If it fails, it'll do so silently
+                await message.delete(delay=GateConf.voice_ping_delete_delay)
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
diff --git a/config-default.yml b/config-default.yml
index 7de9faeda..c2a4e71ad 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -522,7 +522,7 @@ voice_gate:
     minimum_messages: 50  # How many messages a user must have to be eligible for voice
     bot_message_delete_delay: 10  # Seconds before deleting bot's response in Voice Gate
     minimum_activity_blocks: 3  # Number of 10 minute blocks during which a user must have been active
-    voice_ping_delete_delay: 60 # Seconds before deleting the bot's ping to user in Voice Gate
+    voice_ping_delete_delay: 60  # Seconds before deleting the bot's ping to user in Voice Gate
 
 config:
     required_keys: ['bot.token']
-- 
cgit v1.2.3


From 18fed79ba8f82ab546165cc577a16c08d42f5b77 Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Fri, 6 Nov 2020 14:54:54 -0600
Subject: Removed extra else's and added constant

- Removed unnecessary else statements
- Added NO_MSG constant to replace the `False` that was being used previously in the redis cache.

Signed-off-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 57 ++++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 28 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index eba05901f..a68018567 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -18,6 +18,8 @@ from bot.utils.checks import InWhitelistCheckFailure
 
 log = logging.getLogger(__name__)
 
+NO_MSG = 0
+
 FAILED_MESSAGE = (
     """You are not currently eligible to use voice inside Python Discord for the following reasons:\n\n{reasons}"""
 )
@@ -39,9 +41,9 @@ VOICE_PING = (
 class VoiceGate(Cog):
     """Voice channels verification management."""
 
-    # RedisCache[t.Union[discord.User.id, discord.Member.id], t.Union[discord.Message.id, bool]]
+    # RedisCache[t.Union[discord.User.id, discord.Member.id], t.Union[discord.Message.id, int]]
     # The cache's keys are the IDs of members who are verified or have joined a voice channel
-    # The cache's values are either the message ID of the ping message or False if no message is present
+    # The cache's values are either the message ID of the ping message or 0 (NO_MSG) if no message is present
     redis_cache = RedisCache()
 
     def __init__(self, bot: Bot) -> None:
@@ -66,11 +68,11 @@ class VoiceGate(Cog):
         - You must have been active for over a certain number of 10-minute blocks
         """
         # If user has received a ping in voice_verification, delete the message
-        if message_id := await self.redis_cache.get(ctx.author.id, None):
+        if message_id := await self.redis_cache.get(ctx.author.id, NO_MSG):
             with suppress(discord.NotFound):
                 ping_message = await ctx.channel.fetch_message(message_id)
                 await ping_message.delete()
-            await self.redis_cache.set(ctx.author.id, False)
+            await self.redis_cache.set(ctx.author.id, NO_MSG)
 
         try:
             data = await self.bot.api_client.get(f"bot/users/{ctx.author.id}/metricity_data")
@@ -190,7 +192,7 @@ class VoiceGate(Cog):
             before: discord.VoiceState,
             after: discord.VoiceState
     ) -> None:
-        """Pings a user if they've never joined the voice chat before and aren't verified."""
+        """Pings a user if they've never joined the voice chat before and aren't voice verified."""
         if member.bot:
             log.trace("User is a bot. Ignore.")
             return
@@ -199,29 +201,28 @@ class VoiceGate(Cog):
         if member.voice is None:
             log.trace("User not in a voice channel. Ignore.")
             return
-        else:
-            in_cache = await self.redis_cache.get(member.id, None)
-            if in_cache:
-                log.trace("User already in cache. Ignore.")
-                return
-            else:
-                log.trace("User not in cache and is in a voice channel")
-                verified = any(Roles.voice_verified == role.id for role in member.roles)
-                if verified:
-                    log.trace("User is verified, add to the cache and ignore")
-                    # redis cache does not accept None, so False is used to signify no message
-                    await self.redis_cache.set(member.id, False)
-                    return
-
-                log.trace("User is unverified. Send ping.")
-                await self.bot.wait_until_guild_available()
-                voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
-
-                message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
-                await self.redis_cache.set(member.id, message.id)
-
-                # Message will try to be deleted after 1 minutes. If it fails, it'll do so silently
-                await message.delete(delay=GateConf.voice_ping_delete_delay)
+
+        in_cache = await self.redis_cache.get(member.id, None)
+        if in_cache:
+            log.trace("User already in cache. Ignore.")
+            return
+
+        log.trace("User not in cache and is in a voice channel.")
+        verified = any(Roles.voice_verified == role.id for role in member.roles)
+        if verified:
+            log.trace("User is verified, add to the cache and ignore.")
+            await self.redis_cache.set(member.id, NO_MSG)
+            return
+
+        log.trace("User is unverified. Send ping.")
+        await self.bot.wait_until_guild_available()
+        voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
+
+        message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
+        await self.redis_cache.set(member.id, message.id)
+
+        # Message will try to be deleted after 1 minutes. If it fails, it'll do so silently
+        await message.delete(delay=GateConf.voice_ping_delete_delay)
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
-- 
cgit v1.2.3


From 472faca4b19419f1101258c876fc5fbbd7da8f3a Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sun, 8 Nov 2020 15:03:46 +0800
Subject: Remove unnecessary noqa pragma for flake8

---
 bot/exts/moderation/infraction/management.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 8aeb45f96..97fc7b1d8 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -49,7 +49,7 @@ class ModManagement(commands.Cog):
     async def infraction_append(
         self,
         ctx: Context,
-        infraction: Infraction,  # noqa: F821
+        infraction: Infraction,
         duration: t.Union[Expiry, allowed_strings("p", "permanent"), None],   # noqa: F821
         *,
         reason: str = None
@@ -87,7 +87,7 @@ class ModManagement(commands.Cog):
     async def infraction_edit(
         self,
         ctx: Context,
-        infraction: Infraction,  # noqa: F821
+        infraction: Infraction,
         duration: t.Union[Expiry, allowed_strings("p", "permanent"), None],   # noqa: F821
         *,
         reason: str = None
-- 
cgit v1.2.3


From 3e73fd76d73b7e84888af46e0b6b47a1dd4003d3 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sun, 8 Nov 2020 15:16:30 +0800
Subject: Raise BadArgument in the Infraction converter

---
 bot/converters.py                            | 9 ++++-----
 bot/exts/moderation/infraction/management.py | 6 ------
 2 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/bot/converters.py b/bot/converters.py
index 962416238..f350e863e 100644
--- a/bot/converters.py
+++ b/bot/converters.py
@@ -568,12 +568,11 @@ class Infraction(Converter):
             infractions = await ctx.bot.api_client.get("bot/infractions", params=params)
 
             if not infractions:
-                await ctx.send(
-                    ":x: Couldn't find most recent infraction; you have never given an infraction."
+                raise BadArgument(
+                    "Couldn't find most recent infraction; you have never given an infraction."
                 )
-                return None
-
-            return infractions[0]
+            else:
+                return infractions[0]
 
         else:
             return ctx.bot.api_client.get(f"bot/infractions/{arg}")
diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 97fc7b1d8..49ddfa473 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -73,9 +73,6 @@ class ModManagement(commands.Cog):
         Use "p" or "permanent" to mark the infraction as permanent. Alternatively, an ISO 8601
         timestamp can be provided for the duration.
         """
-        if not infraction:
-            return
-
         await self.infraction_edit(
             ctx=ctx,
             infraction=infraction,
@@ -115,9 +112,6 @@ class ModManagement(commands.Cog):
             # Unlike UserInputError, the error handler will show a specified message for BadArgument
             raise commands.BadArgument("Neither a new expiry nor a new reason was specified.")
 
-        if not infraction:
-            return
-
         old_infraction = infraction
         infraction_id = infraction["id"]
 
-- 
cgit v1.2.3


From de0b6984cc1947f5454939b4e20a09e6eeaffa98 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sun, 8 Nov 2020 15:23:03 +0800
Subject: Refactor redundant code in infraction_edit

---
 bot/exts/moderation/infraction/management.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 49ddfa473..88b2f98c6 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -112,14 +112,13 @@ class ModManagement(commands.Cog):
             # Unlike UserInputError, the error handler will show a specified message for BadArgument
             raise commands.BadArgument("Neither a new expiry nor a new reason was specified.")
 
-        old_infraction = infraction
         infraction_id = infraction["id"]
 
         request_data = {}
         confirm_messages = []
         log_text = ""
 
-        if duration is not None and not old_infraction['active']:
+        if duration is not None and not infraction['active']:
             if reason is None:
                 await ctx.send(":x: Cannot edit the expiration of an expired infraction.")
                 return
@@ -138,7 +137,7 @@ class ModManagement(commands.Cog):
             request_data['reason'] = reason
             confirm_messages.append("set a new reason")
             log_text += f"""
-                Previous reason: {old_infraction['reason']}
+                Previous reason: {infraction['reason']}
                 New reason: {reason}
             """.rstrip()
         else:
@@ -153,7 +152,7 @@ class ModManagement(commands.Cog):
         # Re-schedule infraction if the expiration has been updated
         if 'expires_at' in request_data:
             # A scheduled task should only exist if the old infraction wasn't permanent
-            if old_infraction['expires_at']:
+            if infraction['expires_at']:
                 self.infractions_cog.scheduler.cancel(new_infraction['id'])
 
             # If the infraction was not marked as permanent, schedule a new expiration task
@@ -161,7 +160,7 @@ class ModManagement(commands.Cog):
                 self.infractions_cog.schedule_expiration(new_infraction)
 
             log_text += f"""
-                Previous expiry: {old_infraction['expires_at'] or "Permanent"}
+                Previous expiry: {infraction['expires_at'] or "Permanent"}
                 New expiry: {new_infraction['expires_at'] or "Permanent"}
             """.rstrip()
 
-- 
cgit v1.2.3


From af7cfd35945f7885a7cd36490aa0ffcf91218c8b Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Sun, 8 Nov 2020 16:03:11 +0800
Subject: Automatically add periods as visual buffers

---
 bot/exts/moderation/infraction/management.py | 17 +++++++++++------
 bot/utils/regex.py                           |  2 ++
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 88b2f98c6..e6513c32d 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -16,6 +16,7 @@ from bot.exts.moderation.modlog import ModLog
 from bot.pagination import LinePaginator
 from bot.utils import messages, time
 from bot.utils.checks import in_whitelist_check
+from bot.utils.regex import END_PUNCTUATION_RE
 
 log = logging.getLogger(__name__)
 
@@ -72,13 +73,17 @@ class ModManagement(commands.Cog):
 
         Use "p" or "permanent" to mark the infraction as permanent. Alternatively, an ISO 8601
         timestamp can be provided for the duration.
+
+        If a previous infraction reason does not end with an ending punctuation mark, this automatically
+        adds a period before the amended reason.
         """
-        await self.infraction_edit(
-            ctx=ctx,
-            infraction=infraction,
-            duration=duration,
-            reason=fr"{infraction['reason']} **\|\|** {reason}",
-        )
+        add_period = not END_PUNCTUATION_RE.match(infraction["reason"])
+
+        new_reason = "".join((
+            infraction["reason"], ". " if add_period else " ", reason,
+        ))
+
+        await self.infraction_edit(ctx, infraction, duration, reason=new_reason)
 
     @infraction_group.command(name='edit')
     async def infraction_edit(
diff --git a/bot/utils/regex.py b/bot/utils/regex.py
index 0d2068f90..cfce52bb3 100644
--- a/bot/utils/regex.py
+++ b/bot/utils/regex.py
@@ -10,3 +10,5 @@ INVITE_RE = re.compile(
     r"([a-zA-Z0-9\-]+)",                              # the invite code itself
     flags=re.IGNORECASE
 )
+
+END_PUNCTUATION_RE = re.compile("^.+?[.?!]$")
-- 
cgit v1.2.3


From 8cc2622c7f9b6fb3381eaa72f5b98670f34b3541 Mon Sep 17 00:00:00 2001
From: Daniel Brown <browndj3@gmail.com>
Date: Sun, 8 Nov 2020 12:38:26 -0600
Subject: Added dummy parameter, changed message delete logic

- Added a None placeholder in the `__init__` for voice gate channel.
- Changed deletion logic in on_voice_state_update to check if the message has already been deleted.
- Changed deletion logic in voice_verify to only require one api call.
---
 bot/exts/moderation/voice_gate.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index a68018567..57abfb7a1 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -48,6 +48,8 @@ class VoiceGate(Cog):
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
+        # voice_verification_channel set to None so that we have a placeholder to get it later in the cog
+        self.voice_verification_channel = None
 
     @property
     def mod_log(self) -> ModLog:
@@ -70,8 +72,8 @@ class VoiceGate(Cog):
         # If user has received a ping in voice_verification, delete the message
         if message_id := await self.redis_cache.get(ctx.author.id, NO_MSG):
             with suppress(discord.NotFound):
-                ping_message = await ctx.channel.fetch_message(message_id)
-                await ping_message.delete()
+                self.voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
+                await self.bot.http.delete_message(self.voice_verification_channel, message_id)
             await self.redis_cache.set(ctx.author.id, NO_MSG)
 
         try:
@@ -202,7 +204,7 @@ class VoiceGate(Cog):
             log.trace("User not in a voice channel. Ignore.")
             return
 
-        in_cache = await self.redis_cache.get(member.id, None)
+        in_cache = await self.redis_cache.get(member.id, NO_MSG)
         if in_cache:
             log.trace("User already in cache. Ignore.")
             return
@@ -221,8 +223,10 @@ class VoiceGate(Cog):
         message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
         await self.redis_cache.set(member.id, message.id)
 
-        # Message will try to be deleted after 1 minutes. If it fails, it'll do so silently
-        await message.delete(delay=GateConf.voice_ping_delete_delay)
+        await asyncio.sleep(60)
+        if message := await self.redis_cache.get(member.id):
+            await message.delete()
+            await self.redis_cache.set(member.id, NO_MSG)
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
-- 
cgit v1.2.3


From ec8018c3f160dd6017f024adc898840267116379 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Sun, 8 Nov 2020 23:46:05 +0100
Subject: Voice Gate: one-line func signature

---
 bot/exts/moderation/voice_gate.py | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 57abfb7a1..0aefa5d53 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -6,7 +6,7 @@ from datetime import datetime, timedelta
 import discord
 from async_rediscache import RedisCache
 from dateutil import parser
-from discord import Colour, Member
+from discord import Colour, Member, VoiceState
 from discord.ext.commands import Cog, Context, command
 
 from bot.api import ResponseCodeError
@@ -188,12 +188,7 @@ class VoiceGate(Cog):
             await message.delete()
 
     @Cog.listener()
-    async def on_voice_state_update(
-            self,
-            member: Member,
-            before: discord.VoiceState,
-            after: discord.VoiceState
-    ) -> None:
+    async def on_voice_state_update(self, member: Member, before: VoiceState, after: VoiceState) -> None:
         """Pings a user if they've never joined the voice chat before and aren't voice verified."""
         if member.bot:
             log.trace("User is a bot. Ignore.")
-- 
cgit v1.2.3


From 59b34c77b60d6f97e5d915bd0ad5cfb7d419143a Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Sun, 8 Nov 2020 23:49:06 +0100
Subject: Voice Gate: fix cache membership check

Since the cache offers a 'contains' coro, let's use it.

If the member ID is already present in the cache, they were either
already verified, or were already pung about not being verified.
---
 bot/exts/moderation/voice_gate.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 0aefa5d53..2e8305227 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -199,8 +199,7 @@ class VoiceGate(Cog):
             log.trace("User not in a voice channel. Ignore.")
             return
 
-        in_cache = await self.redis_cache.get(member.id, NO_MSG)
-        if in_cache:
+        if await self.redis_cache.contains(member.id):
             log.trace("User already in cache. Ignore.")
             return
 
-- 
cgit v1.2.3


From d6820a2209f1605349456801c0e8e6f2045b1649 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Sun, 8 Nov 2020 23:50:49 +0100
Subject: Voice Gate: refer to config rather than hard-coded duration

The const was introduced for this purpose, but it was accidentally
not being used.
---
 bot/exts/moderation/voice_gate.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 2e8305227..6e6f4411b 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -217,7 +217,7 @@ class VoiceGate(Cog):
         message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
         await self.redis_cache.set(member.id, message.id)
 
-        await asyncio.sleep(60)
+        await asyncio.sleep(GateConf.voice_ping_delete_delay)
         if message := await self.redis_cache.get(member.id):
             await message.delete()
             await self.redis_cache.set(member.id, NO_MSG)
-- 
cgit v1.2.3


From dbff099fbcf4fb582ea6a091497c017e5de38d9d Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Mon, 9 Nov 2020 00:06:57 +0100
Subject: Voice Gate: correct HTTP delete method usage

This removes the need to fetch the Channel object. Add a trace log
to help with testing.
---
 bot/exts/moderation/voice_gate.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 6e6f4411b..054dbed2d 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -48,8 +48,6 @@ class VoiceGate(Cog):
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
-        # voice_verification_channel set to None so that we have a placeholder to get it later in the cog
-        self.voice_verification_channel = None
 
     @property
     def mod_log(self) -> ModLog:
@@ -71,9 +69,9 @@ class VoiceGate(Cog):
         """
         # If user has received a ping in voice_verification, delete the message
         if message_id := await self.redis_cache.get(ctx.author.id, NO_MSG):
+            log.trace(f"Removing voice gate reminder message for user: {ctx.author.id}")
             with suppress(discord.NotFound):
-                self.voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
-                await self.bot.http.delete_message(self.voice_verification_channel, message_id)
+                await self.bot.http.delete_message(Channels.voice_gate, message_id)
             await self.redis_cache.set(ctx.author.id, NO_MSG)
 
         try:
-- 
cgit v1.2.3


From 92132af28ef97ff7837b4d1bae4115e8a95b9554 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Mon, 9 Nov 2020 00:09:38 +0100
Subject: Voice Gate: correct after-delay message delete methodology

Use a HTTP method so that we do not have to fetch the message object,
the cache only gives us the ID.
---
 bot/exts/moderation/voice_gate.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 054dbed2d..97b588e72 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -216,8 +216,11 @@ class VoiceGate(Cog):
         await self.redis_cache.set(member.id, message.id)
 
         await asyncio.sleep(GateConf.voice_ping_delete_delay)
-        if message := await self.redis_cache.get(member.id):
-            await message.delete()
+
+        if message_id := await self.redis_cache.get(member.id):
+            log.trace(f"Removing voice gate reminder message for user: {member.id}")
+            with suppress(discord.NotFound):
+                await self.bot.http.delete_message(Channels.voice_gate, message_id)
             await self.redis_cache.set(member.id, NO_MSG)
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
-- 
cgit v1.2.3


From fca8b814df974b4c30e14a72d48681da77259899 Mon Sep 17 00:00:00 2001
From: Thomas Petersson <thomas@petersson.priv.no>
Date: Mon, 9 Nov 2020 18:15:00 +0100
Subject: fix(bot): statds pr review suggestions

---
 bot/bot.py | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/bot/bot.py b/bot/bot.py
index eee940637..b097513f1 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -37,6 +37,7 @@ class Bot(commands.Bot):
 
         self._connector = None
         self._resolver = None
+        self._statsd_timerhandle: asyncio.TimerHandle = None
         self._guild_available = asyncio.Event()
 
         statsd_url = constants.Stats.statsd_host
@@ -48,20 +49,24 @@ class Bot(commands.Bot):
             statsd_url = LOCALHOST
 
         self.stats = AsyncStatsClient(self.loop, LOCALHOST)
-        self.connect_statsd(statsd_url)
+        self._connect_statsd(statsd_url)
 
-    def connect_statsd(self, statsd_url: str, retry_after: int = 2, attempt: int = 1) -> None:
+    def _connect_statsd(self, statsd_url: str, retry_after: int = 2, attempt: int = 1) -> None:
         """Callback used to retry a connection to statsd if it should fail."""
-        if attempt > 5:
-            log.error("Reached 10 attempts trying to reconnect AsyncStatsClient. Aborting")
+        if self._statsd_timerhandle and not self._statsd_timerhandle.cancelled:
+            self._statsd_timerhandle.cancel()
+
+        if attempt >= 5:
+            log.error("Reached 5 attempts trying to reconnect AsyncStatsClient. Aborting")
             return
 
         try:
             self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
         except socket.gaierror:
-            log.warning(f"Statsd client failed to connect (Attempts: {attempt})")
+            log.warning(f"Statsd client failed to connect (Attempt(s): {attempt})")
             # Use a fallback strategy for retrying, up to 5 times.
-            self.loop.call_later(retry_after, self.retry_statsd_connection, statsd_url, retry_after ** 2, attempt + 1)
+            self._statsd_timerhandle = self.loop.call_later(
+                retry_after, self._connect_statsd, statsd_url, retry_after * 5, attempt + 1)
 
     async def cache_filter_list_data(self) -> None:
         """Cache all the data in the FilterList on the site."""
@@ -167,6 +172,9 @@ class Bot(commands.Bot):
         if self.redis_session:
             await self.redis_session.close()
 
+        if self._statsd_timerhandle and not self._statsd_timerhandle.cancelled:
+            self._statsd_timerhandle.cancel()
+
     def insert_item_into_filter_list_cache(self, item: Dict[str, str]) -> None:
         """Add an item to the bots filter_list_cache."""
         type_ = item["type"]
-- 
cgit v1.2.3


From b4220a32bf6e6c3e46392e443979acdff8979e50 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Tue, 10 Nov 2020 17:24:39 +0100
Subject: Voice Gate: define atomic `_delete_ping` function

The code for ping deletion was duplicated in two places. In this commit,
we move it into a helper function, and apply a lock to make each
transaction atomic.

This means that if two coroutines try to call the function, the first
has to finish before the second can begin. This avoids the following:

Coro1: Message in cache? Yes.
Coro1: Send delete request. Yield control (await).
Coro2: Message in cache? Yes.

Now Coro2 has to wait for Coro1 to finish. Therefore it will always
find the `NO_MSG` signal, and not attempt the deletion.

Co-authored-by: MarkKoz <KozlovMark@gmail.com>
Co-authored-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Co-authored-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 97b588e72..d53d08efe 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -54,6 +54,23 @@ class VoiceGate(Cog):
         """Get the currently loaded ModLog cog instance."""
         return self.bot.get_cog("ModLog")
 
+    @redis_cache.atomic_transaction  # Fully process each call until starting the next
+    async def _delete_ping(self, member_id: int) -> None:
+        """
+        If `redis_cache` holds a message ID for `member_id`, delete the message.
+
+        If the message was deleted, the value under the `member_id` key is then set to `NO_MSG`.
+        When `member_id` is not in the cache, or has a value of `NO_MSG` already, this function
+        does nothing.
+        """
+        if message_id := await self.redis_cache.get(member_id):
+            log.trace(f"Removing voice gate reminder message for user: {member_id}")
+            with suppress(discord.NotFound):
+                await self.bot.http.delete_message(Channels.voice_gate, message_id)
+            await self.redis_cache.set(member_id, NO_MSG)
+        else:
+            log.trace(f"Voice gate reminder message for user {member_id} was already removed")
+
     @command(aliases=('voiceverify',))
     @has_no_roles(Roles.voice_verified)
     @in_whitelist(channels=(Channels.voice_gate,), redirect=None)
@@ -67,12 +84,7 @@ class VoiceGate(Cog):
         - You must not be actively banned from using our voice channels
         - You must have been active for over a certain number of 10-minute blocks
         """
-        # If user has received a ping in voice_verification, delete the message
-        if message_id := await self.redis_cache.get(ctx.author.id, NO_MSG):
-            log.trace(f"Removing voice gate reminder message for user: {ctx.author.id}")
-            with suppress(discord.NotFound):
-                await self.bot.http.delete_message(Channels.voice_gate, message_id)
-            await self.redis_cache.set(ctx.author.id, NO_MSG)
+        await self._delete_ping(ctx.author.id)  # If user has received a ping in voice_verification, delete the message
 
         try:
             data = await self.bot.api_client.get(f"bot/users/{ctx.author.id}/metricity_data")
@@ -217,11 +229,7 @@ class VoiceGate(Cog):
 
         await asyncio.sleep(GateConf.voice_ping_delete_delay)
 
-        if message_id := await self.redis_cache.get(member.id):
-            log.trace(f"Removing voice gate reminder message for user: {member.id}")
-            with suppress(discord.NotFound):
-                await self.bot.http.delete_message(Channels.voice_gate, message_id)
-            await self.redis_cache.set(member.id, NO_MSG)
+        await self._delete_ping(member.id)
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
-- 
cgit v1.2.3


From 4b60c214804cb44610ff49f4bce3b8f2ffe5194c Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Tue, 10 Nov 2020 18:30:37 +0100
Subject: Voice Gate: ensure atomicity when notifying users

Previously, the listener risked yielding control to a racing event at
multiple points between checking whether the member was already
notified, notifying them, and writing this information into the cache.

As a result, in a pathological case, multiple racing coroutines could
have passed the membership check and ping-spammed the user, before the
first coro could have a chance to write the message ID into the cache.

In this commit, we move this logic into an atomic helper, which will
ensure that events are processed one-by-one, and subsequent events
correctly abort.

Co-authored-by: MarkKoz <KozlovMark@gmail.com>
Co-authored-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Co-authored-by: Daniel Brown <browndj3@gmail.com>
---
 bot/exts/moderation/voice_gate.py | 59 ++++++++++++++++++++++++++-------------
 1 file changed, 39 insertions(+), 20 deletions(-)

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index d53d08efe..0c0e93d42 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -71,6 +71,37 @@ class VoiceGate(Cog):
         else:
             log.trace(f"Voice gate reminder message for user {member_id} was already removed")
 
+    @redis_cache.atomic_transaction
+    async def _ping_newcomer(self, member: discord.Member) -> bool:
+        """
+        See if `member` should be sent a voice verification notification, and send it if so.
+
+        Returns False if the notification was not sent. This happens when:
+        * The `member` has already received the notification
+        * The `member` is already voice-verified
+
+        Otherwise, the notification message ID is stored in `redis_cache` and True is returned.
+        """
+        if await self.redis_cache.contains(member.id):
+            log.trace("User already in cache. Ignore.")
+            return False
+
+        log.trace("User not in cache and is in a voice channel.")
+        verified = any(Roles.voice_verified == role.id for role in member.roles)
+        if verified:
+            log.trace("User is verified, add to the cache and ignore.")
+            await self.redis_cache.set(member.id, NO_MSG)
+            return False
+
+        log.trace("User is unverified. Send ping.")
+        await self.bot.wait_until_guild_available()
+        voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
+
+        message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
+        await self.redis_cache.set(member.id, message.id)
+
+        return True
+
     @command(aliases=('voiceverify',))
     @has_no_roles(Roles.voice_verified)
     @in_whitelist(channels=(Channels.voice_gate,), redirect=None)
@@ -209,27 +240,15 @@ class VoiceGate(Cog):
             log.trace("User not in a voice channel. Ignore.")
             return
 
-        if await self.redis_cache.contains(member.id):
-            log.trace("User already in cache. Ignore.")
-            return
-
-        log.trace("User not in cache and is in a voice channel.")
-        verified = any(Roles.voice_verified == role.id for role in member.roles)
-        if verified:
-            log.trace("User is verified, add to the cache and ignore.")
-            await self.redis_cache.set(member.id, NO_MSG)
-            return
-
-        log.trace("User is unverified. Send ping.")
-        await self.bot.wait_until_guild_available()
-        voice_verification_channel = self.bot.get_channel(Channels.voice_gate)
-
-        message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
-        await self.redis_cache.set(member.id, message.id)
-
-        await asyncio.sleep(GateConf.voice_ping_delete_delay)
+        # To avoid race conditions, checking if the user should receive a notification
+        # and sending it if appropriate is delegated to an atomic helper
+        notification_sent = await self._ping_newcomer(member)
 
-        await self._delete_ping(member.id)
+        # Schedule the notification to be deleted after the configured delay, which is
+        # again delegated to an atomic helper
+        if notification_sent:
+            await asyncio.sleep(GateConf.voice_ping_delete_delay)
+            await self._delete_ping(member.id)
 
     async def cog_command_error(self, ctx: Context, error: Exception) -> None:
         """Check for & ignore any InWhitelistCheckFailure."""
-- 
cgit v1.2.3


From b32174b4bcf55eef15dd4bd44d1a9676f86934b9 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Tue, 10 Nov 2020 18:33:31 +0100
Subject: Voice Gate: explain the purpose of `NO_MSG`

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

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 0c0e93d42..4d48d2c1b 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -18,6 +18,10 @@ from bot.utils.checks import InWhitelistCheckFailure
 
 log = logging.getLogger(__name__)
 
+# Flag written to the cog's RedisCache as a value when the Member's (key) notification
+# was already removed ~ this signals both that no further notifications should be sent,
+# and that the notification does not need to be removed. The implementation relies on
+# this being falsey!
 NO_MSG = 0
 
 FAILED_MESSAGE = (
-- 
cgit v1.2.3


From 36bffe9653b33c64aea21c5c31471f69d290ed37 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Wed, 11 Nov 2020 21:34:39 +0100
Subject: CI: invalidate dependency cache

The cache became corrupted for reasons what we were not able to figure
out, causing the pre-commit step to fail when the environment was
retrieved from the cache. By changing the key, we force cache rebuild.
---
 azure-pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 9f58e38c8..991b1f447 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -34,7 +34,7 @@ jobs:
       - task: Cache@2
         displayName: 'Restore Python environment'
         inputs:
-          key: python | $(Agent.OS) | "$(python.pythonLocation)" | 0 | ./Pipfile | ./Pipfile.lock
+          key: python | $(Agent.OS) | "$(python.pythonLocation)" | 1 | ./Pipfile | ./Pipfile.lock
           cacheHitVar: PY_ENV_RESTORED
           path: $(PYTHONUSERBASE)
         continueOnError: true
-- 
cgit v1.2.3


From 8c8b65c4647f23010d7fb458246c28b3ccbeb549 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Wed, 11 Nov 2020 22:37:28 +0100
Subject: Config: ensure 2 blank lines between classes

Previous changes reduced the spacing to 1 blank line, which is
inconsistent with the prevailing style.
---
 bot/constants.py   | 2 ++
 config-default.yml | 1 +
 2 files changed, 3 insertions(+)

diff --git a/bot/constants.py b/bot/constants.py
index 66a049851..731f06fed 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -361,6 +361,7 @@ class CleanMessages(metaclass=YAMLGetter):
 
     message_limit: int
 
+
 class Stats(metaclass=YAMLGetter):
     section = "bot"
     subsection = "stats"
@@ -603,6 +604,7 @@ class VoiceGate(metaclass=YAMLGetter):
     minimum_activity_blocks: int
     voice_ping_delete_delay: int
 
+
 class Event(Enum):
     """
     Event names. This does not include every event (for example, raw
diff --git a/config-default.yml b/config-default.yml
index c2a4e71ad..8912841ff 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -524,5 +524,6 @@ voice_gate:
     minimum_activity_blocks: 3  # Number of 10 minute blocks during which a user must have been active
     voice_ping_delete_delay: 60  # Seconds before deleting the bot's ping to user in Voice Gate
 
+
 config:
     required_keys: ['bot.token']
-- 
cgit v1.2.3


From 9794016943861fb41d1b84a24d2766fad0771a16 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Fri, 13 Nov 2020 08:26:59 +0100
Subject: CI: invalidate environment cache

The cache was corrupted again for unknown reasons.
---
 azure-pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 991b1f447..0aa36a940 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -34,7 +34,7 @@ jobs:
       - task: Cache@2
         displayName: 'Restore Python environment'
         inputs:
-          key: python | $(Agent.OS) | "$(python.pythonLocation)" | 1 | ./Pipfile | ./Pipfile.lock
+          key: python | $(Agent.OS) | "$(python.pythonLocation)" | 2 | ./Pipfile | ./Pipfile.lock
           cacheHitVar: PY_ENV_RESTORED
           path: $(PYTHONUSERBASE)
         continueOnError: true
-- 
cgit v1.2.3


From 8885b15ca367398cd3208cbe3e9fce2e85b6a379 Mon Sep 17 00:00:00 2001
From: kwzrd <kwzrd@pythondiscord.com>
Date: Fri, 13 Nov 2020 08:30:27 +0100
Subject: CI: disable 'continueOnError'

After #1219, we started to encounter issues with the cache being
corrupted and CI failing due to 'pre-commit' not being installed
after restore.

Although it doesn't seem likely that this could have been the culprit,
the issues began appearing shortly after merging the PR.

Let's see what happens if we disable it.
---
 azure-pipelines.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 0aa36a940..188ad7f93 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -37,7 +37,6 @@ jobs:
           key: python | $(Agent.OS) | "$(python.pythonLocation)" | 2 | ./Pipfile | ./Pipfile.lock
           cacheHitVar: PY_ENV_RESTORED
           path: $(PYTHONUSERBASE)
-        continueOnError: true
 
       - script: echo '##vso[task.prependpath]$(PYTHONUSERBASE)/bin'
         displayName: 'Prepend PATH'
@@ -65,7 +64,6 @@ jobs:
         inputs:
           key: pre-commit | "$(python.pythonLocation)" | 0 | .pre-commit-config.yaml
           path: $(PRE_COMMIT_HOME)
-        continueOnError: true
 
       # pre-commit's venv doesn't allow user installs - not that they're really needed anyway.
       - script: export PIP_USER=0; pre-commit run --all-files
-- 
cgit v1.2.3


From 4d4dfe42632cc88265efcb8052b7bca5209d3f4d Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Fri, 13 Nov 2020 18:39:04 +0100
Subject: Migrate CI Pipeline to GitHub Actions

I've migrated our Azure CI Pipeline to GitHub Actions. While the general
workflow is the same, there are a few changes:

- `flake8` is no longer run by `pre-commit`, but rather by a separate
  action that adds annotations to the GH Action results page.

- As we no longer have need for xml-formatted coverage files, the
  xmlrunner for unittest has been removed as a dependency. Instead, we
  now publish our coverage results to coveralls.io.

- We use version 2 of docker's GitHub Action build-and-push flow, which
  is split over multiple steps instead of one.

- I have changed the badges to GitHub Actions and coveralls.io badges.

Note: Because we accept PRs from forks, we need to be a bit careful with
our secrets. While we do use the `pull_request_target` event, we should
not expose secrets in steps that run code from the repository.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/lint-test-build.yml | 122 +++++++++++++++
 Pipfile                               |   1 -
 Pipfile.lock                          | 282 +++++++++++++++++-----------------
 README.md                             |   5 +-
 azure-pipelines.yml                   | 106 -------------
 5 files changed, 265 insertions(+), 251 deletions(-)
 create mode 100644 .github/workflows/lint-test-build.yml
 delete mode 100644 azure-pipelines.yml

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
new file mode 100644
index 000000000..dc472ec8e
--- /dev/null
+++ b/.github/workflows/lint-test-build.yml
@@ -0,0 +1,122 @@
+name: Lint, Test, Build
+
+on:
+  push:
+    branches:
+      - master
+  # We use pull_request_target as we get PRs from
+  # forks, but need to be able to add annotations
+  # for our flake8 step.
+  pull_request_target:
+
+
+jobs:
+  lint-test:
+    runs-on: ubuntu-latest
+    env:
+      BOT_API_KEY: foo
+      BOT_SENTRY_DSN: blah
+      BOT_TOKEN: bar
+      REDDIT_CLIENT_ID: spam
+      REDDIT_SECRET: ham
+      REDIS_PASSWORD: ''
+
+      PIP_NO_CACHE_DIR: false
+      PIP_USER: 1
+      PIPENV_HIDE_EMOJIS: 1
+      PIPENV_IGNORE_VIRTUALENVS: 1
+      PIPENV_NOSPIN: 1
+      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
+      PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
+
+    steps:
+      - name: Add custom PYTHONUSERBASE to PATH
+        run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
+
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Setup python
+        id: python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.8'
+
+      - name: Python Dependency Caching
+        uses: actions/cache@v2
+        id: python_cache
+        with:
+          path: ${{ env.PYTHONUSERBASE }}
+          key: "python-0-${{ runner.os }}-${{ env.PYTHONUSERBASE }}-\
+          ${{ steps.python.outputs.python-version }}-\
+          ${{ hashFiles('./Pipfile', './Pipfile.lock') }}"
+
+      - name: Install dependencies using pipenv
+        if: steps.python_cache.outputs.cache-hit != 'true'
+        run: |
+          pip install pipenv
+          pipenv install --dev --deploy --system
+
+      - name: Pre-commit Environment Caching
+        uses: actions/cache@v2
+        id: pre_commit_cache
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
+          ${{ steps.python.outputs.python-version }}-\
+          ${{ hashFiles('./.pre-commit-config.yaml') }}"
+
+      # We will not run `flake8` here, as we will use a separate flake8 action
+      - name: Run pre-commit hooks
+        run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
+
+      # This step requires `pull_request_target` due to the use of annotations
+      - name: Run flake8
+        uses: julianwachholz/flake8-action@v1
+        with:
+          checkName: lint
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # We run `coverage` using the `python` command so we can suppress
+      # irrelevant warnings in our CI output.
+      - name: Run tests and generate coverage report
+        run: |
+            python -Wignore -m coverage run -m unittest
+            coverage report -m
+
+      # This step will publish the coverage reports coveralls.io and
+      # print a "job" link in the output of the GitHub Action
+      - name: Publish coverage report to coveralls.io
+        env:
+            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          pip install coveralls
+          coveralls
+
+  build-and-push:
+    needs: lint-test
+    if: github.event_name != 'pull_request_target' && github.ref == 'refs/heads/master'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          cache-from: type=registry,ref=pythondiscord/bot:latest
+          tags: pythondiscord/bot:latest
diff --git a/Pipfile b/Pipfile
index 99fc70b46..b8a542653 100644
--- a/Pipfile
+++ b/Pipfile
@@ -39,7 +39,6 @@ flake8-tidy-imports = "~=4.0"
 flake8-todo = "~=0.7"
 pep8-naming = "~=0.9"
 pre-commit = "~=2.1"
-unittest-xml-reporting = "~=3.0"
 
 [requires]
 python_version = "3.8"
diff --git a/Pipfile.lock b/Pipfile.lock
index becd85c55..ebd7f20fd 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "073fd0c51749aafa188fdbe96c5b90dd157cb1d23bdd144801fb0d0a369ffa88"
+            "sha256": "906565a018f17354f8f5f1508505fdac1f52b522caab8d539654136eb3194f50"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -34,21 +34,22 @@
         },
         "aiohttp": {
             "hashes": [
-                "sha256:1e984191d1ec186881ffaed4581092ba04f7c61582a177b187d3a2f07ed9719e",
-                "sha256:259ab809ff0727d0e834ac5e8a283dc5e3e0ecc30c4d80b3cd17a4139ce1f326",
-                "sha256:2f4d1a4fdce595c947162333353d4a44952a724fba9ca3205a3df99a33d1307a",
-                "sha256:32e5f3b7e511aa850829fbe5aa32eb455e5534eaa4b1ce93231d00e2f76e5654",
-                "sha256:344c780466b73095a72c616fac5ea9c4665add7fc129f285fbdbca3cccf4612a",
-                "sha256:460bd4237d2dbecc3b5ed57e122992f60188afe46e7319116da5eb8a9dfedba4",
-                "sha256:4c6efd824d44ae697814a2a85604d8e992b875462c6655da161ff18fd4f29f17",
-                "sha256:50aaad128e6ac62e7bf7bd1f0c0a24bc968a0c0590a726d5a955af193544bcec",
-                "sha256:6206a135d072f88da3e71cc501c59d5abffa9d0bb43269a6dcd28d66bfafdbdd",
-                "sha256:65f31b622af739a802ca6fd1a3076fd0ae523f8485c52924a89561ba10c49b48",
-                "sha256:ae55bac364c405caa23a4f2d6cfecc6a0daada500274ffca4a9230e7129eac59",
-                "sha256:b778ce0c909a2653741cb4b1ac7015b5c130ab9c897611df43ae6a58523cb965"
+                "sha256:1a4160579ffbc1b69e88cb6ca8bb0fbd4947dfcbf9fb1e2a4fc4c7a4a986c1fe",
+                "sha256:206c0ccfcea46e1bddc91162449c20c72f308aebdcef4977420ef329c8fcc599",
+                "sha256:2ad493de47a8f926386fa6d256832de3095ba285f325db917c7deae0b54a9fc8",
+                "sha256:319b490a5e2beaf06891f6711856ea10591cfe84fe9f3e71a721aa8f20a0872a",
+                "sha256:470e4c90da36b601676fe50c49a60d34eb8c6593780930b1aa4eea6f508dfa37",
+                "sha256:60f4caa3b7f7a477f66ccdd158e06901e1d235d572283906276e3803f6b098f5",
+                "sha256:66d64486172b032db19ea8522328b19cfb78a3e1e5b62ab6a0567f93f073dea0",
+                "sha256:687461cd974722110d1763b45c5db4d2cdee8d50f57b00c43c7590d1dd77fc5c",
+                "sha256:698cd7bc3c7d1b82bb728bae835724a486a8c376647aec336aa21a60113c3645",
+                "sha256:797456399ffeef73172945708810f3277f794965eb6ec9bd3a0c007c0476be98",
+                "sha256:a885432d3cabc1287bcf88ea94e1826d3aec57fd5da4a586afae4591b061d40d",
+                "sha256:c506853ba52e516b264b106321c424d03f3ddef2813246432fa9d1cefd361c81",
+                "sha256:fb83326d8295e8840e4ba774edf346e87eca78ba8a89c55d2690352842c15ba5"
             ],
             "index": "pypi",
-            "version": "==3.6.2"
+            "version": "==3.6.3"
         },
         "aioping": {
             "hashes": [
@@ -68,11 +69,11 @@
         },
         "aiormq": {
             "hashes": [
-                "sha256:106695a836f19c1af6c46b58e8aac80e00f86c5b3287a3c6483a1ee369cc95c9",
-                "sha256:9f6dbf6155fe2b7a3d24bf68de97fb812db0fac0a54e96bc1af14ea95078ba7f"
+                "sha256:8218dd9f7198d6e7935855468326bbacf0089f926c70baa8dd92944cb2496573",
+                "sha256:e584dac13a242589aaf42470fd3006cb0dc5aed6506cbd20357c7ec8bbe4a89e"
             ],
             "markers": "python_version >= '3.6'",
-            "version": "==3.2.3"
+            "version": "==3.3.1"
         },
         "alabaster": {
             "hashes": [
@@ -103,35 +104,35 @@
         },
         "attrs": {
             "hashes": [
-                "sha256:26b54ddbbb9ee1d34d5d3668dd37d6cf74990ab23c828c2888dccdceee395594",
-                "sha256:fce7fc47dfc976152e82d53ff92fa0407700c21acd20886a13777a0d20e655dc"
+                "sha256:31b2eced602aa8423c2aea9c76a724617ed67cf9513173fd3a4f03e3a929c7e6",
+                "sha256:832aa3cde19744e49938b91fea06d69ecb9e649c93ba974535d08ad92164f700"
             ],
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==20.2.0"
+            "version": "==20.3.0"
         },
         "babel": {
             "hashes": [
-                "sha256:1aac2ae2d0d8ea368fa90906567f5c08463d98ade155c0c4bfedd6a0f7160e38",
-                "sha256:d670ea0b10f8b723672d3a6abeb87b565b244da220d76b4dba1b66269ec152d4"
+                "sha256:9d35c22fcc79893c3ecc85ac4a56cde1ecf3f19c540bba0922308a6c06ca6fa5",
+                "sha256:da031ab54472314f210b0adcff1588ee5d1d1d0ba4dbd07b94dba82bde791e05"
             ],
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==2.8.0"
+            "version": "==2.9.0"
         },
         "beautifulsoup4": {
             "hashes": [
-                "sha256:1edf5e39f3a5bc6e38b235b369128416c7239b34f692acccececb040233032a1",
-                "sha256:5dfe44f8fddc89ac5453f02659d3ab1668f2c0d9684839f0785037e8c6d9ac8d",
-                "sha256:645d833a828722357038299b7f6879940c11dddd95b900fe5387c258b72bb883"
+                "sha256:4c98143716ef1cb40bf7f39a8e3eec8f8b009509e74904ba3a7b315431577e35",
+                "sha256:84729e322ad1d5b4d25f805bfa05b902dd96450f43842c4e99067d5e1369eb25",
+                "sha256:fff47e031e34ec82bf17e00da8f592fe7de69aeea38be00523c04623c04fb666"
             ],
             "index": "pypi",
-            "version": "==4.9.2"
+            "version": "==4.9.3"
         },
         "certifi": {
             "hashes": [
-                "sha256:5930595817496dd21bb8dc35dad090f1c2cd0adfaf21204bf6732ca5d8ee34d3",
-                "sha256:8fc0819f1f30ba15bdb34cceffb9ef04d99f420f68eb75d901e9560b8749fc41"
+                "sha256:1f422849db327d534e3d0c5f02a263458c3955ec0aae4ff09b95f195c59f4edd",
+                "sha256:f05def092c44fbf25834a51509ef6e631dc19765ab8a57b4e7ab85531f0a9cf4"
             ],
-            "version": "==2020.6.20"
+            "version": "==2020.11.8"
         },
         "cffi": {
             "hashes": [
@@ -183,11 +184,11 @@
         },
         "colorama": {
             "hashes": [
-                "sha256:7d73d2a99753107a36ac6b455ee49046802e59d9d076ef8e47b61499fa29afff",
-                "sha256:e96da0d330793e2cb9485e9ddfd918d456036c7149416295932478192f4436a1"
+                "sha256:5941b2b48a20143d2267e95b1c2a7603ce057ee39fd88e7329b0c292aa16869b",
+                "sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2"
             ],
             "markers": "sys_platform == 'win32'",
-            "version": "==0.4.3"
+            "version": "==0.4.4"
         },
         "coloredlogs": {
             "hashes": [
@@ -207,11 +208,11 @@
         },
         "discord.py": {
             "hashes": [
-                "sha256:3acb61fde0d862ed346a191d69c46021e6063673f63963bc984ae09a685ab211",
-                "sha256:e71089886aa157341644bdecad63a72ff56b44406b1a6467b66db31c8e5a5a15"
+                "sha256:2367359e31f6527f8a936751fc20b09d7495dd6a76b28c8fb13d4ca6c55b7563",
+                "sha256:def00dc50cf36d21346d71bc89f0cad8f18f9a3522978dc18c7796287d47de8b"
             ],
             "index": "pypi",
-            "version": "==1.5.0"
+            "version": "==1.5.1"
         },
         "docutils": {
             "hashes": [
@@ -223,10 +224,10 @@
         },
         "fakeredis": {
             "hashes": [
-                "sha256:7ea0866ba5edb40fe2e9b1722535df0c7e6b91d518aa5f50d96c2fff3ea7f4c2",
-                "sha256:aad8836ffe0319ffbba66dcf872ac6e7e32d1f19790e31296ba58445efb0a5c7"
+                "sha256:8070b7fce16f828beaef2c757a4354af91698685d5232404f1aeeb233529c7a5",
+                "sha256:f8c8ea764d7b6fd801e7f5486e3edd32ca991d506186f1923a01fc072e33c271"
             ],
-            "version": "==1.4.3"
+            "version": "==1.4.4"
         },
         "feedparser": {
             "hashes": [
@@ -331,40 +332,46 @@
         },
         "lxml": {
             "hashes": [
-                "sha256:05a444b207901a68a6526948c7cc8f9fe6d6f24c70781488e32fd74ff5996e3f",
-                "sha256:08fc93257dcfe9542c0a6883a25ba4971d78297f63d7a5a26ffa34861ca78730",
-                "sha256:107781b213cf7201ec3806555657ccda67b1fccc4261fb889ef7fc56976db81f",
-                "sha256:121b665b04083a1e85ff1f5243d4a93aa1aaba281bc12ea334d5a187278ceaf1",
-                "sha256:1fa21263c3aba2b76fd7c45713d4428dbcc7644d73dcf0650e9d344e433741b3",
-                "sha256:2b30aa2bcff8e958cd85d907d5109820b01ac511eae5b460803430a7404e34d7",
-                "sha256:4b4a111bcf4b9c948e020fd207f915c24a6de3f1adc7682a2d92660eb4e84f1a",
-                "sha256:5591c4164755778e29e69b86e425880f852464a21c7bb53c7ea453bbe2633bbe",
-                "sha256:59daa84aef650b11bccd18f99f64bfe44b9f14a08a28259959d33676554065a1",
-                "sha256:5a9c8d11aa2c8f8b6043d845927a51eb9102eb558e3f936df494e96393f5fd3e",
-                "sha256:5dd20538a60c4cc9a077d3b715bb42307239fcd25ef1ca7286775f95e9e9a46d",
-                "sha256:74f48ec98430e06c1fa8949b49ebdd8d27ceb9df8d3d1c92e1fdc2773f003f20",
-                "sha256:786aad2aa20de3dbff21aab86b2fb6a7be68064cbbc0219bde414d3a30aa47ae",
-                "sha256:7ad7906e098ccd30d8f7068030a0b16668ab8aa5cda6fcd5146d8d20cbaa71b5",
-                "sha256:80a38b188d20c0524fe8959c8ce770a8fdf0e617c6912d23fc97c68301bb9aba",
-                "sha256:8f0ec6b9b3832e0bd1d57af41f9238ea7709bbd7271f639024f2fc9d3bb01293",
-                "sha256:92282c83547a9add85ad658143c76a64a8d339028926d7dc1998ca029c88ea6a",
-                "sha256:94150231f1e90c9595ccc80d7d2006c61f90a5995db82bccbca7944fd457f0f6",
-                "sha256:9dc9006dcc47e00a8a6a029eb035c8f696ad38e40a27d073a003d7d1443f5d88",
-                "sha256:a76979f728dd845655026ab991df25d26379a1a8fc1e9e68e25c7eda43004bed",
-                "sha256:aa8eba3db3d8761db161003e2d0586608092e217151d7458206e243be5a43843",
-                "sha256:bea760a63ce9bba566c23f726d72b3c0250e2fa2569909e2d83cda1534c79443",
-                "sha256:c3f511a3c58676147c277eff0224c061dd5a6a8e1373572ac817ac6324f1b1e0",
-                "sha256:c9d317efde4bafbc1561509bfa8a23c5cab66c44d49ab5b63ff690f5159b2304",
-                "sha256:cc411ad324a4486b142c41d9b2b6a722c534096963688d879ea6fa8a35028258",
-                "sha256:cdc13a1682b2a6241080745b1953719e7fe0850b40a5c71ca574f090a1391df6",
-                "sha256:cfd7c5dd3c35c19cec59c63df9571c67c6d6e5c92e0fe63517920e97f61106d1",
-                "sha256:e1cacf4796b20865789083252186ce9dc6cc59eca0c2e79cca332bdff24ac481",
-                "sha256:e70d4e467e243455492f5de463b72151cc400710ac03a0678206a5f27e79ddef",
-                "sha256:ecc930ae559ea8a43377e8b60ca6f8d61ac532fc57efb915d899de4a67928efd",
-                "sha256:f161af26f596131b63b236372e4ce40f3167c1b5b5d459b29d2514bd8c9dc9ee"
-            ],
-            "index": "pypi",
-            "version": "==4.5.2"
+                "sha256:098fb713b31050463751dcc694878e1d39f316b86366fb9fe3fbbe5396ac9fab",
+                "sha256:0e89f5d422988c65e6936e4ec0fe54d6f73f3128c80eb7ecc3b87f595523607b",
+                "sha256:189ad47203e846a7a4951c17694d845b6ade7917c47c64b29b86526eefc3adf5",
+                "sha256:1d87936cb5801c557f3e981c9c193861264c01209cb3ad0964a16310ca1b3301",
+                "sha256:211b3bcf5da70c2d4b84d09232534ad1d78320762e2c59dedc73bf01cb1fc45b",
+                "sha256:2358809cc64394617f2719147a58ae26dac9e21bae772b45cfb80baa26bfca5d",
+                "sha256:23c83112b4dada0b75789d73f949dbb4e8f29a0a3511647024a398ebd023347b",
+                "sha256:24e811118aab6abe3ce23ff0d7d38932329c513f9cef849d3ee88b0f848f2aa9",
+                "sha256:2d5896ddf5389560257bbe89317ca7bcb4e54a02b53a3e572e1ce4226512b51b",
+                "sha256:2d6571c48328be4304aee031d2d5046cbc8aed5740c654575613c5a4f5a11311",
+                "sha256:2e311a10f3e85250910a615fe194839a04a0f6bc4e8e5bb5cac221344e3a7891",
+                "sha256:302160eb6e9764168e01d8c9ec6becddeb87776e81d3fcb0d97954dd51d48e0a",
+                "sha256:3a7a380bfecc551cfd67d6e8ad9faa91289173bdf12e9cfafbd2bdec0d7b1ec1",
+                "sha256:3d9b2b72eb0dbbdb0e276403873ecfae870599c83ba22cadff2db58541e72856",
+                "sha256:475325e037fdf068e0c2140b818518cf6bc4aa72435c407a798b2db9f8e90810",
+                "sha256:4b7572145054330c8e324a72d808c8c8fbe12be33368db28c39a255ad5f7fb51",
+                "sha256:4fff34721b628cce9eb4538cf9a73d02e0f3da4f35a515773cce6f5fe413b360",
+                "sha256:56eff8c6fb7bc4bcca395fdff494c52712b7a57486e4fbde34c31bb9da4c6cc4",
+                "sha256:573b2f5496c7e9f4985de70b9bbb4719ffd293d5565513e04ac20e42e6e5583f",
+                "sha256:7ecaef52fd9b9535ae5f01a1dd2651f6608e4ec9dc136fc4dfe7ebe3c3ddb230",
+                "sha256:803a80d72d1f693aa448566be46ffd70882d1ad8fc689a2e22afe63035eb998a",
+                "sha256:8862d1c2c020cb7a03b421a9a7b4fe046a208db30994fc8ff68c627a7915987f",
+                "sha256:9b06690224258db5cd39a84e993882a6874676f5de582da57f3df3a82ead9174",
+                "sha256:a71400b90b3599eb7bf241f947932e18a066907bf84617d80817998cee81e4bf",
+                "sha256:bb252f802f91f59767dcc559744e91efa9df532240a502befd874b54571417bd",
+                "sha256:be1ebf9cc25ab5399501c9046a7dcdaa9e911802ed0e12b7d620cd4bbf0518b3",
+                "sha256:be7c65e34d1b50ab7093b90427cbc488260e4b3a38ef2435d65b62e9fa3d798a",
+                "sha256:c0dac835c1a22621ffa5e5f999d57359c790c52bbd1c687fe514ae6924f65ef5",
+                "sha256:c152b2e93b639d1f36ec5a8ca24cde4a8eefb2b6b83668fcd8e83a67badcb367",
+                "sha256:d182eada8ea0de61a45a526aa0ae4bcd222f9673424e65315c35820291ff299c",
+                "sha256:d18331ea905a41ae71596502bd4c9a2998902328bbabd29e3d0f5f8569fabad1",
+                "sha256:d20d32cbb31d731def4b1502294ca2ee99f9249b63bc80e03e67e8f8e126dea8",
+                "sha256:d4ad7fd3269281cb471ad6c7bafca372e69789540d16e3755dd717e9e5c9d82f",
+                "sha256:d6f8c23f65a4bfe4300b85f1f40f6c32569822d08901db3b6454ab785d9117cc",
+                "sha256:d84d741c6e35c9f3e7406cb7c4c2e08474c2a6441d59322a00dcae65aac6315d",
+                "sha256:e65c221b2115a91035b55a593b6eb94aa1206fa3ab374f47c6dc10d364583ff9",
+                "sha256:f98b6f256be6cec8dd308a8563976ddaff0bdc18b730720f6f4bee927ffe926f"
+            ],
+            "index": "pypi",
+            "version": "==4.6.1"
         },
         "markdownify": {
             "hashes": [
@@ -415,11 +422,11 @@
         },
         "more-itertools": {
             "hashes": [
-                "sha256:6f83822ae94818eae2612063a5101a7311e68ae8002005b5e05f03fd74a86a20",
-                "sha256:9b30f12df9393f0d28af9210ff8efe48d10c94f73e5daf886f10c4b0b0b4f03c"
+                "sha256:8e1a2a43b2f2727425f2b5839587ae37093f19153dc26c0927d1048ff6557330",
+                "sha256:b3a9005928e5bed54076e6e549c792b306fddfe72b2d1d22dd63d42d5d3899cf"
             ],
             "index": "pypi",
-            "version": "==8.5.0"
+            "version": "==8.6.0"
         },
         "multidict": {
             "hashes": [
@@ -510,11 +517,11 @@
         },
         "pygments": {
             "hashes": [
-                "sha256:307543fe65c0947b126e83dd5a61bd8acbd84abec11f43caebaf5534cbc17998",
-                "sha256:926c3f319eda178d1bd90851e4317e6d8cdb5e292a3386aac9bd75eca29cf9c7"
+                "sha256:381985fcc551eb9d37c52088a32914e00517e57f4a21609f48141ba08e193fa0",
+                "sha256:88a0bbcd659fcb9573703957c6b9cff9fab7295e6e76db54c9d00ae42df32773"
             ],
             "markers": "python_version >= '3.5'",
-            "version": "==2.7.1"
+            "version": "==2.7.2"
         },
         "pyparsing": {
             "hashes": [
@@ -534,10 +541,10 @@
         },
         "pytz": {
             "hashes": [
-                "sha256:a494d53b6d39c3c6e44c3bec237336e14305e4f29bbf800b599253057fbb79ed",
-                "sha256:c35965d010ce31b23eeb663ed3cc8c906275d6be1a34393a1d73a41febf4a048"
+                "sha256:3e6b7dd2d1e0a59084bcee14a17af60c5c562cdc16d828e8eba2e683d3a7e268",
+                "sha256:5c55e189b682d420be27c6995ba6edce0c0a77dd67bfbe2ae6607134d5851ffd"
             ],
-            "version": "==2020.1"
+            "version": "==2020.4"
         },
         "pyyaml": {
             "hashes": [
@@ -566,19 +573,19 @@
         },
         "requests": {
             "hashes": [
-                "sha256:b3559a131db72c33ee969480840fff4bb6dd111de7dd27c8ee1f820f4f00231b",
-                "sha256:fe75cc94a9443b9246fc7049224f75604b113c36acb93f87b80ed42c44cbb898"
+                "sha256:7f1a0b932f4a60a1a65caa4263921bb7d9ee911957e0ae4a23a6dd08185ad5f8",
+                "sha256:e786fa28d8c9154e6a4de5d46a1d921b8749f8b74e28bde23768e5e16eece998"
             ],
             "index": "pypi",
-            "version": "==2.24.0"
+            "version": "==2.25.0"
         },
         "sentry-sdk": {
             "hashes": [
-                "sha256:c9c0fa1412bad87104c4eee8dd36c7bbf60b0d92ae917ab519094779b22e6d9a",
-                "sha256:e159f7c919d19ae86e5a4ff370fccc45149fab461fbeb93fb5a735a0b33a9cb1"
+                "sha256:81d7a5d8ca0b13a16666e8280127b004565aa988bfeec6481e98a8601804b215",
+                "sha256:fd48f627945511c140546939b4d73815be4860cd1d2b9149577d7f6563e7bd60"
             ],
             "index": "pypi",
-            "version": "==0.17.8"
+            "version": "==0.19.3"
         },
         "six": {
             "hashes": [
@@ -597,10 +604,10 @@
         },
         "sortedcontainers": {
             "hashes": [
-                "sha256:4e73a757831fc3ca4de2859c422564239a31d8213d09a2a666e375807034d2ba",
-                "sha256:c633ebde8580f241f274c1f8994a665c0e54a17724fecd0cae2f079e09c36d3f"
+                "sha256:37257a32add0a3ee490bb170b599e93095eed89a55da91fa9f48753ea12fd73f",
+                "sha256:59cc937650cf60d677c16775597c89a960658a09cf7c1a668f86e1e4464b10a1"
             ],
-            "version": "==2.2.2"
+            "version": "==2.3.0"
         },
         "soupsieve": {
             "hashes": [
@@ -676,34 +683,34 @@
         },
         "urllib3": {
             "hashes": [
-                "sha256:91056c15fa70756691db97756772bb1eb9678fa585d9184f24534b100dc60f4a",
-                "sha256:e7983572181f5e1522d9c98453462384ee92a0be7fac5f1413a1e35c56cc0461"
+                "sha256:19188f96923873c92ccb987120ec4acaa12f0461fa9ce5d3d0772bc965a39e08",
+                "sha256:d8ff90d979214d7b4f8ce956e80f4028fc6860e4431f731ea4a8c08f23f99473"
             ],
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4' and python_version < '4'",
-            "version": "==1.25.10"
+            "version": "==1.26.2"
         },
         "yarl": {
             "hashes": [
-                "sha256:04a54f126a0732af75e5edc9addeaa2113e2ca7c6fce8974a63549a70a25e50e",
-                "sha256:3cc860d72ed989f3b1f3abbd6ecf38e412de722fb38b8f1b1a086315cf0d69c5",
-                "sha256:5d84cc36981eb5a8533be79d6c43454c8e6a39ee3118ceaadbd3c029ab2ee580",
-                "sha256:5e447e7f3780f44f890360ea973418025e8c0cdcd7d6a1b221d952600fd945dc",
-                "sha256:61d3ea3c175fe45f1498af868879c6ffeb989d4143ac542163c45538ba5ec21b",
-                "sha256:67c5ea0970da882eaf9efcf65b66792557c526f8e55f752194eff8ec722c75c2",
-                "sha256:6f6898429ec3c4cfbef12907047136fd7b9e81a6ee9f105b45505e633427330a",
-                "sha256:7ce35944e8e61927a8f4eb78f5bc5d1e6da6d40eadd77e3f79d4e9399e263921",
-                "sha256:b7c199d2cbaf892ba0f91ed36d12ff41ecd0dde46cbf64ff4bfe997a3ebc925e",
-                "sha256:c15d71a640fb1f8e98a1423f9c64d7f1f6a3a168f803042eaf3a5b5022fde0c1",
-                "sha256:c22607421f49c0cb6ff3ed593a49b6a99c6ffdeaaa6c944cdda83c2393c8864d",
-                "sha256:c604998ab8115db802cc55cb1b91619b2831a6128a62ca7eea577fc8ea4d3131",
-                "sha256:d088ea9319e49273f25b1c96a3763bf19a882cff774d1792ae6fba34bd40550a",
-                "sha256:db9eb8307219d7e09b33bcb43287222ef35cbcf1586ba9472b0a4b833666ada1",
-                "sha256:e31fef4e7b68184545c3d68baec7074532e077bd1906b040ecfba659737df188",
-                "sha256:e32f0fb443afcfe7f01f95172b66f279938fbc6bdaebe294b0ff6747fb6db020",
-                "sha256:fcbe419805c9b20db9a51d33b942feddbf6e7fb468cb20686fd7089d4164c12a"
+                "sha256:040b237f58ff7d800e6e0fd89c8439b841f777dd99b4a9cca04d6935564b9409",
+                "sha256:17668ec6722b1b7a3a05cc0167659f6c95b436d25a36c2d52db0eca7d3f72593",
+                "sha256:3a584b28086bc93c888a6c2aa5c92ed1ae20932f078c46509a66dce9ea5533f2",
+                "sha256:4439be27e4eee76c7632c2427ca5e73703151b22cae23e64adb243a9c2f565d8",
+                "sha256:48e918b05850fffb070a496d2b5f97fc31d15d94ca33d3d08a4f86e26d4e7c5d",
+                "sha256:9102b59e8337f9874638fcfc9ac3734a0cfadb100e47d55c20d0dc6087fb4692",
+                "sha256:9b930776c0ae0c691776f4d2891ebc5362af86f152dd0da463a6614074cb1b02",
+                "sha256:b3b9ad80f8b68519cc3372a6ca85ae02cc5a8807723ac366b53c0f089db19e4a",
+                "sha256:bc2f976c0e918659f723401c4f834deb8a8e7798a71be4382e024bcc3f7e23a8",
+                "sha256:c22c75b5f394f3d47105045ea551e08a3e804dc7e01b37800ca35b58f856c3d6",
+                "sha256:c52ce2883dc193824989a9b97a76ca86ecd1fa7955b14f87bf367a61b6232511",
+                "sha256:ce584af5de8830d8701b8979b18fcf450cef9a382b1a3c8ef189bedc408faf1e",
+                "sha256:da456eeec17fa8aa4594d9a9f27c0b1060b6a75f2419fe0c00609587b2695f4a",
+                "sha256:db6db0f45d2c63ddb1a9d18d1b9b22f308e52c83638c26b422d520a815c4b3fb",
+                "sha256:df89642981b94e7db5596818499c4b2219028f2a528c9c37cc1de45bf2fd3a3f",
+                "sha256:f18d68f2be6bf0e89f1521af2b1bb46e66ab0018faafa81d70f358153170a317",
+                "sha256:f379b7f83f23fe12823085cd6b906edc49df969eb99757f58ff382349a3303c6"
             ],
             "markers": "python_version >= '3.5'",
-            "version": "==1.6.0"
+            "version": "==1.5.1"
         }
     },
     "develop": {
@@ -716,11 +723,11 @@
         },
         "attrs": {
             "hashes": [
-                "sha256:26b54ddbbb9ee1d34d5d3668dd37d6cf74990ab23c828c2888dccdceee395594",
-                "sha256:fce7fc47dfc976152e82d53ff92fa0407700c21acd20886a13777a0d20e655dc"
+                "sha256:31b2eced602aa8423c2aea9c76a724617ed67cf9513173fd3a4f03e3a929c7e6",
+                "sha256:832aa3cde19744e49938b91fea06d69ecb9e649c93ba974535d08ad92164f700"
             ],
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==20.2.0"
+            "version": "==20.3.0"
         },
         "cfgv": {
             "hashes": [
@@ -786,19 +793,19 @@
         },
         "flake8": {
             "hashes": [
-                "sha256:15e351d19611c887e482fb960eae4d44845013cc142d42896e9862f775d8cf5c",
-                "sha256:f04b9fcbac03b0a3e58c0ab3a0ecc462e023a9faf046d57794184028123aa208"
+                "sha256:749dbbd6bfd0cf1318af27bf97a14e28e5ff548ef8e5b1566ccfb25a11e7c839",
+                "sha256:aadae8761ec651813c24be05c6f7b4680857ef6afaae4651a4eccaef97ce6c3b"
             ],
             "index": "pypi",
-            "version": "==3.8.3"
+            "version": "==3.8.4"
         },
         "flake8-annotations": {
             "hashes": [
-                "sha256:09fe1aa3f40cb8fef632a0ab3614050a7584bb884b6134e70cf1fc9eeee642fa",
-                "sha256:5bda552f074fd6e34276c7761756fa07d824ffac91ce9c0a8555eb2bc5b92d7a"
+                "sha256:0bcebb0792f1f96d617ded674dca7bf64181870bfe5dace353a1483551f8e5f1",
+                "sha256:bebd11a850f6987a943ce8cdff4159767e0f5f89b3c88aca64680c2175ee02df"
             ],
             "index": "pypi",
-            "version": "==2.4.0"
+            "version": "==2.4.1"
         },
         "flake8-bugbear": {
             "hashes": [
@@ -856,11 +863,11 @@
         },
         "identify": {
             "hashes": [
-                "sha256:7c22c384a2c9b32c5cc891d13f923f6b2653aa83e2d75d8f79be240d6c86c4f4",
-                "sha256:da683bfb7669fa749fc7731f378229e2dbf29a1d1337cbde04106f02236eb29d"
+                "sha256:5dd84ac64a9a115b8e0b27d1756b244b882ad264c3c423f42af8235a6e71ca12",
+                "sha256:c9504ba6a043ee2db0a9d69e43246bc138034895f6338d5aed1b41e4a73b1513"
             ],
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==1.5.5"
+            "version": "==1.5.9"
         },
         "mccabe": {
             "hashes": [
@@ -886,11 +893,11 @@
         },
         "pre-commit": {
             "hashes": [
-                "sha256:810aef2a2ba4f31eed1941fc270e72696a1ad5590b9751839c90807d0fff6b9a",
-                "sha256:c54fd3e574565fe128ecc5e7d2f91279772ddb03f8729645fa812fe809084a70"
+                "sha256:22e6aa3bd571debb01eb7d34483f11c01b65237be4eebbf30c3d4fb65762d315",
+                "sha256:905ebc9b534b991baec87e934431f2d0606ba27f2b90f7f652985f5a5b8b6ae6"
             ],
             "index": "pypi",
-            "version": "==2.7.1"
+            "version": "==2.8.2"
         },
         "pycodestyle": {
             "hashes": [
@@ -950,26 +957,19 @@
         },
         "toml": {
             "hashes": [
-                "sha256:926b612be1e5ce0634a2ca03470f95169cf16f939018233a670519cb4ac58b0f",
-                "sha256:bda89d5935c2eac546d648028b9901107a595863cb36bae0c73ac804a9b4ce88"
+                "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b",
+                "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"
             ],
-            "version": "==0.10.1"
-        },
-        "unittest-xml-reporting": {
-            "hashes": [
-                "sha256:7bf515ea8cb244255a25100cd29db611a73f8d3d0aaf672ed3266307e14cc1ca",
-                "sha256:984cebba69e889401bfe3adb9088ca376b3a1f923f0590d005126c1bffd1a695"
-            ],
-            "index": "pypi",
-            "version": "==3.0.4"
+            "markers": "python_version >= '2.6' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==0.10.2"
         },
         "virtualenv": {
             "hashes": [
-                "sha256:43add625c53c596d38f971a465553f6318decc39d98512bc100fa1b1e839c8dc",
-                "sha256:e0305af10299a7fb0d69393d8f04cb2965dda9351140d11ac8db4e5e3970451b"
+                "sha256:b0011228208944ce71052987437d3843e05690b2f23d1c7da4263fde104c97a2",
+                "sha256:b8d6110f493af256a40d65e29846c69340a947669eec8ce784fcf3dd3af28380"
             ],
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
-            "version": "==20.0.31"
+            "version": "==20.1.0"
         }
     }
 }
diff --git a/README.md b/README.md
index b37ece296..482ada08c 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,8 @@
 # Python Utility Bot
 
 [![Discord](https://img.shields.io/static/v1?label=Python%20Discord&logo=discord&message=%3E100k%20members&color=%237289DA&logoColor=white)](https://discord.gg/2B963hn)
-[![Build Status](https://dev.azure.com/python-discord/Python%20Discord/_apis/build/status/Bot?branchName=master)](https://dev.azure.com/python-discord/Python%20Discord/_build/latest?definitionId=1&branchName=master)
-[![Tests](https://img.shields.io/azure-devops/tests/python-discord/Python%20Discord/1?compact_message)](https://dev.azure.com/python-discord/Python%20Discord/_apis/build/status/Bot?branchName=master)
-[![Coverage](https://img.shields.io/azure-devops/coverage/python-discord/Python%20Discord/1/master)](https://dev.azure.com/python-discord/Python%20Discord/_apis/build/status/Bot?branchName=master)
+![Lint, Test, Build](https://github.com/python-discord/bot/workflows/Lint,%20Test,%20Build/badge.svg?branch=master)
+[![Coverage Status](https://coveralls.io/repos/github/python-discord/bot/badge.svg)](https://coveralls.io/github/python-discord/bot)
 [![License](https://img.shields.io/github/license/python-discord/bot)](LICENSE)
 [![Website](https://img.shields.io/badge/website-visit-brightgreen)](https://pythondiscord.com)
 
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
deleted file mode 100644
index 188ad7f93..000000000
--- a/azure-pipelines.yml
+++ /dev/null
@@ -1,106 +0,0 @@
-# https://aka.ms/yaml
-
-variables:
-  PIP_NO_CACHE_DIR: false
-  PIP_USER: 1
-  PIPENV_HIDE_EMOJIS: 1
-  PIPENV_IGNORE_VIRTUALENVS: 1
-  PIPENV_NOSPIN: 1
-  PRE_COMMIT_HOME: $(Pipeline.Workspace)/pre-commit-cache
-  PYTHONUSERBASE: $(Pipeline.Workspace)/py-user-base
-
-jobs:
-  - job: test
-    displayName: 'Lint & Test'
-    pool:
-      vmImage: ubuntu-18.04
-
-    variables:
-      BOT_API_KEY: foo
-      BOT_SENTRY_DSN: blah
-      BOT_TOKEN: bar
-      REDDIT_CLIENT_ID: spam
-      REDDIT_SECRET: ham
-      REDIS_PASSWORD: ''
-
-    steps:
-      - task: UsePythonVersion@0
-        displayName: 'Set Python version'
-        name: python
-        inputs:
-          versionSpec: '3.8.x'
-          addToPath: true
-
-      - task: Cache@2
-        displayName: 'Restore Python environment'
-        inputs:
-          key: python | $(Agent.OS) | "$(python.pythonLocation)" | 2 | ./Pipfile | ./Pipfile.lock
-          cacheHitVar: PY_ENV_RESTORED
-          path: $(PYTHONUSERBASE)
-
-      - script: echo '##vso[task.prependpath]$(PYTHONUSERBASE)/bin'
-        displayName: 'Prepend PATH'
-
-      - script: pip install pipenv
-        displayName: 'Install pipenv'
-        condition: and(succeeded(), ne(variables.PY_ENV_RESTORED, 'true'))
-
-      - script: pipenv install --dev --deploy --system
-        displayName: 'Install project using pipenv'
-        condition: and(succeeded(), ne(variables.PY_ENV_RESTORED, 'true'))
-
-      # Create an executable shell script which replaces the original pipenv binary.
-      # The shell script ignores the first argument and executes the rest of the args as a command.
-      # It makes the `pipenv run flake8` command in the pre-commit hook work by circumventing
-      # pipenv entirely, which is too dumb to know it should use the system interpreter rather than
-      # creating a new venv.
-      - script: |
-          printf '%s\n%s' '#!/bin/bash' '"${@:2}"' > $(python.pythonLocation)/bin/pipenv \
-          && chmod +x $(python.pythonLocation)/bin/pipenv
-        displayName: 'Mock pipenv binary'
-
-      - task: Cache@2
-        displayName: 'Restore pre-commit environment'
-        inputs:
-          key: pre-commit | "$(python.pythonLocation)" | 0 | .pre-commit-config.yaml
-          path: $(PRE_COMMIT_HOME)
-
-      # pre-commit's venv doesn't allow user installs - not that they're really needed anyway.
-      - script: export PIP_USER=0; pre-commit run --all-files
-        displayName: 'Run pre-commit hooks'
-
-      - script: coverage run -m xmlrunner
-        displayName: Run tests
-
-      - script: coverage report -m && coverage xml -o coverage.xml
-        displayName: Generate test coverage report
-
-      - task: PublishCodeCoverageResults@1
-        displayName: 'Publish Coverage Results'
-        condition: succeededOrFailed()
-        inputs:
-          codeCoverageTool: Cobertura
-          summaryFileLocation: coverage.xml
-
-      - task: PublishTestResults@2
-        condition: succeededOrFailed()
-        displayName: 'Publish Test Results'
-        inputs:
-          testResultsFiles: '**/TEST-*.xml'
-          testRunTitle: 'Bot Test Results'
-
-  - job: build
-    displayName: 'Build & Push Container'
-    dependsOn: 'test'
-    condition: and(succeeded(), ne(variables['Build.Reason'], 'PullRequest'), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
-
-    steps:
-      - task: Docker@2
-        displayName: 'Build & Push Container'
-        inputs:
-          containerRegistry: 'DockerHub'
-          repository: 'pythondiscord/bot'
-          command: 'buildAndPush'
-          Dockerfile: 'Dockerfile'
-          buildContext: '.'
-          tags: 'latest'
-- 
cgit v1.2.3


From 8588d2dbdb44bc5b48e97ae511474ca19d129ee5 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Sat, 14 Nov 2020 11:03:54 +0100
Subject: Add CI dependency coveralls to our Pipfile

The dependency `coveralls` was installed directly in GitHub Actions, as
it's not required for local dev environments. However, it's a small
package and there's value in keeping all our dependency specifications
in one place. That's why I've moved it to the [dev] section of our
Pipfile.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/lint-test-build.yml |  4 +--
 Pipfile                               |  1 +
 Pipfile.lock                          | 54 ++++++++++++++++++++++++++++++++++-
 3 files changed, 55 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
index dc472ec8e..05783e813 100644
--- a/.github/workflows/lint-test-build.yml
+++ b/.github/workflows/lint-test-build.yml
@@ -90,9 +90,7 @@ jobs:
       - name: Publish coverage report to coveralls.io
         env:
             GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          pip install coveralls
-          coveralls
+        run: coveralls
 
   build-and-push:
     needs: lint-test
diff --git a/Pipfile b/Pipfile
index b8a542653..0730b9150 100644
--- a/Pipfile
+++ b/Pipfile
@@ -39,6 +39,7 @@ flake8-tidy-imports = "~=4.0"
 flake8-todo = "~=0.7"
 pep8-naming = "~=0.9"
 pre-commit = "~=2.1"
+coveralls = "~=2.1"
 
 [requires]
 python_version = "3.8"
diff --git a/Pipfile.lock b/Pipfile.lock
index ebd7f20fd..6a6a1aaf6 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "906565a018f17354f8f5f1508505fdac1f52b522caab8d539654136eb3194f50"
+            "sha256": "ca6b100f7ee2e6e01eec413a754fc11be064e965a255b2c4927d4a2dd1c451ec"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -729,6 +729,13 @@
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
             "version": "==20.3.0"
         },
+        "certifi": {
+            "hashes": [
+                "sha256:1f422849db327d534e3d0c5f02a263458c3955ec0aae4ff09b95f195c59f4edd",
+                "sha256:f05def092c44fbf25834a51509ef6e631dc19765ab8a57b4e7ab85531f0a9cf4"
+            ],
+            "version": "==2020.11.8"
+        },
         "cfgv": {
             "hashes": [
                 "sha256:32e43d604bbe7896fe7c248a9c2276447dbef840feb28fe20494f62af110211d",
@@ -737,6 +744,13 @@
             "markers": "python_full_version >= '3.6.1'",
             "version": "==3.2.0"
         },
+        "chardet": {
+            "hashes": [
+                "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae",
+                "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"
+            ],
+            "version": "==3.0.4"
+        },
         "coverage": {
             "hashes": [
                 "sha256:0203acd33d2298e19b57451ebb0bed0ab0c602e5cf5a818591b4918b1f97d516",
@@ -777,6 +791,14 @@
             "index": "pypi",
             "version": "==5.3"
         },
+        "coveralls": {
+            "hashes": [
+                "sha256:4430b862baabb3cf090d36d84d331966615e4288d8a8c5957e0fd456d0dd8bd6",
+                "sha256:b3b60c17b03a0dee61952a91aed6f131e0b2ac8bd5da909389c53137811409e1"
+            ],
+            "index": "pypi",
+            "version": "==2.1.2"
+        },
         "distlib": {
             "hashes": [
                 "sha256:8c09de2c67b3e7deef7184574fc060ab8a793e7adbb183d942c389c8b13c52fb",
@@ -784,6 +806,12 @@
             ],
             "version": "==0.3.1"
         },
+        "docopt": {
+            "hashes": [
+                "sha256:49b3a825280bd66b3aa83585ef59c4a8c82f2c8a522dbe754a8bc8d08c85c491"
+            ],
+            "version": "==0.6.2"
+        },
         "filelock": {
             "hashes": [
                 "sha256:18d82244ee114f543149c66a6e0c14e9c4f8a1044b5cdaadd0f82159d6a6ff59",
@@ -869,6 +897,14 @@
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
             "version": "==1.5.9"
         },
+        "idna": {
+            "hashes": [
+                "sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6",
+                "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==2.10"
+        },
         "mccabe": {
             "hashes": [
                 "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42",
@@ -940,6 +976,14 @@
             "index": "pypi",
             "version": "==5.3.1"
         },
+        "requests": {
+            "hashes": [
+                "sha256:7f1a0b932f4a60a1a65caa4263921bb7d9ee911957e0ae4a23a6dd08185ad5f8",
+                "sha256:e786fa28d8c9154e6a4de5d46a1d921b8749f8b74e28bde23768e5e16eece998"
+            ],
+            "index": "pypi",
+            "version": "==2.25.0"
+        },
         "six": {
             "hashes": [
                 "sha256:30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259",
@@ -963,6 +1007,14 @@
             "markers": "python_version >= '2.6' and python_version not in '3.0, 3.1, 3.2, 3.3'",
             "version": "==0.10.2"
         },
+        "urllib3": {
+            "hashes": [
+                "sha256:19188f96923873c92ccb987120ec4acaa12f0461fa9ce5d3d0772bc965a39e08",
+                "sha256:d8ff90d979214d7b4f8ce956e80f4028fc6860e4431f731ea4a8c08f23f99473"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4' and python_version < '4'",
+            "version": "==1.26.2"
+        },
         "virtualenv": {
             "hashes": [
                 "sha256:b0011228208944ce71052987437d3843e05690b2f23d1c7da4263fde104c97a2",
-- 
cgit v1.2.3


From 5d50adf20946665d92df2e9f2551f3db1946d5b0 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Sat, 14 Nov 2020 11:07:18 +0100
Subject: Stop Checkout Actions from persisting credentials

By default, the Checkout Actions persists the credentials in the
environment. As our Actions will also run for PRs made from a fork, we
don't want to persist credentials in such a way.

I've also:
- Ported a comment on PIP_USER and pre-commit from the azure configs
- Removed unnecessary id for the pre-commit caching step

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/lint-test-build.yml | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
index 05783e813..9101574ae 100644
--- a/.github/workflows/lint-test-build.yml
+++ b/.github/workflows/lint-test-build.yml
@@ -33,8 +33,12 @@ jobs:
       - name: Add custom PYTHONUSERBASE to PATH
         run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
 
+      # We don't want to persist credentials, as our GitHub Action
+      # may be run when a PR is made from a fork.
       - name: Checkout repository
         uses: actions/checkout@v2
+        with:
+          persist-credentials: false
 
       - name: Setup python
         id: python
@@ -59,14 +63,15 @@ jobs:
 
       - name: Pre-commit Environment Caching
         uses: actions/cache@v2
-        id: pre_commit_cache
         with:
           path: ${{ env.PRE_COMMIT_HOME }}
           key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
           ${{ steps.python.outputs.python-version }}-\
           ${{ hashFiles('./.pre-commit-config.yaml') }}"
 
-      # We will not run `flake8` here, as we will use a separate flake8 action
+      # We will not run `flake8` here, as we will use a separate flake8
+      # action. As pre-commit does not support user installs, and we don't
+      # really need it, we set PIP_USER=0.
       - name: Run pre-commit hooks
         run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
 
-- 
cgit v1.2.3


From 135ecf50138ade058539c07641c03c1db2d5c11f Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Sat, 14 Nov 2020 19:32:32 +0100
Subject: Set flake8 action checkName to correct value

The `checkName` value of this action needs to have the same value as the name of the job.

Co-authored-by: Joe Banks <joseph@josephbanks.me>
---
 .github/workflows/lint-test-build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
index 9101574ae..a6f7df45c 100644
--- a/.github/workflows/lint-test-build.yml
+++ b/.github/workflows/lint-test-build.yml
@@ -79,7 +79,7 @@ jobs:
       - name: Run flake8
         uses: julianwachholz/flake8-action@v1
         with:
-          checkName: lint
+          checkName: lint-test
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-- 
cgit v1.2.3


From 7f3dee18cfb4aa0e94a2422b0221121f39170981 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Sat, 14 Nov 2020 19:36:45 +0100
Subject: Remove codeql analysis as it had little effect

The codeql analysis action we had proved to add little value to our test
suite and has been removed.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/codeql-analysis.yml | 32 --------------------------------
 1 file changed, 32 deletions(-)
 delete mode 100644 .github/workflows/codeql-analysis.yml

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
deleted file mode 100644
index 8760b35ec..000000000
--- a/.github/workflows/codeql-analysis.yml
+++ /dev/null
@@ -1,32 +0,0 @@
-name: "Code scanning - action"
-
-on:
-  push:
-  pull_request:
-  schedule:
-    - cron: '0 12 * * *'
-
-jobs:
-  CodeQL-Build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-      with:
-        fetch-depth: 2
-
-    - run: git checkout HEAD^2
-      if: ${{ github.event_name == 'pull_request' }}
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: python
-
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
-- 
cgit v1.2.3


From dbe2f00087a7b6a3036e232b280a64c2f0a425c4 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Sat, 14 Nov 2020 19:39:20 +0100
Subject: Add documentation to GitHub Actions steps

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/lint-test-build.yml | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
index a6f7df45c..dc4ea5fd9 100644
--- a/.github/workflows/lint-test-build.yml
+++ b/.github/workflows/lint-test-build.yml
@@ -14,6 +14,7 @@ jobs:
   lint-test:
     runs-on: ubuntu-latest
     env:
+      # Dummy values for required bot environment variables
       BOT_API_KEY: foo
       BOT_SENTRY_DSN: blah
       BOT_TOKEN: bar
@@ -21,13 +22,21 @@ jobs:
       REDDIT_SECRET: ham
       REDIS_PASSWORD: ''
 
+      # Configure pip to cache dependencies and do a user install
       PIP_NO_CACHE_DIR: false
       PIP_USER: 1
+
+      # Hide the graphical elements from pipenv's output
       PIPENV_HIDE_EMOJIS: 1
-      PIPENV_IGNORE_VIRTUALENVS: 1
       PIPENV_NOSPIN: 1
-      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
+
+      # Make sure pipenv does not try reuse an environment it's running in
+      PIPENV_IGNORE_VIRTUALENVS: 1
+
+      # Specify explicit paths for python dependencies and the pre-commit
+      # environment so we know which directories to cache
       PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
+      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
 
     steps:
       - name: Add custom PYTHONUSERBASE to PATH
@@ -46,6 +55,12 @@ jobs:
         with:
           python-version: '3.8'
 
+      # This step caches our Python dependencies. To make sure we
+      # only restore a cache when the dependencies, the python version,
+      # the runner operating system, and the dependency location haven't
+      # changed, we create a cache key that is a composite of those states.
+      #
+      # Only when the context is exactly the same, we will restore the cache.
       - name: Python Dependency Caching
         uses: actions/cache@v2
         id: python_cache
@@ -55,12 +70,16 @@ jobs:
           ${{ steps.python.outputs.python-version }}-\
           ${{ hashFiles('./Pipfile', './Pipfile.lock') }}"
 
+      # Install our dependencies if we did not restore a dependency cache
       - name: Install dependencies using pipenv
         if: steps.python_cache.outputs.cache-hit != 'true'
         run: |
           pip install pipenv
           pipenv install --dev --deploy --system
 
+      # This step caches our pre-commit environment. To make sure we
+      # do create a new environment when our pre-commit setup changes,
+      # we create a cache key based on relevant factors.
       - name: Pre-commit Environment Caching
         uses: actions/cache@v2
         with:
@@ -70,12 +89,13 @@ jobs:
           ${{ hashFiles('./.pre-commit-config.yaml') }}"
 
       # We will not run `flake8` here, as we will use a separate flake8
-      # action. As pre-commit does not support user installs, and we don't
-      # really need it, we set PIP_USER=0.
+      # action. As pre-commit does not support user installs, we set
+      # PIP_USER=0 to not do a user install.
       - name: Run pre-commit hooks
         run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
 
-      # This step requires `pull_request_target` due to the use of annotations
+      # This step requires `pull_request_target`, as adding annotations
+      # requires "write" permissions to the repo.
       - name: Run flake8
         uses: julianwachholz/flake8-action@v1
         with:
-- 
cgit v1.2.3


From 98800896d14b60c567d4c6f7f1b6e2f40f3f84d3 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Sat, 14 Nov 2020 19:44:34 +0100
Subject: Push container to both DockerHub and GHCR

To make the transition easier, we push the Docker container to both
DockerHub and the GitHub Container Registry. I've also added a secondary
tag by short commit SHA.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/lint-test-build.yml | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
index dc4ea5fd9..a5a930912 100644
--- a/.github/workflows/lint-test-build.yml
+++ b/.github/workflows/lint-test-build.yml
@@ -123,6 +123,12 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
+      # Create a commit SHA-based tag for the container repositories
+      - name: Create SHA Container Tag
+        id: sha_tag
+        run: |
+          tag=$(cut -c 1-7 <<< $GITHUB_SHA)
+          echo "::set-output name=tag::$tag"
       - name: Checkout code
         uses: actions/checkout@v2
 
@@ -135,11 +141,25 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GHCR_TOKEN  }}
+
+      # This step currently pushes to both DockerHub and GHCR to
+      # make the migration easier. The DockerHub push will be
+      # removed once we've migrated to our K8s cluster.
       - name: Build and push
         uses: docker/build-push-action@v2
         with:
           context: .
           file: ./Dockerfile
           push: true
-          cache-from: type=registry,ref=pythondiscord/bot:latest
-          tags: pythondiscord/bot:latest
+          cache-from: type=registry,ref=ghcr.io/python-discord/bot:latest
+          tags: |
+            ghcr.io/python-discord/bot:latest
+            ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}
+            pythondiscord/bot:latest
+            pythondiscord/bot:${{ steps.sha_tag.outputs.tag }}
-- 
cgit v1.2.3


From a66e4e8814000b53291f5d156f774fd50c271f52 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Sun, 15 Nov 2020 02:35:31 +0100
Subject: Remove DockerHub from GitHub Actions

We don't use DockerHub anymore; let's remove it!

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/lint-test-build.yml | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
index a5a930912..c63f78ff6 100644
--- a/.github/workflows/lint-test-build.yml
+++ b/.github/workflows/lint-test-build.yml
@@ -135,12 +135,6 @@ jobs:
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v1
 
-      - name: Login to DockerHub
-        uses: docker/login-action@v1
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
       - name: Login to Github Container Registry
         uses: docker/login-action@v1
         with:
@@ -148,9 +142,9 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GHCR_TOKEN  }}
 
-      # This step currently pushes to both DockerHub and GHCR to
-      # make the migration easier. The DockerHub push will be
-      # removed once we've migrated to our K8s cluster.
+      # This step builds and pushed the container to the
+      # Github Container Registry tagged with "latest" and
+      # the short SHA of the commit.
       - name: Build and push
         uses: docker/build-push-action@v2
         with:
@@ -161,5 +155,3 @@ jobs:
           tags: |
             ghcr.io/python-discord/bot:latest
             ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}
-            pythondiscord/bot:latest
-            pythondiscord/bot:${{ steps.sha_tag.outputs.tag }}
-- 
cgit v1.2.3


From 244a72f6d716e3b0f4f5d2059a754a6abbeca673 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Sun, 15 Nov 2020 15:11:09 +0100
Subject: Use GHCR for the site container in docker-compose

The docker-compose file should pull the site container from the GitHub
Container Registry instead of DockerHub, as the latter will not receive
new container images.

Snekbox currently still pulls from DockerHub as it's not yet migrated to
GHCR.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 docker-compose.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker-compose.yml b/docker-compose.yml
index 8be5aac0e..dc89e8885 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -26,7 +26,7 @@ services:
     privileged: true
 
   web:
-    image: pythondiscord/site:latest
+    image: ghcr.io/python-discord/site:latest
     command: ["run", "--debug"]
     networks:
       default:
-- 
cgit v1.2.3


From a7f14a1e9055b1dfc794112ba353d401582e6662 Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Sun, 15 Nov 2020 19:56:24 +0000
Subject: Add Kubernetes deployment manifest

---
 deployment.yaml | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 deployment.yaml

diff --git a/deployment.yaml b/deployment.yaml
new file mode 100644
index 000000000..ca5ff5941
--- /dev/null
+++ b/deployment.yaml
@@ -0,0 +1,21 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: bot
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: bot
+  template:
+    metadata:
+      labels:
+        app: bot
+    spec:
+      containers:
+      - name: bot
+        image: ghcr.io/python-discord/bot:latest
+        imagePullPolicy: Always
+        envFrom:
+        - secretRef:
+            name: bot-env
-- 
cgit v1.2.3


From 2cba93b6b0cedf98eaf244cf42e1b3c3faf64615 Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Sun, 15 Nov 2020 19:56:51 +0000
Subject: Add deploy steps to GitHub Actions

---
 .github/workflows/lint-test-build.yml  | 157 ------------------------------
 .github/workflows/lint-test-deploy.yml | 171 +++++++++++++++++++++++++++++++++
 2 files changed, 171 insertions(+), 157 deletions(-)
 delete mode 100644 .github/workflows/lint-test-build.yml
 create mode 100644 .github/workflows/lint-test-deploy.yml

diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
deleted file mode 100644
index c63f78ff6..000000000
--- a/.github/workflows/lint-test-build.yml
+++ /dev/null
@@ -1,157 +0,0 @@
-name: Lint, Test, Build
-
-on:
-  push:
-    branches:
-      - master
-  # We use pull_request_target as we get PRs from
-  # forks, but need to be able to add annotations
-  # for our flake8 step.
-  pull_request_target:
-
-
-jobs:
-  lint-test:
-    runs-on: ubuntu-latest
-    env:
-      # Dummy values for required bot environment variables
-      BOT_API_KEY: foo
-      BOT_SENTRY_DSN: blah
-      BOT_TOKEN: bar
-      REDDIT_CLIENT_ID: spam
-      REDDIT_SECRET: ham
-      REDIS_PASSWORD: ''
-
-      # Configure pip to cache dependencies and do a user install
-      PIP_NO_CACHE_DIR: false
-      PIP_USER: 1
-
-      # Hide the graphical elements from pipenv's output
-      PIPENV_HIDE_EMOJIS: 1
-      PIPENV_NOSPIN: 1
-
-      # Make sure pipenv does not try reuse an environment it's running in
-      PIPENV_IGNORE_VIRTUALENVS: 1
-
-      # Specify explicit paths for python dependencies and the pre-commit
-      # environment so we know which directories to cache
-      PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
-      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
-
-    steps:
-      - name: Add custom PYTHONUSERBASE to PATH
-        run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
-
-      # We don't want to persist credentials, as our GitHub Action
-      # may be run when a PR is made from a fork.
-      - name: Checkout repository
-        uses: actions/checkout@v2
-        with:
-          persist-credentials: false
-
-      - name: Setup python
-        id: python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.8'
-
-      # This step caches our Python dependencies. To make sure we
-      # only restore a cache when the dependencies, the python version,
-      # the runner operating system, and the dependency location haven't
-      # changed, we create a cache key that is a composite of those states.
-      #
-      # Only when the context is exactly the same, we will restore the cache.
-      - name: Python Dependency Caching
-        uses: actions/cache@v2
-        id: python_cache
-        with:
-          path: ${{ env.PYTHONUSERBASE }}
-          key: "python-0-${{ runner.os }}-${{ env.PYTHONUSERBASE }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./Pipfile', './Pipfile.lock') }}"
-
-      # Install our dependencies if we did not restore a dependency cache
-      - name: Install dependencies using pipenv
-        if: steps.python_cache.outputs.cache-hit != 'true'
-        run: |
-          pip install pipenv
-          pipenv install --dev --deploy --system
-
-      # This step caches our pre-commit environment. To make sure we
-      # do create a new environment when our pre-commit setup changes,
-      # we create a cache key based on relevant factors.
-      - name: Pre-commit Environment Caching
-        uses: actions/cache@v2
-        with:
-          path: ${{ env.PRE_COMMIT_HOME }}
-          key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./.pre-commit-config.yaml') }}"
-
-      # We will not run `flake8` here, as we will use a separate flake8
-      # action. As pre-commit does not support user installs, we set
-      # PIP_USER=0 to not do a user install.
-      - name: Run pre-commit hooks
-        run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
-
-      # This step requires `pull_request_target`, as adding annotations
-      # requires "write" permissions to the repo.
-      - name: Run flake8
-        uses: julianwachholz/flake8-action@v1
-        with:
-          checkName: lint-test
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      # We run `coverage` using the `python` command so we can suppress
-      # irrelevant warnings in our CI output.
-      - name: Run tests and generate coverage report
-        run: |
-            python -Wignore -m coverage run -m unittest
-            coverage report -m
-
-      # This step will publish the coverage reports coveralls.io and
-      # print a "job" link in the output of the GitHub Action
-      - name: Publish coverage report to coveralls.io
-        env:
-            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: coveralls
-
-  build-and-push:
-    needs: lint-test
-    if: github.event_name != 'pull_request_target' && github.ref == 'refs/heads/master'
-    runs-on: ubuntu-latest
-
-    steps:
-      # Create a commit SHA-based tag for the container repositories
-      - name: Create SHA Container Tag
-        id: sha_tag
-        run: |
-          tag=$(cut -c 1-7 <<< $GITHUB_SHA)
-          echo "::set-output name=tag::$tag"
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Login to Github Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GHCR_TOKEN  }}
-
-      # This step builds and pushed the container to the
-      # Github Container Registry tagged with "latest" and
-      # the short SHA of the commit.
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: ./Dockerfile
-          push: true
-          cache-from: type=registry,ref=ghcr.io/python-discord/bot:latest
-          tags: |
-            ghcr.io/python-discord/bot:latest
-            ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}
diff --git a/.github/workflows/lint-test-deploy.yml b/.github/workflows/lint-test-deploy.yml
new file mode 100644
index 000000000..b4003ddc1
--- /dev/null
+++ b/.github/workflows/lint-test-deploy.yml
@@ -0,0 +1,171 @@
+name: Lint, Test, Build
+
+on:
+  push:
+    branches:
+      - master
+  # We use pull_request_target as we get PRs from
+  # forks, but need to be able to add annotations
+  # for our flake8 step.
+  pull_request_target:
+
+
+jobs:
+  lint-test:
+    runs-on: ubuntu-latest
+    env:
+      # Dummy values for required bot environment variables
+      BOT_API_KEY: foo
+      BOT_SENTRY_DSN: blah
+      BOT_TOKEN: bar
+      REDDIT_CLIENT_ID: spam
+      REDDIT_SECRET: ham
+      REDIS_PASSWORD: ''
+
+      # Configure pip to cache dependencies and do a user install
+      PIP_NO_CACHE_DIR: false
+      PIP_USER: 1
+
+      # Hide the graphical elements from pipenv's output
+      PIPENV_HIDE_EMOJIS: 1
+      PIPENV_NOSPIN: 1
+
+      # Make sure pipenv does not try reuse an environment it's running in
+      PIPENV_IGNORE_VIRTUALENVS: 1
+
+      # Specify explicit paths for python dependencies and the pre-commit
+      # environment so we know which directories to cache
+      PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
+      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
+
+    steps:
+      - name: Add custom PYTHONUSERBASE to PATH
+        run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
+
+      # We don't want to persist credentials, as our GitHub Action
+      # may be run when a PR is made from a fork.
+      - name: Checkout repository
+        uses: actions/checkout@v2
+        with:
+          persist-credentials: false
+
+      - name: Setup python
+        id: python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.8'
+
+      # This step caches our Python dependencies. To make sure we
+      # only restore a cache when the dependencies, the python version,
+      # the runner operating system, and the dependency location haven't
+      # changed, we create a cache key that is a composite of those states.
+      #
+      # Only when the context is exactly the same, we will restore the cache.
+      - name: Python Dependency Caching
+        uses: actions/cache@v2
+        id: python_cache
+        with:
+          path: ${{ env.PYTHONUSERBASE }}
+          key: "python-0-${{ runner.os }}-${{ env.PYTHONUSERBASE }}-\
+          ${{ steps.python.outputs.python-version }}-\
+          ${{ hashFiles('./Pipfile', './Pipfile.lock') }}"
+
+      # Install our dependencies if we did not restore a dependency cache
+      - name: Install dependencies using pipenv
+        if: steps.python_cache.outputs.cache-hit != 'true'
+        run: |
+          pip install pipenv
+          pipenv install --dev --deploy --system
+
+      # This step caches our pre-commit environment. To make sure we
+      # do create a new environment when our pre-commit setup changes,
+      # we create a cache key based on relevant factors.
+      - name: Pre-commit Environment Caching
+        uses: actions/cache@v2
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
+          ${{ steps.python.outputs.python-version }}-\
+          ${{ hashFiles('./.pre-commit-config.yaml') }}"
+
+      # We will not run `flake8` here, as we will use a separate flake8
+      # action. As pre-commit does not support user installs, we set
+      # PIP_USER=0 to not do a user install.
+      - name: Run pre-commit hooks
+        run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
+
+      # This step requires `pull_request_target`, as adding annotations
+      # requires "write" permissions to the repo.
+      - name: Run flake8
+        uses: julianwachholz/flake8-action@v1
+        with:
+          checkName: lint-test
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # We run `coverage` using the `python` command so we can suppress
+      # irrelevant warnings in our CI output.
+      - name: Run tests and generate coverage report
+        run: |
+            python -Wignore -m coverage run -m unittest
+            coverage report -m
+
+      # This step will publish the coverage reports coveralls.io and
+      # print a "job" link in the output of the GitHub Action
+      - name: Publish coverage report to coveralls.io
+        env:
+            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: coveralls
+
+  build-and-push:
+    needs: lint-test
+    if: github.event_name != 'pull_request_target' && github.ref == 'refs/heads/master'
+    runs-on: ubuntu-latest
+
+    steps:
+      # Create a commit SHA-based tag for the container repositories
+      - name: Create SHA Container Tag
+        id: sha_tag
+        run: |
+          tag=$(cut -c 1-7 <<< $GITHUB_SHA)
+          echo "::set-output name=tag::$tag"
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GHCR_TOKEN  }}
+
+      # This step builds and pushed the container to the
+      # Github Container Registry tagged with "latest" and
+      # the short SHA of the commit.
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          cache-from: type=registry,ref=ghcr.io/python-discord/bot:latest
+          tags: |
+            ghcr.io/python-discord/bot:latest
+            ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}
+
+      - name: Authenticate with Kubernetes
+        uses: azure/k8s-set-context@v1
+        with:
+          method: kubeconfig
+          kubeconfig: ${{ secrets.KUBECONFIG }}
+
+      - name: Deploy to Kubernetes
+        uses: Azure/k8s-deploy@v1
+        with:
+          manifests: |
+              deployment.yaml
+          images: 'ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}'
+          kubectl-version: 'latest'
-- 
cgit v1.2.3


From 6c8fed8aeb4850990f9f027401898aeb3330e732 Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Sun, 15 Nov 2020 19:57:00 +0000
Subject: Update config options with new hosts

---
 config-default.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/config-default.yml b/config-default.yml
index 8912841ff..ac67251b0 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -4,13 +4,13 @@ bot:
     sentry_dsn:  !ENV "BOT_SENTRY_DSN"
 
     redis:
-        host:  "redis"
+        host:  "redis.default.svc.cluster.local"
         port:  6379
         password: !ENV "REDIS_PASSWORD"
         use_fakeredis: false
 
     stats:
-        statsd_host: "graphite"
+        statsd_host: "graphite.default.svc.cluster.local"
         presence_update_timeout: 300
 
     cooldowns:
-- 
cgit v1.2.3


From 99ffe92dee79f4884bde4c086b2a8dc853684861 Mon Sep 17 00:00:00 2001
From: Gustav Odinger <gustav@odinger.se>
Date: Mon, 16 Nov 2020 01:10:20 +0100
Subject: Add bright green color to constants

- The color is used in the new help channel embed
---
 bot/constants.py   | 1 +
 config-default.yml | 1 +
 2 files changed, 2 insertions(+)

diff --git a/bot/constants.py b/bot/constants.py
index 731f06fed..719895567 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -248,6 +248,7 @@ class Colours(metaclass=YAMLGetter):
     soft_red: int
     soft_green: int
     soft_orange: int
+    bright_green: int
 
 
 class DuckPond(metaclass=YAMLGetter):
diff --git a/config-default.yml b/config-default.yml
index 8912841ff..cdcf914ce 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -27,6 +27,7 @@ style:
         soft_red: 0xcd6d6d
         soft_green: 0x68c290
         soft_orange: 0xf9cb54
+        bright_green: 0x01d277
 
     emojis:
         defcon_disabled: "<:defcondisabled:470326273952972810>"
-- 
cgit v1.2.3


From 6db37138c5cd6927477bd936f9009501138baa9e Mon Sep 17 00:00:00 2001
From: Gustav Odinger <gustav@odinger.se>
Date: Mon, 16 Nov 2020 01:12:08 +0100
Subject: Update help channel available message

- Adds a footer and title
- Uses a green colored embed
- Updates message to be easier to read and contain practical info for asking better questions
---
 bot/exts/help_channels.py | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index 062d4fcfe..3fbffb218 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -28,17 +28,21 @@ This is a Python help channel. You can claim your own help channel in the Python
 """
 
 AVAILABLE_MSG = f"""
-This help channel is now **available**, which means that you can claim it by simply typing your \
-question into it. Once claimed, the channel will move into the **Python Help: Occupied** category, \
-and will be yours until it has been inactive for {constants.HelpChannels.idle_minutes} minutes or \
-is closed manually with `!close`. When that happens, it will be set to **dormant** and moved into \
-the **Help: Dormant** category.
-
-Try to write the best question you can by providing a detailed description and telling us what \
-you've tried already. For more information on asking a good question, \
-check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
+**Send your question here to claim the channel**
+This channel will be dedicated to answering your question only. We’ll try to answer and help you solve the issue.
+
+**Keep in mind:**
+• It's always ok to just ask your question. You don't need permission.
+• Explain what you expect to happen and what actually happens.
+• Include a code sample and error message, if you got one.
+
+For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
 """
 
+AVAILABLE_TITLE = "✅ Available help channel"
+
+AVAILABLE_FOOTER = f"Closes after {constants.HelpChannels.idle_minutes} minutes of inactivity or when you send !close."
+
 DORMANT_MSG = f"""
 This help channel has been marked as **dormant**, and has been moved into the **Help: Dormant** \
 category at the bottom of the channel list. It is no longer possible to send messages in this \
@@ -837,7 +841,12 @@ class HelpChannels(commands.Cog):
         channel_info = f"#{channel} ({channel.id})"
         log.trace(f"Sending available message in {channel_info}.")
 
-        embed = discord.Embed(description=AVAILABLE_MSG)
+        embed = discord.Embed(
+            title=AVAILABLE_TITLE,
+            color=constants.Colours.bright_green,
+            description=AVAILABLE_MSG,
+        )
+        embed.set_footer(text=AVAILABLE_FOOTER)
 
         msg = await self.get_last_message(channel)
         if self.match_bot_embed(msg, DORMANT_MSG):
-- 
cgit v1.2.3


From 43e52d7102c2bf33186b527dc512566d08b0d1fd Mon Sep 17 00:00:00 2001
From: Gustav Odinger <gustav@odinger.se>
Date: Tue, 17 Nov 2020 23:03:11 +0100
Subject: Add green-checkmark to bot constants

---
 bot/constants.py   | 2 ++
 config-default.yml | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/bot/constants.py b/bot/constants.py
index 719895567..d2e88a744 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -355,6 +355,8 @@ class Icons(metaclass=YAMLGetter):
     voice_state_green: str
     voice_state_red: str
 
+    green_checkmark: str
+
 
 class CleanMessages(metaclass=YAMLGetter):
     section = "bot"
diff --git a/config-default.yml b/config-default.yml
index cdcf914ce..30b607f94 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -120,6 +120,8 @@ style:
         voice_state_green: "https://cdn.discordapp.com/emojis/656899770094452754.png"
         voice_state_red: "https://cdn.discordapp.com/emojis/656899769905709076.png"
 
+        green_checkmark: "https://raw.githubusercontent.com/python-discord/branding/master/icons/checkmark/green-checkmark-dist.png"
+
 
 guild:
     id: 267624335836053506
-- 
cgit v1.2.3


From 6a53035ce4aec0063ec333214e5b3e8bab66ba01 Mon Sep 17 00:00:00 2001
From: Gustav Odinger <gustav@odinger.se>
Date: Tue, 17 Nov 2020 23:04:31 +0100
Subject: Use author as the title of the embed

- Allows the icon to be centered
---
 bot/exts/help_channels.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index 3fbffb218..37bc78b26 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -842,10 +842,10 @@ class HelpChannels(commands.Cog):
         log.trace(f"Sending available message in {channel_info}.")
 
         embed = discord.Embed(
-            title=AVAILABLE_TITLE,
             color=constants.Colours.bright_green,
             description=AVAILABLE_MSG,
         )
+        embed.set_author(name=AVAILABLE_TITLE, icon_url=constants.Icons.green_checkmark)
         embed.set_footer(text=AVAILABLE_FOOTER)
 
         msg = await self.get_last_message(channel)
-- 
cgit v1.2.3


From 1e9b22b52007b087e83b4ccf2ee11cc63b991de9 Mon Sep 17 00:00:00 2001
From: Gustav Odinger <gustav@odinger.se>
Date: Tue, 17 Nov 2020 23:06:03 +0100
Subject: Update available message to sound better

- This replaces "one" with "any"
- This is supposed to read better
---
 bot/exts/help_channels.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index 37bc78b26..056434020 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -34,7 +34,7 @@ This channel will be dedicated to answering your question only. We’ll try to a
 **Keep in mind:**
 • It's always ok to just ask your question. You don't need permission.
 • Explain what you expect to happen and what actually happens.
-• Include a code sample and error message, if you got one.
+• Include a code sample and error message, if you got any.
 
 For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
 """
-- 
cgit v1.2.3


From ded520e374535b86013ca3a1de5c5eb1d3444bcb Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Wed, 18 Nov 2020 18:55:36 +0100
Subject: Pull snekbox image from GHCR in docker-compose

We're in the process of migrating snekbox to the GitHub Container
Repository, which will replace DockerHub. I've changed docker-compose to
reflect that change.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 docker-compose.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker-compose.yml b/docker-compose.yml
index dc89e8885..0002d1d56 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -18,7 +18,7 @@ services:
       - "127.0.0.1:6379:6379"
 
   snekbox:
-    image: pythondiscord/snekbox:latest
+    image: ghcr.io/python-discord/snekbox:latest
     init: true
     ipc: none
     ports:
-- 
cgit v1.2.3


From ccd0e150d34693ff0d459e7b2d0300b30192e987 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Wed, 18 Nov 2020 21:15:29 +0100
Subject: Make sure we lint the actual pull request

Unfortunately, our old setup did not actually lint the PR, as it was
running in the context of the target repository. To sidestep the issue
of using `pull_request_target` altogether, I've now changed our run of
flake8 to using it directly and having it output its errors in teh
format of Workflow Commands.

This means that our flake8 output will not be translated automatically
in annotations for the run.

In addition, I've split up the workflow into two separate files: one for
linting & testing and one for building (& deploying).

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/build.yml           |  51 +++++++++++
 .github/workflows/lint-test-build.yml | 157 ----------------------------------
 .github/workflows/lint-test.yml       | 115 +++++++++++++++++++++++++
 3 files changed, 166 insertions(+), 157 deletions(-)
 create mode 100644 .github/workflows/build.yml
 delete mode 100644 .github/workflows/lint-test-build.yml
 create mode 100644 .github/workflows/lint-test.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 000000000..fa1449c85
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,51 @@
+name: Build
+
+on:
+  workflow_run:
+    workflows: ["Lint & Test"]
+    branches:
+      - master
+    types:
+      - completed
+
+jobs:
+  build:
+    if: github.event.workflow_run.conclusion == 'success'
+    name: Build & Push
+    runs-on: ubuntu-latest
+
+    steps:
+      # Create a commit SHA-based tag for the container repositories
+      - name: Create SHA Container Tag
+        id: sha_tag
+        run: |
+          tag=$(cut -c 1-7 <<< $GITHUB_SHA)
+          echo "::set-output name=tag::$tag"
+
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GHCR_TOKEN  }}
+
+      # Build and push the container to the GitHub Container
+      # Repository. The container will be tagged as "latest"
+      # and with the short SHA of the commit.
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          cache-from: type=registry,ref=ghcr.io/python-discord/bot:latest
+          cache-to: type=inline
+          tags: |
+            ghcr.io/python-discord/bot:latest
+            ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}
diff --git a/.github/workflows/lint-test-build.yml b/.github/workflows/lint-test-build.yml
deleted file mode 100644
index c63f78ff6..000000000
--- a/.github/workflows/lint-test-build.yml
+++ /dev/null
@@ -1,157 +0,0 @@
-name: Lint, Test, Build
-
-on:
-  push:
-    branches:
-      - master
-  # We use pull_request_target as we get PRs from
-  # forks, but need to be able to add annotations
-  # for our flake8 step.
-  pull_request_target:
-
-
-jobs:
-  lint-test:
-    runs-on: ubuntu-latest
-    env:
-      # Dummy values for required bot environment variables
-      BOT_API_KEY: foo
-      BOT_SENTRY_DSN: blah
-      BOT_TOKEN: bar
-      REDDIT_CLIENT_ID: spam
-      REDDIT_SECRET: ham
-      REDIS_PASSWORD: ''
-
-      # Configure pip to cache dependencies and do a user install
-      PIP_NO_CACHE_DIR: false
-      PIP_USER: 1
-
-      # Hide the graphical elements from pipenv's output
-      PIPENV_HIDE_EMOJIS: 1
-      PIPENV_NOSPIN: 1
-
-      # Make sure pipenv does not try reuse an environment it's running in
-      PIPENV_IGNORE_VIRTUALENVS: 1
-
-      # Specify explicit paths for python dependencies and the pre-commit
-      # environment so we know which directories to cache
-      PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
-      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
-
-    steps:
-      - name: Add custom PYTHONUSERBASE to PATH
-        run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
-
-      # We don't want to persist credentials, as our GitHub Action
-      # may be run when a PR is made from a fork.
-      - name: Checkout repository
-        uses: actions/checkout@v2
-        with:
-          persist-credentials: false
-
-      - name: Setup python
-        id: python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.8'
-
-      # This step caches our Python dependencies. To make sure we
-      # only restore a cache when the dependencies, the python version,
-      # the runner operating system, and the dependency location haven't
-      # changed, we create a cache key that is a composite of those states.
-      #
-      # Only when the context is exactly the same, we will restore the cache.
-      - name: Python Dependency Caching
-        uses: actions/cache@v2
-        id: python_cache
-        with:
-          path: ${{ env.PYTHONUSERBASE }}
-          key: "python-0-${{ runner.os }}-${{ env.PYTHONUSERBASE }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./Pipfile', './Pipfile.lock') }}"
-
-      # Install our dependencies if we did not restore a dependency cache
-      - name: Install dependencies using pipenv
-        if: steps.python_cache.outputs.cache-hit != 'true'
-        run: |
-          pip install pipenv
-          pipenv install --dev --deploy --system
-
-      # This step caches our pre-commit environment. To make sure we
-      # do create a new environment when our pre-commit setup changes,
-      # we create a cache key based on relevant factors.
-      - name: Pre-commit Environment Caching
-        uses: actions/cache@v2
-        with:
-          path: ${{ env.PRE_COMMIT_HOME }}
-          key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./.pre-commit-config.yaml') }}"
-
-      # We will not run `flake8` here, as we will use a separate flake8
-      # action. As pre-commit does not support user installs, we set
-      # PIP_USER=0 to not do a user install.
-      - name: Run pre-commit hooks
-        run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
-
-      # This step requires `pull_request_target`, as adding annotations
-      # requires "write" permissions to the repo.
-      - name: Run flake8
-        uses: julianwachholz/flake8-action@v1
-        with:
-          checkName: lint-test
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      # We run `coverage` using the `python` command so we can suppress
-      # irrelevant warnings in our CI output.
-      - name: Run tests and generate coverage report
-        run: |
-            python -Wignore -m coverage run -m unittest
-            coverage report -m
-
-      # This step will publish the coverage reports coveralls.io and
-      # print a "job" link in the output of the GitHub Action
-      - name: Publish coverage report to coveralls.io
-        env:
-            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: coveralls
-
-  build-and-push:
-    needs: lint-test
-    if: github.event_name != 'pull_request_target' && github.ref == 'refs/heads/master'
-    runs-on: ubuntu-latest
-
-    steps:
-      # Create a commit SHA-based tag for the container repositories
-      - name: Create SHA Container Tag
-        id: sha_tag
-        run: |
-          tag=$(cut -c 1-7 <<< $GITHUB_SHA)
-          echo "::set-output name=tag::$tag"
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Login to Github Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GHCR_TOKEN  }}
-
-      # This step builds and pushed the container to the
-      # Github Container Registry tagged with "latest" and
-      # the short SHA of the commit.
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: ./Dockerfile
-          push: true
-          cache-from: type=registry,ref=ghcr.io/python-discord/bot:latest
-          tags: |
-            ghcr.io/python-discord/bot:latest
-            ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}
diff --git a/.github/workflows/lint-test.yml b/.github/workflows/lint-test.yml
new file mode 100644
index 000000000..5444fc3de
--- /dev/null
+++ b/.github/workflows/lint-test.yml
@@ -0,0 +1,115 @@
+name: Lint & Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+
+jobs:
+  lint-test:
+    runs-on: ubuntu-latest
+    env:
+      # Dummy values for required bot environment variables
+      BOT_API_KEY: foo
+      BOT_SENTRY_DSN: blah
+      BOT_TOKEN: bar
+      REDDIT_CLIENT_ID: spam
+      REDDIT_SECRET: ham
+      REDIS_PASSWORD: ''
+
+      # Configure pip to cache dependencies and do a user install
+      PIP_NO_CACHE_DIR: false
+      PIP_USER: 1
+
+      # Hide the graphical elements from pipenv's output
+      PIPENV_HIDE_EMOJIS: 1
+      PIPENV_NOSPIN: 1
+
+      # Make sure pipenv does not try reuse an environment it's running in
+      PIPENV_IGNORE_VIRTUALENVS: 1
+
+      # Specify explicit paths for python dependencies and the pre-commit
+      # environment so we know which directories to cache
+      PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
+      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
+
+    steps:
+      - name: Add custom PYTHONUSERBASE to PATH
+        run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
+
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Setup python
+        id: python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.8'
+
+      # This step caches our Python dependencies. To make sure we
+      # only restore a cache when the dependencies, the python version,
+      # the runner operating system, and the dependency location haven't
+      # changed, we create a cache key that is a composite of those states.
+      #
+      # Only when the context is exactly the same, we will restore the cache.
+      - name: Python Dependency Caching
+        uses: actions/cache@v2
+        id: python_cache
+        with:
+          path: ${{ env.PYTHONUSERBASE }}
+          key: "python-0-${{ runner.os }}-${{ env.PYTHONUSERBASE }}-\
+          ${{ steps.python.outputs.python-version }}-\
+          ${{ hashFiles('./Pipfile', './Pipfile.lock') }}"
+
+      # Install our dependencies if we did not restore a dependency cache
+      - name: Install dependencies using pipenv
+        if: steps.python_cache.outputs.cache-hit != 'true'
+        run: |
+          pip install pipenv
+          pipenv install --dev --deploy --system
+
+      # This step caches our pre-commit environment. To make sure we
+      # do create a new environment when our pre-commit setup changes,
+      # we create a cache key based on relevant factors.
+      - name: Pre-commit Environment Caching
+        uses: actions/cache@v2
+        with:
+          path: ${{ env.PRE_COMMIT_HOME }}
+          key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
+          ${{ steps.python.outputs.python-version }}-\
+          ${{ hashFiles('./.pre-commit-config.yaml') }}"
+
+      # We will not run `flake8` here, as we will use a separate flake8
+      # action. As pre-commit does not support user installs, we set
+      # PIP_USER=0 to not do a user install.
+      - name: Run pre-commit hooks
+        run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
+
+      # Run flake8 and have it format the linting errors in the format of
+      # the GitHub Workflow command to register error annotations. This
+      # means that our flake8 output is automatically added as an error
+      # annotation to both the run result and in the "Files" tab of a
+      # pull request.
+      #
+      # Format used:
+      # ::error file={filename},line={line},col={col}::{message}
+      - name: Run flake8
+        run: "flake8 \
+        --format='::error file=%(path)s,line=%(row)d,col=%(col)d::\
+        [flake8] %(code)s: %(text)s'"
+
+      # We run `coverage` using the `python` command so we can suppress
+      # irrelevant warnings in our CI output.
+      - name: Run tests and generate coverage report
+        run: |
+            python -Wignore -m coverage run -m unittest
+            coverage report -m
+
+      # This step will publish the coverage reports coveralls.io and
+      # print a "job" link in the output of the GitHub Action
+      - name: Publish coverage report to coveralls.io
+        env:
+            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: coveralls
-- 
cgit v1.2.3


From 5fe041d1e67ee767788d02f0428250213c43acce Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Wed, 18 Nov 2020 21:35:27 +0100
Subject: Update badges in README to new workflows

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 README.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 482ada08c..210b3e047 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,8 @@
 # Python Utility Bot
 
 [![Discord](https://img.shields.io/static/v1?label=Python%20Discord&logo=discord&message=%3E100k%20members&color=%237289DA&logoColor=white)](https://discord.gg/2B963hn)
-![Lint, Test, Build](https://github.com/python-discord/bot/workflows/Lint,%20Test,%20Build/badge.svg?branch=master)
+[![Lint & Test][1]][2]
+[![Build][3]][4]
 [![Coverage Status](https://coveralls.io/repos/github/python-discord/bot/badge.svg)](https://coveralls.io/github/python-discord/bot)
 [![License](https://img.shields.io/github/license/python-discord/bot)](LICENSE)
 [![Website](https://img.shields.io/badge/website-visit-brightgreen)](https://pythondiscord.com)
@@ -10,3 +11,8 @@ This project is a Discord bot specifically for use with the Python Discord serve
 and other tools to help keep the server running like a well-oiled machine.
 
 Read the [Contributing Guide](https://pythondiscord.com/pages/contributing/bot/) on our website if you're interested in helping out.
+
+[1]: https://github.com/python-discord/bot/workflows/Lint%20&%20Test/badge.svg?branch=master
+[2]: https://github.com/python-discord/bot/actions?query=workflow%3A%22Lint+%26+Test%22+branch%3Amaster
+[3]: https://github.com/python-discord/bot/workflows/Build/badge.svg?branch=master
+[4]: https://github.com/python-discord/bot/actions?query=workflow%3ABuild+branch%3Amaster
-- 
cgit v1.2.3


From 6b07eb115a5db91579a35f8ce899c6ea5943ef1d Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Wed, 18 Nov 2020 21:39:46 +0100
Subject: Use GHCR image tags in Pipfile

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 Pipfile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Pipfile b/Pipfile
index 0730b9150..103ce84cf 100644
--- a/Pipfile
+++ b/Pipfile
@@ -48,8 +48,8 @@ python_version = "3.8"
 start = "python -m bot"
 lint = "pre-commit run --all-files"
 precommit = "pre-commit install"
-build = "docker build -t pythondiscord/bot:latest -f Dockerfile ."
-push = "docker push pythondiscord/bot:latest"
+build = "docker build -t ghcr.io/python-discord/bot:latest -f Dockerfile ."
+push = "docker push ghcr.io/python-discord/bot:latest"
 test = "coverage run -m unittest"
 html = "coverage html"
 report = "coverage report"
-- 
cgit v1.2.3


From 79404ca86434382c297a8247fed06d820323cdc5 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Thu, 19 Nov 2020 00:17:15 +0100
Subject: Add comment explaining buildx to workflow

It's better to document these steps.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/build.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index fa1449c85..706ab462f 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -25,6 +25,12 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v2
 
+      # The current version (v2) of Docker's build-push action uses
+      # buildx, which comes with BuildKit features that help us speed
+      # up our builds using additional cache features. Buildx also
+      # has a lot of other features that are not as relevant to us.
+      #
+      # See https://github.com/docker/build-push-action
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v1
 
-- 
cgit v1.2.3


From ebd440ac8aff27ad70f6a59fde6af15fa8c61b68 Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Thu, 19 Nov 2020 00:27:05 +0000
Subject: Update snekbox address in config-default.yml

---
 config-default.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config-default.yml b/config-default.yml
index ac67251b0..89493c4de 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -329,7 +329,7 @@ urls:
     paste_service:                      !JOIN [*SCHEMA, *PASTE, "/{key}"]
 
     # Snekbox
-    snekbox_eval_api: "http://snekbox:8060/eval"
+    snekbox_eval_api: "http://snekbox.default.svc.cluster.local/eval"
 
     # Discord API URLs
     discord_api:        &DISCORD_API "https://discordapp.com/api/v7/"
-- 
cgit v1.2.3


From d65785aa4c189180601521dc0402d63d95e5bebe Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Thu, 19 Nov 2020 16:09:26 +0100
Subject: Fix the deploy stage of our build pipeline

I've fixed the deploy stage of our build pipeline, as it got mixed in
with the old workflow file due to a merge conflict. The deploy stage is
currently split into a separate workflow; theoretically, this allows us
to trigger a redeploy from GitHub, without having to build the container
image again.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/deploy.yml           |  30 ++++++
 .github/workflows/lint-test-deploy.yml | 171 ---------------------------------
 README.md                              |   7 +-
 3 files changed, 36 insertions(+), 172 deletions(-)
 create mode 100644 .github/workflows/deploy.yml
 delete mode 100644 .github/workflows/lint-test-deploy.yml

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
new file mode 100644
index 000000000..0e9d3e079
--- /dev/null
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,30 @@
+name: Deploy
+
+on:
+  workflow_run:
+    workflows: ["Build"]
+    branches:
+      - master
+    types:
+      - completed
+
+jobs:
+  build:
+    if: github.event.workflow_run.conclusion == 'success'
+    name: Build & Push
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Authenticate with Kubernetes
+        uses: azure/k8s-set-context@v1
+        with:
+          method: kubeconfig
+          kubeconfig: ${{ secrets.KUBECONFIG }}
+
+      - name: Deploy to Kubernetes
+        uses: Azure/k8s-deploy@v1
+        with:
+          manifests: |
+              deployment.yaml
+          images: 'ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}'
+          kubectl-version: 'latest'
diff --git a/.github/workflows/lint-test-deploy.yml b/.github/workflows/lint-test-deploy.yml
deleted file mode 100644
index b4003ddc1..000000000
--- a/.github/workflows/lint-test-deploy.yml
+++ /dev/null
@@ -1,171 +0,0 @@
-name: Lint, Test, Build
-
-on:
-  push:
-    branches:
-      - master
-  # We use pull_request_target as we get PRs from
-  # forks, but need to be able to add annotations
-  # for our flake8 step.
-  pull_request_target:
-
-
-jobs:
-  lint-test:
-    runs-on: ubuntu-latest
-    env:
-      # Dummy values for required bot environment variables
-      BOT_API_KEY: foo
-      BOT_SENTRY_DSN: blah
-      BOT_TOKEN: bar
-      REDDIT_CLIENT_ID: spam
-      REDDIT_SECRET: ham
-      REDIS_PASSWORD: ''
-
-      # Configure pip to cache dependencies and do a user install
-      PIP_NO_CACHE_DIR: false
-      PIP_USER: 1
-
-      # Hide the graphical elements from pipenv's output
-      PIPENV_HIDE_EMOJIS: 1
-      PIPENV_NOSPIN: 1
-
-      # Make sure pipenv does not try reuse an environment it's running in
-      PIPENV_IGNORE_VIRTUALENVS: 1
-
-      # Specify explicit paths for python dependencies and the pre-commit
-      # environment so we know which directories to cache
-      PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
-      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
-
-    steps:
-      - name: Add custom PYTHONUSERBASE to PATH
-        run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
-
-      # We don't want to persist credentials, as our GitHub Action
-      # may be run when a PR is made from a fork.
-      - name: Checkout repository
-        uses: actions/checkout@v2
-        with:
-          persist-credentials: false
-
-      - name: Setup python
-        id: python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.8'
-
-      # This step caches our Python dependencies. To make sure we
-      # only restore a cache when the dependencies, the python version,
-      # the runner operating system, and the dependency location haven't
-      # changed, we create a cache key that is a composite of those states.
-      #
-      # Only when the context is exactly the same, we will restore the cache.
-      - name: Python Dependency Caching
-        uses: actions/cache@v2
-        id: python_cache
-        with:
-          path: ${{ env.PYTHONUSERBASE }}
-          key: "python-0-${{ runner.os }}-${{ env.PYTHONUSERBASE }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./Pipfile', './Pipfile.lock') }}"
-
-      # Install our dependencies if we did not restore a dependency cache
-      - name: Install dependencies using pipenv
-        if: steps.python_cache.outputs.cache-hit != 'true'
-        run: |
-          pip install pipenv
-          pipenv install --dev --deploy --system
-
-      # This step caches our pre-commit environment. To make sure we
-      # do create a new environment when our pre-commit setup changes,
-      # we create a cache key based on relevant factors.
-      - name: Pre-commit Environment Caching
-        uses: actions/cache@v2
-        with:
-          path: ${{ env.PRE_COMMIT_HOME }}
-          key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./.pre-commit-config.yaml') }}"
-
-      # We will not run `flake8` here, as we will use a separate flake8
-      # action. As pre-commit does not support user installs, we set
-      # PIP_USER=0 to not do a user install.
-      - name: Run pre-commit hooks
-        run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
-
-      # This step requires `pull_request_target`, as adding annotations
-      # requires "write" permissions to the repo.
-      - name: Run flake8
-        uses: julianwachholz/flake8-action@v1
-        with:
-          checkName: lint-test
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      # We run `coverage` using the `python` command so we can suppress
-      # irrelevant warnings in our CI output.
-      - name: Run tests and generate coverage report
-        run: |
-            python -Wignore -m coverage run -m unittest
-            coverage report -m
-
-      # This step will publish the coverage reports coveralls.io and
-      # print a "job" link in the output of the GitHub Action
-      - name: Publish coverage report to coveralls.io
-        env:
-            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: coveralls
-
-  build-and-push:
-    needs: lint-test
-    if: github.event_name != 'pull_request_target' && github.ref == 'refs/heads/master'
-    runs-on: ubuntu-latest
-
-    steps:
-      # Create a commit SHA-based tag for the container repositories
-      - name: Create SHA Container Tag
-        id: sha_tag
-        run: |
-          tag=$(cut -c 1-7 <<< $GITHUB_SHA)
-          echo "::set-output name=tag::$tag"
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-
-      - name: Login to Github Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GHCR_TOKEN  }}
-
-      # This step builds and pushed the container to the
-      # Github Container Registry tagged with "latest" and
-      # the short SHA of the commit.
-      - name: Build and push
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          file: ./Dockerfile
-          push: true
-          cache-from: type=registry,ref=ghcr.io/python-discord/bot:latest
-          tags: |
-            ghcr.io/python-discord/bot:latest
-            ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}
-
-      - name: Authenticate with Kubernetes
-        uses: azure/k8s-set-context@v1
-        with:
-          method: kubeconfig
-          kubeconfig: ${{ secrets.KUBECONFIG }}
-
-      - name: Deploy to Kubernetes
-        uses: Azure/k8s-deploy@v1
-        with:
-          manifests: |
-              deployment.yaml
-          images: 'ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}'
-          kubectl-version: 'latest'
diff --git a/README.md b/README.md
index 210b3e047..c813997e7 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,9 @@
 # Python Utility Bot
 
-[![Discord](https://img.shields.io/static/v1?label=Python%20Discord&logo=discord&message=%3E100k%20members&color=%237289DA&logoColor=white)](https://discord.gg/2B963hn)
+[![Discord][7]][8]
 [![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/github/license/python-discord/bot)](LICENSE)
 [![Website](https://img.shields.io/badge/website-visit-brightgreen)](https://pythondiscord.com)
@@ -16,3 +17,7 @@ Read the [Contributing Guide](https://pythondiscord.com/pages/contributing/bot/)
 [2]: https://github.com/python-discord/bot/actions?query=workflow%3A%22Lint+%26+Test%22+branch%3Amaster
 [3]: https://github.com/python-discord/bot/workflows/Build/badge.svg?branch=master
 [4]: https://github.com/python-discord/bot/actions?query=workflow%3ABuild+branch%3Amaster
+[5]: https://github.com/python-discord/bot/workflows/Deploy/badge.svg?branch=master
+[6]: https://github.com/python-discord/bot/actions?query=workflow%3ADeploy+branch%3Amaster
+[7]: https://img.shields.io/static/v1?label=Python%20Discord&logo=discord&message=%3E100k%20members&color=%237289DA&logoColor=white
+[8]: https://discord.gg/2B963hn
-- 
cgit v1.2.3


From b287165e01c78e36af2cfbc19366555359ffdc18 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Thu, 19 Nov 2020 17:31:12 +0100
Subject: Checkout code so we can deploy

---
 .github/workflows/deploy.yml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 0e9d3e079..90555a8ee 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -15,6 +15,15 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
+      - name: Create SHA Container Tag
+        id: sha_tag
+        run: |
+          tag=$(cut -c 1-7 <<< $GITHUB_SHA)
+          echo "::set-output name=tag::$tag"
+
+      - name: Checkout code
+        uses: actions/checkout@v2
+
       - name: Authenticate with Kubernetes
         uses: azure/k8s-set-context@v1
         with:
-- 
cgit v1.2.3


From 902b5fa0c7a3c981039e9eb397320e83f69fa44f Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Fri, 20 Nov 2020 20:19:25 +0200
Subject: Install emoji package for emojis filtering

---
 Pipfile      |  1 +
 Pipfile.lock | 49 ++++++++++++++++++++++++++++++-------------------
 2 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/Pipfile b/Pipfile
index 0730b9150..0478eafb5 100644
--- a/Pipfile
+++ b/Pipfile
@@ -26,6 +26,7 @@ requests = "~=2.22"
 sentry-sdk = "~=0.14"
 sphinx = "~=2.2"
 statsd = "~=3.3"
+emoji = "~=0.6"
 
 [dev-packages]
 coverage = "~=5.0"
diff --git a/Pipfile.lock b/Pipfile.lock
index 6a6a1aaf6..541db1627 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "ca6b100f7ee2e6e01eec413a754fc11be064e965a255b2c4927d4a2dd1c451ec"
+            "sha256": "3ccb368599709d2970f839fc3721cfeebcd5a2700fed7231b2ce38a080828325"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -222,6 +222,13 @@
             "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'",
             "version": "==0.16"
         },
+        "emoji": {
+            "hashes": [
+                "sha256:e42da4f8d648f8ef10691bc246f682a1ec6b18373abfd9be10ec0b398823bd11"
+            ],
+            "index": "pypi",
+            "version": "==0.6.0"
+        },
         "fakeredis": {
             "hashes": [
                 "sha256:8070b7fce16f828beaef2c757a4354af91698685d5232404f1aeeb233529c7a5",
@@ -548,16 +555,18 @@
         },
         "pyyaml": {
             "hashes": [
-                "sha256:06a0d7ba600ce0b2d2fe2e78453a470b5a6e000a985dd4a4e54e436cc36b0e97",
+                "sha256:73f099454b799e05e5ab51423c7bcf361c58d3206fa7b0d555426b1f4d9a3eaf",
+                "sha256:ad9c67312c84def58f3c04504727ca879cb0013b2517c85a9a253f0cb6380c0a",
+                "sha256:cc8955cfbfc7a115fa81d85284ee61147059a753344bc51098f3ccd69b0d7e0c",
                 "sha256:240097ff019d7c70a4922b6869d8a86407758333f02203e0fc6ff79c5dcede76",
-                "sha256:4f4b913ca1a7319b33cfb1369e91e50354d6f07a135f3b901aca02aa95940bd2",
+                "sha256:6034f55dab5fea9e53f436aa68fa3ace2634918e8b5994d82f3621c04ff5ed2e",
                 "sha256:69f00dca373f240f842b2931fb2c7e14ddbacd1397d57157a9b005a6a9942648",
-                "sha256:73f099454b799e05e5ab51423c7bcf361c58d3206fa7b0d555426b1f4d9a3eaf",
+                "sha256:b8eac752c5e14d3eca0e6dd9199cd627518cb5ec06add0de9d32baeee6fe645d",
+                "sha256:06a0d7ba600ce0b2d2fe2e78453a470b5a6e000a985dd4a4e54e436cc36b0e97",
                 "sha256:74809a57b329d6cc0fdccee6318f44b9b8649961fa73144a98735b0aaf029f1f",
-                "sha256:7739fc0fa8205b3ee8808aea45e968bc90082c10aef6ea95e855e10abf4a37b2",
+                "sha256:4f4b913ca1a7319b33cfb1369e91e50354d6f07a135f3b901aca02aa95940bd2",
                 "sha256:95f71d2af0ff4227885f7a6605c37fd53d3a106fcab511b8860ecca9fcf400ee",
-                "sha256:b8eac752c5e14d3eca0e6dd9199cd627518cb5ec06add0de9d32baeee6fe645d",
-                "sha256:cc8955cfbfc7a115fa81d85284ee61147059a753344bc51098f3ccd69b0d7e0c",
+                "sha256:7739fc0fa8205b3ee8808aea45e968bc90082c10aef6ea95e855e10abf4a37b2",
                 "sha256:d13155f591e6fcc1ec3b30685d50bf0711574e2c0dfffd7644babf8b5102ca1a"
             ],
             "index": "pypi",
@@ -581,11 +590,11 @@
         },
         "sentry-sdk": {
             "hashes": [
-                "sha256:81d7a5d8ca0b13a16666e8280127b004565aa988bfeec6481e98a8601804b215",
-                "sha256:fd48f627945511c140546939b4d73815be4860cd1d2b9149577d7f6563e7bd60"
+                "sha256:1052f0ed084e532f66cb3e4ba617960d820152aee8b93fc6c05bd53861768c1c",
+                "sha256:4c42910a55a6b1fe694d5e4790d5188d105d77b5a6346c1c64cbea8c06c0e8b7"
             ],
             "index": "pypi",
-            "version": "==0.19.3"
+            "version": "==0.19.4"
         },
         "six": {
             "hashes": [
@@ -793,11 +802,11 @@
         },
         "coveralls": {
             "hashes": [
-                "sha256:4430b862baabb3cf090d36d84d331966615e4288d8a8c5957e0fd456d0dd8bd6",
-                "sha256:b3b60c17b03a0dee61952a91aed6f131e0b2ac8bd5da909389c53137811409e1"
+                "sha256:2301a19500b06649d2ec4f2858f9c69638d7699a4c63027c5d53daba666147cc",
+                "sha256:b990ba1f7bc4288e63340be0433698c1efe8217f78c689d254c2540af3d38617"
             ],
             "index": "pypi",
-            "version": "==2.1.2"
+            "version": "==2.2.0"
         },
         "distlib": {
             "hashes": [
@@ -961,16 +970,18 @@
         },
         "pyyaml": {
             "hashes": [
-                "sha256:06a0d7ba600ce0b2d2fe2e78453a470b5a6e000a985dd4a4e54e436cc36b0e97",
+                "sha256:73f099454b799e05e5ab51423c7bcf361c58d3206fa7b0d555426b1f4d9a3eaf",
+                "sha256:ad9c67312c84def58f3c04504727ca879cb0013b2517c85a9a253f0cb6380c0a",
+                "sha256:cc8955cfbfc7a115fa81d85284ee61147059a753344bc51098f3ccd69b0d7e0c",
                 "sha256:240097ff019d7c70a4922b6869d8a86407758333f02203e0fc6ff79c5dcede76",
-                "sha256:4f4b913ca1a7319b33cfb1369e91e50354d6f07a135f3b901aca02aa95940bd2",
+                "sha256:6034f55dab5fea9e53f436aa68fa3ace2634918e8b5994d82f3621c04ff5ed2e",
                 "sha256:69f00dca373f240f842b2931fb2c7e14ddbacd1397d57157a9b005a6a9942648",
-                "sha256:73f099454b799e05e5ab51423c7bcf361c58d3206fa7b0d555426b1f4d9a3eaf",
+                "sha256:b8eac752c5e14d3eca0e6dd9199cd627518cb5ec06add0de9d32baeee6fe645d",
+                "sha256:06a0d7ba600ce0b2d2fe2e78453a470b5a6e000a985dd4a4e54e436cc36b0e97",
                 "sha256:74809a57b329d6cc0fdccee6318f44b9b8649961fa73144a98735b0aaf029f1f",
-                "sha256:7739fc0fa8205b3ee8808aea45e968bc90082c10aef6ea95e855e10abf4a37b2",
+                "sha256:4f4b913ca1a7319b33cfb1369e91e50354d6f07a135f3b901aca02aa95940bd2",
                 "sha256:95f71d2af0ff4227885f7a6605c37fd53d3a106fcab511b8860ecca9fcf400ee",
-                "sha256:b8eac752c5e14d3eca0e6dd9199cd627518cb5ec06add0de9d32baeee6fe645d",
-                "sha256:cc8955cfbfc7a115fa81d85284ee61147059a753344bc51098f3ccd69b0d7e0c",
+                "sha256:7739fc0fa8205b3ee8808aea45e968bc90082c10aef6ea95e855e10abf4a37b2",
                 "sha256:d13155f591e6fcc1ec3b30685d50bf0711574e2c0dfffd7644babf8b5102ca1a"
             ],
             "index": "pypi",
-- 
cgit v1.2.3


From 29a22b460f9c124657aafa96a820337dd0b1b37b Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Fri, 20 Nov 2020 20:20:40 +0200
Subject: Catch Unicode emojis in emojis filtering rule

Instead detecting only custom emojis, rule now catch too Unicode emojis.
This converts Unicode emojis to :emoji: format and count them.
---
 bot/rules/discord_emojis.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/bot/rules/discord_emojis.py b/bot/rules/discord_emojis.py
index 6e47f0197..41faf7ee8 100644
--- a/bot/rules/discord_emojis.py
+++ b/bot/rules/discord_emojis.py
@@ -2,16 +2,17 @@ import re
 from typing import Dict, Iterable, List, Optional, Tuple
 
 from discord import Member, Message
+from emoji import demojize
 
 
-DISCORD_EMOJI_RE = re.compile(r"<:\w+:\d+>")
+DISCORD_EMOJI_RE = re.compile(r"<:\w+:\d+>|:\w+:")
 CODE_BLOCK_RE = re.compile(r"```.*?```", flags=re.DOTALL)
 
 
 async def apply(
     last_message: Message, recent_messages: List[Message], config: Dict[str, int]
 ) -> Optional[Tuple[str, Iterable[Member], Iterable[Message]]]:
-    """Detects total Discord emojis (excluding Unicode emojis) exceeding the limit sent by a single user."""
+    """Detects total Discord emojis exceeding the limit sent by a single user."""
     relevant_messages = tuple(
         msg
         for msg in recent_messages
@@ -19,8 +20,9 @@ async def apply(
     )
 
     # Get rid of code blocks in the message before searching for emojis.
+    # Convert Unicode emojis to :emoji: format to get their count.
     total_emojis = sum(
-        len(DISCORD_EMOJI_RE.findall(CODE_BLOCK_RE.sub("", msg.content)))
+        len(DISCORD_EMOJI_RE.findall(demojize(CODE_BLOCK_RE.sub("", msg.content))))
         for msg in relevant_messages
     )
 
-- 
cgit v1.2.3


From 14734fde3d2a8d268bdae1603a6b64d964546dff Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Fri, 20 Nov 2020 20:35:00 +0200
Subject: Cover Unicode emojis catching as antispam rule with test cases

---
 tests/bot/rules/test_discord_emojis.py | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/tests/bot/rules/test_discord_emojis.py b/tests/bot/rules/test_discord_emojis.py
index 9a72723e2..66c2d9f92 100644
--- a/tests/bot/rules/test_discord_emojis.py
+++ b/tests/bot/rules/test_discord_emojis.py
@@ -5,11 +5,12 @@ from tests.bot.rules import DisallowedCase, RuleTest
 from tests.helpers import MockMessage
 
 discord_emoji = "<:abcd:1234>"  # Discord emojis follow the format <:name:id>
+unicode_emoji = "🧪"
 
 
-def make_msg(author: str, n_emojis: int) -> MockMessage:
+def make_msg(author: str, n_emojis: int, emoji: str = discord_emoji) -> MockMessage:
     """Build a MockMessage instance with content containing `n_emojis` arbitrary emojis."""
-    return MockMessage(author=author, content=discord_emoji * n_emojis)
+    return MockMessage(author=author, content=emoji * n_emojis)
 
 
 class DiscordEmojisRuleTests(RuleTest):
@@ -20,16 +21,22 @@ class DiscordEmojisRuleTests(RuleTest):
         self.config = {"max": 2, "interval": 10}
 
     async def test_allows_messages_within_limit(self):
-        """Cases with a total amount of discord emojis within limit."""
+        """Cases with a total amount of discord and unicode emojis within limit."""
         cases = (
             [make_msg("bob", 2)],
             [make_msg("alice", 1), make_msg("bob", 2), make_msg("alice", 1)],
+            [make_msg("bob", 2, unicode_emoji)],
+            [
+                make_msg("alice", 1, unicode_emoji),
+                make_msg("bob", 2, unicode_emoji),
+                make_msg("alice", 1, unicode_emoji)
+            ],
         )
 
         await self.run_allowed(cases)
 
     async def test_disallows_messages_beyond_limit(self):
-        """Cases with more than the allowed amount of discord emojis."""
+        """Cases with more than the allowed amount of discord and unicode emojis."""
         cases = (
             DisallowedCase(
                 [make_msg("bob", 3)],
@@ -41,6 +48,20 @@ class DiscordEmojisRuleTests(RuleTest):
                 ("alice",),
                 4,
             ),
+            DisallowedCase(
+                [make_msg("bob", 3, unicode_emoji)],
+                ("bob",),
+                3,
+            ),
+            DisallowedCase(
+                [
+                    make_msg("alice", 2, unicode_emoji),
+                    make_msg("bob", 2, unicode_emoji),
+                    make_msg("alice", 2, unicode_emoji)
+                ],
+                ("alice",),
+                4
+            )
         )
 
         await self.run_disallowed(cases)
-- 
cgit v1.2.3


From b865efeb9bb802ed728232fd8848db6140afccfa Mon Sep 17 00:00:00 2001
From: Gustav Odinger <65498475+gustavwilliam@users.noreply.github.com>
Date: Sat, 21 Nov 2020 00:00:40 +0100
Subject: Update available help channel embed message
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- This changes "we'll try to help you" to say "others will try to help you"
- Clarifies that the rest of the community is going to help — not some dedicated help/staff team
---
 bot/exts/help_channels.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index 056434020..3643b8643 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -29,7 +29,7 @@ This is a Python help channel. You can claim your own help channel in the Python
 
 AVAILABLE_MSG = f"""
 **Send your question here to claim the channel**
-This channel will be dedicated to answering your question only. We’ll try to answer and help you solve the issue.
+This channel will be dedicated to answering your question only. Others will try to answer and help you solve the issue.
 
 **Keep in mind:**
 • It's always ok to just ask your question. You don't need permission.
-- 
cgit v1.2.3


From 969beaf3e21407c08bbda1f6ec2f4e555728aa11 Mon Sep 17 00:00:00 2001
From: Gustav Odinger <gustav@odinger.se>
Date: Sat, 21 Nov 2020 00:33:26 +0100
Subject: Remove duplicate checkmark

- This removes a duplicate checkmark from the title of the embed

- The checkmark was left from the previous title system and wasn't removed in the change
---
 bot/exts/help_channels.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index 3643b8643..4b8679b8a 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -39,7 +39,7 @@ This channel will be dedicated to answering your question only. Others will try
 For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
 """
 
-AVAILABLE_TITLE = "✅ Available help channel"
+AVAILABLE_TITLE = "Available help channel"
 
 AVAILABLE_FOOTER = f"Closes after {constants.HelpChannels.idle_minutes} minutes of inactivity or when you send !close."
 
-- 
cgit v1.2.3


From ed68051a47e67d8e60498a866a8c3c54840aa6fb Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 11:39:18 -0700
Subject: Help channels: move to a subpackage

---
 bot/exts/help_channels.py          | 940 -------------------------------------
 bot/exts/help_channels/__init__.py |  17 +
 bot/exts/help_channels/_cog.py     | 930 ++++++++++++++++++++++++++++++++++++
 3 files changed, 947 insertions(+), 940 deletions(-)
 delete mode 100644 bot/exts/help_channels.py
 create mode 100644 bot/exts/help_channels/__init__.py
 create mode 100644 bot/exts/help_channels/_cog.py

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
deleted file mode 100644
index ced2f72ef..000000000
--- a/bot/exts/help_channels.py
+++ /dev/null
@@ -1,940 +0,0 @@
-import asyncio
-import json
-import logging
-import random
-import typing as t
-from collections import deque
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-import discord
-import discord.abc
-from async_rediscache import RedisCache
-from discord.ext import commands
-
-from bot import constants
-from bot.bot import Bot
-from bot.utils import channel as channel_utils
-from bot.utils.scheduling import Scheduler
-
-log = logging.getLogger(__name__)
-
-ASKING_GUIDE_URL = "https://pythondiscord.com/pages/asking-good-questions/"
-MAX_CHANNELS_PER_CATEGORY = 50
-EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
-
-HELP_CHANNEL_TOPIC = """
-This is a Python help channel. You can claim your own help channel in the Python Help: Available category.
-"""
-
-AVAILABLE_MSG = f"""
-**Send your question here to claim the channel**
-This channel will be dedicated to answering your question only. Others will try to answer and help you solve the issue.
-
-**Keep in mind:**
-• It's always ok to just ask your question. You don't need permission.
-• Explain what you expect to happen and what actually happens.
-• Include a code sample and error message, if you got any.
-
-For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
-"""
-
-AVAILABLE_TITLE = "Available help channel"
-
-AVAILABLE_FOOTER = f"Closes after {constants.HelpChannels.idle_minutes} minutes of inactivity or when you send !close."
-
-DORMANT_MSG = f"""
-This help channel has been marked as **dormant**, and has been moved into the **Help: Dormant** \
-category at the bottom of the channel list. It is no longer possible to send messages in this \
-channel until it becomes available again.
-
-If your question wasn't answered yet, you can claim a new help channel from the \
-**Help: Available** category by simply asking your question again. Consider rephrasing the \
-question to maximize your chance of getting a good answer. If you're not sure how, have a look \
-through our guide for **[asking a good question]({ASKING_GUIDE_URL})**.
-"""
-
-CoroutineFunc = t.Callable[..., t.Coroutine]
-
-
-class HelpChannels(commands.Cog):
-    """
-    Manage the help channel system of the guild.
-
-    The system is based on a 3-category system:
-
-    Available Category
-
-    * Contains channels which are ready to be occupied by someone who needs help
-    * Will always contain `constants.HelpChannels.max_available` channels; refilled automatically
-      from the pool of dormant channels
-        * Prioritise using the channels which have been dormant for the longest amount of time
-        * If there are no more dormant channels, the bot will automatically create a new one
-        * If there are no dormant channels to move, helpers will be notified (see `notify()`)
-    * When a channel becomes available, the dormant embed will be edited to show `AVAILABLE_MSG`
-    * User can only claim a channel at an interval `constants.HelpChannels.claim_minutes`
-        * To keep track of cooldowns, user which claimed a channel will have a temporary role
-
-    In Use Category
-
-    * Contains all channels which are occupied by someone needing help
-    * Channel moves to dormant category after `constants.HelpChannels.idle_minutes` of being idle
-    * Command can prematurely mark a channel as dormant
-        * Channel claimant is allowed to use the command
-        * Allowed roles for the command are configurable with `constants.HelpChannels.cmd_whitelist`
-    * When a channel becomes dormant, an embed with `DORMANT_MSG` will be sent
-
-    Dormant Category
-
-    * Contains channels which aren't in use
-    * Channels are used to refill the Available category
-
-    Help channels are named after the chemical elements in `bot/resources/elements.json`.
-    """
-
-    # This cache tracks which channels are claimed by which members.
-    # RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
-    help_channel_claimants = RedisCache()
-
-    # This cache maps a help channel to whether it has had any
-    # activity other than the original claimant. True being no other
-    # activity and False being other activity.
-    # RedisCache[discord.TextChannel.id, bool]
-    unanswered = RedisCache()
-
-    # This dictionary maps a help channel to the time it was claimed
-    # RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
-    claim_times = RedisCache()
-
-    # This cache maps a help channel to original question message in same channel.
-    # RedisCache[discord.TextChannel.id, discord.Message.id]
-    question_messages = RedisCache()
-
-    def __init__(self, bot: Bot):
-        self.bot = bot
-        self.scheduler = Scheduler(self.__class__.__name__)
-
-        # Categories
-        self.available_category: discord.CategoryChannel = None
-        self.in_use_category: discord.CategoryChannel = None
-        self.dormant_category: discord.CategoryChannel = None
-
-        # Queues
-        self.channel_queue: asyncio.Queue[discord.TextChannel] = None
-        self.name_queue: t.Deque[str] = None
-
-        self.name_positions = self.get_names()
-        self.last_notification: t.Optional[datetime] = None
-
-        # Asyncio stuff
-        self.queue_tasks: t.List[asyncio.Task] = []
-        self.ready = asyncio.Event()
-        self.on_message_lock = asyncio.Lock()
-        self.init_task = self.bot.loop.create_task(self.init_cog())
-
-    def cog_unload(self) -> None:
-        """Cancel the init task and scheduled tasks when the cog unloads."""
-        log.trace("Cog unload: cancelling the init_cog task")
-        self.init_task.cancel()
-
-        log.trace("Cog unload: cancelling the channel queue tasks")
-        for task in self.queue_tasks:
-            task.cancel()
-
-        self.scheduler.cancel_all()
-
-    def create_channel_queue(self) -> asyncio.Queue:
-        """
-        Return a queue of dormant channels to use for getting the next available channel.
-
-        The channels are added to the queue in a random order.
-        """
-        log.trace("Creating the channel queue.")
-
-        channels = list(self.get_category_channels(self.dormant_category))
-        random.shuffle(channels)
-
-        log.trace("Populating the channel queue with channels.")
-        queue = asyncio.Queue()
-        for channel in channels:
-            queue.put_nowait(channel)
-
-        return queue
-
-    async def create_dormant(self) -> t.Optional[discord.TextChannel]:
-        """
-        Create and return a new channel in the Dormant category.
-
-        The new channel will sync its permission overwrites with the category.
-
-        Return None if no more channel names are available.
-        """
-        log.trace("Getting a name for a new dormant channel.")
-
-        try:
-            name = self.name_queue.popleft()
-        except IndexError:
-            log.debug("No more names available for new dormant channels.")
-            return None
-
-        log.debug(f"Creating a new dormant channel named {name}.")
-        return await self.dormant_category.create_text_channel(name, topic=HELP_CHANNEL_TOPIC)
-
-    def create_name_queue(self) -> deque:
-        """Return a queue of element names to use for creating new channels."""
-        log.trace("Creating the chemical element name queue.")
-
-        used_names = self.get_used_names()
-
-        log.trace("Determining the available names.")
-        available_names = (name for name in self.name_positions if name not in used_names)
-
-        log.trace("Populating the name queue with names.")
-        return deque(available_names)
-
-    async def dormant_check(self, ctx: commands.Context) -> bool:
-        """Return True if the user is the help channel claimant or passes the role check."""
-        if await self.help_channel_claimants.get(ctx.channel.id) == ctx.author.id:
-            log.trace(f"{ctx.author} is the help channel claimant, passing the check for dormant.")
-            self.bot.stats.incr("help.dormant_invoke.claimant")
-            return True
-
-        log.trace(f"{ctx.author} is not the help channel claimant, checking roles.")
-        has_role = await commands.has_any_role(*constants.HelpChannels.cmd_whitelist).predicate(ctx)
-
-        if has_role:
-            self.bot.stats.incr("help.dormant_invoke.staff")
-
-        return has_role
-
-    @commands.command(name="close", aliases=["dormant", "solved"], enabled=False)
-    async def close_command(self, ctx: commands.Context) -> None:
-        """
-        Make the current in-use help channel dormant.
-
-        Make the channel dormant if the user passes the `dormant_check`,
-        delete the message that invoked this,
-        and reset the send permissions cooldown for the user who started the session.
-        """
-        log.trace("close command invoked; checking if the channel is in-use.")
-        if ctx.channel.category == self.in_use_category:
-            if await self.dormant_check(ctx):
-                await self.remove_cooldown_role(ctx.author)
-
-                # Ignore missing task when cooldown has passed but the channel still isn't dormant.
-                if ctx.author.id in self.scheduler:
-                    self.scheduler.cancel(ctx.author.id)
-
-                await self.move_to_dormant(ctx.channel, "command")
-                self.scheduler.cancel(ctx.channel.id)
-        else:
-            log.debug(f"{ctx.author} invoked command 'dormant' outside an in-use help channel")
-
-    async def get_available_candidate(self) -> discord.TextChannel:
-        """
-        Return a dormant channel to turn into an available channel.
-
-        If no channel is available, wait indefinitely until one becomes available.
-        """
-        log.trace("Getting an available channel candidate.")
-
-        try:
-            channel = self.channel_queue.get_nowait()
-        except asyncio.QueueEmpty:
-            log.info("No candidate channels in the queue; creating a new channel.")
-            channel = await self.create_dormant()
-
-            if not channel:
-                log.info("Couldn't create a candidate channel; waiting to get one from the queue.")
-                await self.notify()
-                channel = await self.wait_for_dormant_channel()
-
-        return channel
-
-    @staticmethod
-    def get_clean_channel_name(channel: discord.TextChannel) -> str:
-        """Return a clean channel name without status emojis prefix."""
-        prefix = constants.HelpChannels.name_prefix
-        try:
-            # Try to remove the status prefix using the index of the channel prefix
-            name = channel.name[channel.name.index(prefix):]
-            log.trace(f"The clean name for `{channel}` is `{name}`")
-        except ValueError:
-            # If, for some reason, the channel name does not contain "help-" fall back gracefully
-            log.info(f"Can't get clean name because `{channel}` isn't prefixed by `{prefix}`.")
-            name = channel.name
-
-        return name
-
-    @staticmethod
-    def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
-        """Check if a channel should be excluded from the help channel system."""
-        return not isinstance(channel, discord.TextChannel) or channel.id in EXCLUDED_CHANNELS
-
-    def get_category_channels(self, category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
-        """Yield the text channels of the `category` in an unsorted manner."""
-        log.trace(f"Getting text channels in the category '{category}' ({category.id}).")
-
-        # This is faster than using category.channels because the latter sorts them.
-        for channel in self.bot.get_guild(constants.Guild.id).channels:
-            if channel.category_id == category.id and not self.is_excluded_channel(channel):
-                yield channel
-
-    async def get_in_use_time(self, channel_id: int) -> t.Optional[timedelta]:
-        """Return the duration `channel_id` has been in use. Return None if it's not in use."""
-        log.trace(f"Calculating in use time for channel {channel_id}.")
-
-        claimed_timestamp = await self.claim_times.get(channel_id)
-        if claimed_timestamp:
-            claimed = datetime.utcfromtimestamp(claimed_timestamp)
-            return datetime.utcnow() - claimed
-
-    @staticmethod
-    def get_names() -> t.List[str]:
-        """
-        Return a truncated list of prefixed element names.
-
-        The amount of names is configured with `HelpChannels.max_total_channels`.
-        The prefix is configured with `HelpChannels.name_prefix`.
-        """
-        count = constants.HelpChannels.max_total_channels
-        prefix = constants.HelpChannels.name_prefix
-
-        log.trace(f"Getting the first {count} element names from JSON.")
-
-        with Path("bot/resources/elements.json").open(encoding="utf-8") as elements_file:
-            all_names = json.load(elements_file)
-
-        if prefix:
-            return [prefix + name for name in all_names[:count]]
-        else:
-            return all_names[:count]
-
-    def get_used_names(self) -> t.Set[str]:
-        """Return channel names which are already being used."""
-        log.trace("Getting channel names which are already being used.")
-
-        names = set()
-        for cat in (self.available_category, self.in_use_category, self.dormant_category):
-            for channel in self.get_category_channels(cat):
-                names.add(self.get_clean_channel_name(channel))
-
-        if len(names) > MAX_CHANNELS_PER_CATEGORY:
-            log.warning(
-                f"Too many help channels ({len(names)}) already exist! "
-                f"Discord only supports {MAX_CHANNELS_PER_CATEGORY} in a category."
-            )
-
-        log.trace(f"Got {len(names)} used names: {names}")
-        return names
-
-    @classmethod
-    async def get_idle_time(cls, channel: discord.TextChannel) -> t.Optional[int]:
-        """
-        Return the time elapsed, in seconds, since the last message sent in the `channel`.
-
-        Return None if the channel has no messages.
-        """
-        log.trace(f"Getting the idle time for #{channel} ({channel.id}).")
-
-        msg = await cls.get_last_message(channel)
-        if not msg:
-            log.debug(f"No idle time available; #{channel} ({channel.id}) has no messages.")
-            return None
-
-        idle_time = (datetime.utcnow() - msg.created_at).seconds
-
-        log.trace(f"#{channel} ({channel.id}) has been idle for {idle_time} seconds.")
-        return idle_time
-
-    @staticmethod
-    async def get_last_message(channel: discord.TextChannel) -> t.Optional[discord.Message]:
-        """Return the last message sent in the channel or None if no messages exist."""
-        log.trace(f"Getting the last message in #{channel} ({channel.id}).")
-
-        try:
-            return await channel.history(limit=1).next()  # noqa: B305
-        except discord.NoMoreItems:
-            log.debug(f"No last message available; #{channel} ({channel.id}) has no messages.")
-            return None
-
-    async def init_available(self) -> None:
-        """Initialise the Available category with channels."""
-        log.trace("Initialising the Available category with channels.")
-
-        channels = list(self.get_category_channels(self.available_category))
-        missing = constants.HelpChannels.max_available - len(channels)
-
-        # If we've got less than `max_available` channel available, we should add some.
-        if missing > 0:
-            log.trace(f"Moving {missing} missing channels to the Available category.")
-            for _ in range(missing):
-                await self.move_to_available()
-
-        # If for some reason we have more than `max_available` channels available,
-        # we should move the superfluous ones over to dormant.
-        elif missing < 0:
-            log.trace(f"Moving {abs(missing)} superfluous available channels over to the Dormant category.")
-            for channel in channels[:abs(missing)]:
-                await self.move_to_dormant(channel, "auto")
-
-    async def init_categories(self) -> None:
-        """Get the help category objects. Remove the cog if retrieval fails."""
-        log.trace("Getting the CategoryChannel objects for the help categories.")
-
-        try:
-            self.available_category = await channel_utils.try_get_channel(
-                constants.Categories.help_available
-            )
-            self.in_use_category = await channel_utils.try_get_channel(
-                constants.Categories.help_in_use
-            )
-            self.dormant_category = await channel_utils.try_get_channel(
-                constants.Categories.help_dormant
-            )
-        except discord.HTTPException:
-            log.exception("Failed to get a category; cog will be removed")
-            self.bot.remove_cog(self.qualified_name)
-
-    async def init_cog(self) -> None:
-        """Initialise the help channel system."""
-        log.trace("Waiting for the guild to be available before initialisation.")
-        await self.bot.wait_until_guild_available()
-
-        log.trace("Initialising the cog.")
-        await self.init_categories()
-        await self.check_cooldowns()
-
-        self.channel_queue = self.create_channel_queue()
-        self.name_queue = self.create_name_queue()
-
-        log.trace("Moving or rescheduling in-use channels.")
-        for channel in self.get_category_channels(self.in_use_category):
-            await self.move_idle_channel(channel, has_task=False)
-
-        # Prevent the command from being used until ready.
-        # The ready event wasn't used because channels could change categories between the time
-        # the command is invoked and the cog is ready (e.g. if move_idle_channel wasn't called yet).
-        # This may confuse users. So would potentially long delays for the cog to become ready.
-        self.close_command.enabled = True
-
-        await self.init_available()
-
-        log.info("Cog is ready!")
-        self.ready.set()
-
-        self.report_stats()
-
-    def report_stats(self) -> None:
-        """Report the channel count stats."""
-        total_in_use = sum(1 for _ in self.get_category_channels(self.in_use_category))
-        total_available = sum(1 for _ in self.get_category_channels(self.available_category))
-        total_dormant = sum(1 for _ in self.get_category_channels(self.dormant_category))
-
-        self.bot.stats.gauge("help.total.in_use", total_in_use)
-        self.bot.stats.gauge("help.total.available", total_available)
-        self.bot.stats.gauge("help.total.dormant", total_dormant)
-
-    @staticmethod
-    def is_claimant(member: discord.Member) -> bool:
-        """Return True if `member` has the 'Help Cooldown' role."""
-        return any(constants.Roles.help_cooldown == role.id for role in member.roles)
-
-    def match_bot_embed(self, message: t.Optional[discord.Message], description: str) -> bool:
-        """Return `True` if the bot's `message`'s embed description matches `description`."""
-        if not message or not message.embeds:
-            return False
-
-        bot_msg_desc = message.embeds[0].description
-        if bot_msg_desc is discord.Embed.Empty:
-            log.trace("Last message was a bot embed but it was empty.")
-            return False
-        return message.author == self.bot.user and bot_msg_desc.strip() == description.strip()
-
-    async def move_idle_channel(self, channel: discord.TextChannel, has_task: bool = True) -> None:
-        """
-        Make the `channel` dormant if idle or schedule the move if still active.
-
-        If `has_task` is True and rescheduling is required, the extant task to make the channel
-        dormant will first be cancelled.
-        """
-        log.trace(f"Handling in-use channel #{channel} ({channel.id}).")
-
-        if not await self.is_empty(channel):
-            idle_seconds = constants.HelpChannels.idle_minutes * 60
-        else:
-            idle_seconds = constants.HelpChannels.deleted_idle_minutes * 60
-
-        time_elapsed = await self.get_idle_time(channel)
-
-        if time_elapsed is None or time_elapsed >= idle_seconds:
-            log.info(
-                f"#{channel} ({channel.id}) is idle longer than {idle_seconds} seconds "
-                f"and will be made dormant."
-            )
-
-            await self.move_to_dormant(channel, "auto")
-        else:
-            # Cancel the existing task, if any.
-            if has_task:
-                self.scheduler.cancel(channel.id)
-
-            delay = idle_seconds - time_elapsed
-            log.info(
-                f"#{channel} ({channel.id}) is still active; "
-                f"scheduling it to be moved after {delay} seconds."
-            )
-
-            self.scheduler.schedule_later(delay, channel.id, self.move_idle_channel(channel))
-
-    async def move_to_bottom_position(self, channel: discord.TextChannel, category_id: int, **options) -> None:
-        """
-        Move the `channel` to the bottom position of `category` and edit channel attributes.
-
-        To ensure "stable sorting", we use the `bulk_channel_update` endpoint and provide the current
-        positions of the other channels in the category as-is. This should make sure that the channel
-        really ends up at the bottom of the category.
-
-        If `options` are provided, the channel will be edited after the move is completed. This is the
-        same order of operations that `discord.TextChannel.edit` uses. For information on available
-        options, see the documentation on `discord.TextChannel.edit`. While possible, position-related
-        options should be avoided, as it may interfere with the category move we perform.
-        """
-        # Get a fresh copy of the category from the bot to avoid the cache mismatch issue we had.
-        category = await channel_utils.try_get_channel(category_id)
-
-        payload = [{"id": c.id, "position": c.position} for c in category.channels]
-
-        # Calculate the bottom position based on the current highest position in the category. If the
-        # category is currently empty, we simply use the current position of the channel to avoid making
-        # unnecessary changes to positions in the guild.
-        bottom_position = payload[-1]["position"] + 1 if payload else channel.position
-
-        payload.append(
-            {
-                "id": channel.id,
-                "position": bottom_position,
-                "parent_id": category.id,
-                "lock_permissions": True,
-            }
-        )
-
-        # We use d.py's method to ensure our request is processed by d.py's rate limit manager
-        await self.bot.http.bulk_channel_update(category.guild.id, payload)
-
-        # Now that the channel is moved, we can edit the other attributes
-        if options:
-            await channel.edit(**options)
-
-    async def move_to_available(self) -> None:
-        """Make a channel available."""
-        log.trace("Making a channel available.")
-
-        channel = await self.get_available_candidate()
-        log.info(f"Making #{channel} ({channel.id}) available.")
-
-        await self.send_available_message(channel)
-
-        log.trace(f"Moving #{channel} ({channel.id}) to the Available category.")
-
-        await self.move_to_bottom_position(
-            channel=channel,
-            category_id=constants.Categories.help_available,
-        )
-
-        self.report_stats()
-
-    async def move_to_dormant(self, channel: discord.TextChannel, caller: str) -> None:
-        """
-        Make the `channel` dormant.
-
-        A caller argument is provided for metrics.
-        """
-        log.info(f"Moving #{channel} ({channel.id}) to the Dormant category.")
-
-        await self.help_channel_claimants.delete(channel.id)
-        await self.move_to_bottom_position(
-            channel=channel,
-            category_id=constants.Categories.help_dormant,
-        )
-
-        self.bot.stats.incr(f"help.dormant_calls.{caller}")
-
-        in_use_time = await self.get_in_use_time(channel.id)
-        if in_use_time:
-            self.bot.stats.timing("help.in_use_time", in_use_time)
-
-        unanswered = await self.unanswered.get(channel.id)
-        if unanswered:
-            self.bot.stats.incr("help.sessions.unanswered")
-        elif unanswered is not None:
-            self.bot.stats.incr("help.sessions.answered")
-
-        log.trace(f"Position of #{channel} ({channel.id}) is actually {channel.position}.")
-        log.trace(f"Sending dormant message for #{channel} ({channel.id}).")
-        embed = discord.Embed(description=DORMANT_MSG)
-        await channel.send(embed=embed)
-
-        await self.unpin(channel)
-
-        log.trace(f"Pushing #{channel} ({channel.id}) into the channel queue.")
-        self.channel_queue.put_nowait(channel)
-        self.report_stats()
-
-    async def move_to_in_use(self, channel: discord.TextChannel) -> None:
-        """Make a channel in-use and schedule it to be made dormant."""
-        log.info(f"Moving #{channel} ({channel.id}) to the In Use category.")
-
-        await self.move_to_bottom_position(
-            channel=channel,
-            category_id=constants.Categories.help_in_use,
-        )
-
-        timeout = constants.HelpChannels.idle_minutes * 60
-
-        log.trace(f"Scheduling #{channel} ({channel.id}) to become dormant in {timeout} sec.")
-        self.scheduler.schedule_later(timeout, channel.id, self.move_idle_channel(channel))
-        self.report_stats()
-
-    async def notify(self) -> None:
-        """
-        Send a message notifying about a lack of available help channels.
-
-        Configuration:
-
-        * `HelpChannels.notify` - toggle notifications
-        * `HelpChannels.notify_channel` - destination channel for notifications
-        * `HelpChannels.notify_minutes` - minimum interval between notifications
-        * `HelpChannels.notify_roles` - roles mentioned in notifications
-        """
-        if not constants.HelpChannels.notify:
-            return
-
-        log.trace("Notifying about lack of channels.")
-
-        if self.last_notification:
-            elapsed = (datetime.utcnow() - self.last_notification).seconds
-            minimum_interval = constants.HelpChannels.notify_minutes * 60
-            should_send = elapsed >= minimum_interval
-        else:
-            should_send = True
-
-        if not should_send:
-            log.trace("Notification not sent because it's too recent since the previous one.")
-            return
-
-        try:
-            log.trace("Sending notification message.")
-
-            channel = self.bot.get_channel(constants.HelpChannels.notify_channel)
-            mentions = " ".join(f"<@&{role}>" for role in constants.HelpChannels.notify_roles)
-            allowed_roles = [discord.Object(id_) for id_ in constants.HelpChannels.notify_roles]
-
-            message = await channel.send(
-                f"{mentions} A new available help channel is needed but there "
-                f"are no more dormant ones. Consider freeing up some in-use channels manually by "
-                f"using the `{constants.Bot.prefix}dormant` command within the channels.",
-                allowed_mentions=discord.AllowedMentions(everyone=False, roles=allowed_roles)
-            )
-
-            self.bot.stats.incr("help.out_of_channel_alerts")
-
-            self.last_notification = message.created_at
-        except Exception:
-            # Handle it here cause this feature isn't critical for the functionality of the system.
-            log.exception("Failed to send notification about lack of dormant channels!")
-
-    async def check_for_answer(self, message: discord.Message) -> None:
-        """Checks for whether new content in a help channel comes from non-claimants."""
-        channel = message.channel
-
-        # Confirm the channel is an in use help channel
-        if channel_utils.is_in_category(channel, constants.Categories.help_in_use):
-            log.trace(f"Checking if #{channel} ({channel.id}) has been answered.")
-
-            # Check if there is an entry in unanswered
-            if await self.unanswered.contains(channel.id):
-                claimant_id = await self.help_channel_claimants.get(channel.id)
-                if not claimant_id:
-                    # The mapping for this channel doesn't exist, we can't do anything.
-                    return
-
-                # Check the message did not come from the claimant
-                if claimant_id != message.author.id:
-                    # Mark the channel as answered
-                    await self.unanswered.set(channel.id, False)
-
-    @commands.Cog.listener()
-    async def on_message(self, message: discord.Message) -> None:
-        """Move an available channel to the In Use category and replace it with a dormant one."""
-        if message.author.bot:
-            return  # Ignore messages sent by bots.
-
-        channel = message.channel
-
-        await self.check_for_answer(message)
-
-        is_available = channel_utils.is_in_category(channel, constants.Categories.help_available)
-        if not is_available or self.is_excluded_channel(channel):
-            return  # Ignore messages outside the Available category or in excluded channels.
-
-        log.trace("Waiting for the cog to be ready before processing messages.")
-        await self.ready.wait()
-
-        log.trace("Acquiring lock to prevent a channel from being processed twice...")
-        async with self.on_message_lock:
-            log.trace(f"on_message lock acquired for {message.id}.")
-
-            if not channel_utils.is_in_category(channel, constants.Categories.help_available):
-                log.debug(
-                    f"Message {message.id} will not make #{channel} ({channel.id}) in-use "
-                    f"because another message in the channel already triggered that."
-                )
-                return
-
-            log.info(f"Channel #{channel} was claimed by `{message.author.id}`.")
-            await self.move_to_in_use(channel)
-            await self.revoke_send_permissions(message.author)
-
-            await self.pin(message)
-
-            # Add user with channel for dormant check.
-            await self.help_channel_claimants.set(channel.id, message.author.id)
-
-            self.bot.stats.incr("help.claimed")
-
-            # Must use a timezone-aware datetime to ensure a correct POSIX timestamp.
-            timestamp = datetime.now(timezone.utc).timestamp()
-            await self.claim_times.set(channel.id, timestamp)
-
-            await self.unanswered.set(channel.id, True)
-
-            log.trace(f"Releasing on_message lock for {message.id}.")
-
-        # Move a dormant channel to the Available category to fill in the gap.
-        # This is done last and outside the lock because it may wait indefinitely for a channel to
-        # be put in the queue.
-        await self.move_to_available()
-
-    @commands.Cog.listener()
-    async def on_message_delete(self, msg: discord.Message) -> None:
-        """
-        Reschedule an in-use channel to become dormant sooner if the channel is empty.
-
-        The new time for the dormant task is configured with `HelpChannels.deleted_idle_minutes`.
-        """
-        if not channel_utils.is_in_category(msg.channel, constants.Categories.help_in_use):
-            return
-
-        if not await self.is_empty(msg.channel):
-            return
-
-        log.info(f"Claimant of #{msg.channel} ({msg.author}) deleted message, channel is empty now. Rescheduling task.")
-
-        # Cancel existing dormant task before scheduling new.
-        self.scheduler.cancel(msg.channel.id)
-
-        delay = constants.HelpChannels.deleted_idle_minutes * 60
-        self.scheduler.schedule_later(delay, msg.channel.id, self.move_idle_channel(msg.channel))
-
-    async def is_empty(self, channel: discord.TextChannel) -> bool:
-        """Return True if there's an AVAILABLE_MSG and the messages leading up are bot messages."""
-        log.trace(f"Checking if #{channel} ({channel.id}) is empty.")
-
-        # A limit of 100 results in a single API call.
-        # If AVAILABLE_MSG isn't found within 100 messages, then assume the channel is not empty.
-        # Not gonna do an extensive search for it cause it's too expensive.
-        async for msg in channel.history(limit=100):
-            if not msg.author.bot:
-                log.trace(f"#{channel} ({channel.id}) has a non-bot message.")
-                return False
-
-            if self.match_bot_embed(msg, AVAILABLE_MSG):
-                log.trace(f"#{channel} ({channel.id}) has the available message embed.")
-                return True
-
-        return False
-
-    async def check_cooldowns(self) -> None:
-        """Remove expired cooldowns and re-schedule active ones."""
-        log.trace("Checking all cooldowns to remove or re-schedule them.")
-        guild = self.bot.get_guild(constants.Guild.id)
-        cooldown = constants.HelpChannels.claim_minutes * 60
-
-        for channel_id, member_id in await self.help_channel_claimants.items():
-            member = guild.get_member(member_id)
-            if not member:
-                continue  # Member probably left the guild.
-
-            in_use_time = await self.get_in_use_time(channel_id)
-
-            if not in_use_time or in_use_time.seconds > cooldown:
-                # Remove the role if no claim time could be retrieved or if the cooldown expired.
-                # Since the channel is in the claimants cache, it is definitely strange for a time
-                # to not exist. However, it isn't a reason to keep the user stuck with a cooldown.
-                await self.remove_cooldown_role(member)
-            else:
-                # The member is still on a cooldown; re-schedule it for the remaining time.
-                delay = cooldown - in_use_time.seconds
-                self.scheduler.schedule_later(delay, member.id, self.remove_cooldown_role(member))
-
-    async def add_cooldown_role(self, member: discord.Member) -> None:
-        """Add the help cooldown role to `member`."""
-        log.trace(f"Adding cooldown role for {member} ({member.id}).")
-        await self._change_cooldown_role(member, member.add_roles)
-
-    async def remove_cooldown_role(self, member: discord.Member) -> None:
-        """Remove the help cooldown role from `member`."""
-        log.trace(f"Removing cooldown role for {member} ({member.id}).")
-        await self._change_cooldown_role(member, member.remove_roles)
-
-    async def _change_cooldown_role(self, member: discord.Member, coro_func: CoroutineFunc) -> None:
-        """
-        Change `member`'s cooldown role via awaiting `coro_func` and handle errors.
-
-        `coro_func` is intended to be `discord.Member.add_roles` or `discord.Member.remove_roles`.
-        """
-        guild = self.bot.get_guild(constants.Guild.id)
-        role = guild.get_role(constants.Roles.help_cooldown)
-        if role is None:
-            log.warning(f"Help cooldown role ({constants.Roles.help_cooldown}) could not be found!")
-            return
-
-        try:
-            await coro_func(role)
-        except discord.NotFound:
-            log.debug(f"Failed to change role for {member} ({member.id}): member not found")
-        except discord.Forbidden:
-            log.debug(
-                f"Forbidden to change role for {member} ({member.id}); "
-                f"possibly due to role hierarchy"
-            )
-        except discord.HTTPException as e:
-            log.error(f"Failed to change role for {member} ({member.id}): {e.status} {e.code}")
-
-    async def revoke_send_permissions(self, member: discord.Member) -> None:
-        """
-        Disallow `member` to send messages in the Available category for a certain time.
-
-        The time until permissions are reinstated can be configured with
-        `HelpChannels.claim_minutes`.
-        """
-        log.trace(
-            f"Revoking {member}'s ({member.id}) send message permissions in the Available category."
-        )
-
-        await self.add_cooldown_role(member)
-
-        # Cancel the existing task, if any.
-        # Would mean the user somehow bypassed the lack of permissions (e.g. user is guild owner).
-        if member.id in self.scheduler:
-            self.scheduler.cancel(member.id)
-
-        delay = constants.HelpChannels.claim_minutes * 60
-        self.scheduler.schedule_later(delay, member.id, self.remove_cooldown_role(member))
-
-    async def send_available_message(self, channel: discord.TextChannel) -> None:
-        """Send the available message by editing a dormant message or sending a new message."""
-        channel_info = f"#{channel} ({channel.id})"
-        log.trace(f"Sending available message in {channel_info}.")
-
-        embed = discord.Embed(
-            color=constants.Colours.bright_green,
-            description=AVAILABLE_MSG,
-        )
-        embed.set_author(name=AVAILABLE_TITLE, icon_url=constants.Icons.green_checkmark)
-        embed.set_footer(text=AVAILABLE_FOOTER)
-
-        msg = await self.get_last_message(channel)
-        if self.match_bot_embed(msg, DORMANT_MSG):
-            log.trace(f"Found dormant message {msg.id} in {channel_info}; editing it.")
-            await msg.edit(embed=embed)
-        else:
-            log.trace(f"Dormant message not found in {channel_info}; sending a new message.")
-            await channel.send(embed=embed)
-
-    async def pin_wrapper(self, msg_id: int, channel: discord.TextChannel, *, pin: bool) -> bool:
-        """
-        Pin message `msg_id` in `channel` if `pin` is True or unpin if it's False.
-
-        Return True if successful and False otherwise.
-        """
-        channel_str = f"#{channel} ({channel.id})"
-        if pin:
-            func = self.bot.http.pin_message
-            verb = "pin"
-        else:
-            func = self.bot.http.unpin_message
-            verb = "unpin"
-
-        try:
-            await func(channel.id, msg_id)
-        except discord.HTTPException as e:
-            if e.code == 10008:
-                log.debug(f"Message {msg_id} in {channel_str} doesn't exist; can't {verb}.")
-            else:
-                log.exception(
-                    f"Error {verb}ning message {msg_id} in {channel_str}: {e.status} ({e.code})"
-                )
-            return False
-        else:
-            log.trace(f"{verb.capitalize()}ned message {msg_id} in {channel_str}.")
-            return True
-
-    async def pin(self, message: discord.Message) -> None:
-        """Pin an initial question `message` and store it in a cache."""
-        if await self.pin_wrapper(message.id, message.channel, pin=True):
-            await self.question_messages.set(message.channel.id, message.id)
-
-    async def unpin(self, channel: discord.TextChannel) -> None:
-        """Unpin the initial question message sent in `channel`."""
-        msg_id = await self.question_messages.pop(channel.id)
-        if msg_id is None:
-            log.debug(f"#{channel} ({channel.id}) doesn't have a message pinned.")
-        else:
-            await self.pin_wrapper(msg_id, channel, pin=False)
-
-    async def wait_for_dormant_channel(self) -> discord.TextChannel:
-        """Wait for a dormant channel to become available in the queue and return it."""
-        log.trace("Waiting for a dormant channel.")
-
-        task = asyncio.create_task(self.channel_queue.get())
-        self.queue_tasks.append(task)
-        channel = await task
-
-        log.trace(f"Channel #{channel} ({channel.id}) finally retrieved from the queue.")
-        self.queue_tasks.remove(task)
-
-        return channel
-
-
-def validate_config() -> None:
-    """Raise a ValueError if the cog's config is invalid."""
-    log.trace("Validating config.")
-    total = constants.HelpChannels.max_total_channels
-    available = constants.HelpChannels.max_available
-
-    if total == 0 or available == 0:
-        raise ValueError("max_total_channels and max_available and must be greater than 0.")
-
-    if total < available:
-        raise ValueError(
-            f"max_total_channels ({total}) must be greater than or equal to max_available "
-            f"({available})."
-        )
-
-    if total > MAX_CHANNELS_PER_CATEGORY:
-        raise ValueError(
-            f"max_total_channels ({total}) must be less than or equal to "
-            f"{MAX_CHANNELS_PER_CATEGORY} due to Discord's limit on channels per category."
-        )
-
-
-def setup(bot: Bot) -> None:
-    """Load the HelpChannels cog."""
-    try:
-        validate_config()
-    except ValueError as e:
-        log.error(f"HelpChannels cog will not be loaded due to misconfiguration: {e}")
-    else:
-        bot.add_cog(HelpChannels(bot))
diff --git a/bot/exts/help_channels/__init__.py b/bot/exts/help_channels/__init__.py
new file mode 100644
index 000000000..38444b707
--- /dev/null
+++ b/bot/exts/help_channels/__init__.py
@@ -0,0 +1,17 @@
+import logging
+
+from bot.bot import Bot
+
+log = logging.getLogger(__name__)
+
+
+def setup(bot: Bot) -> None:
+    """Load the HelpChannels cog."""
+    # Defer import to reduce side effects from importing the sync package.
+    from bot.exts.help_channels import _cog
+    try:
+        _cog.validate_config()
+    except ValueError as e:
+        log.error(f"HelpChannels cog will not be loaded due to misconfiguration: {e}")
+    else:
+        bot.add_cog(_cog.HelpChannels(bot))
diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
new file mode 100644
index 000000000..5e2a7dd71
--- /dev/null
+++ b/bot/exts/help_channels/_cog.py
@@ -0,0 +1,930 @@
+import asyncio
+import json
+import logging
+import random
+import typing as t
+from collections import deque
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import discord
+import discord.abc
+from async_rediscache import RedisCache
+from discord.ext import commands
+
+from bot import constants
+from bot.bot import Bot
+from bot.utils import channel as channel_utils
+from bot.utils.scheduling import Scheduler
+
+log = logging.getLogger(__name__)
+
+ASKING_GUIDE_URL = "https://pythondiscord.com/pages/asking-good-questions/"
+MAX_CHANNELS_PER_CATEGORY = 50
+EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
+
+HELP_CHANNEL_TOPIC = """
+This is a Python help channel. You can claim your own help channel in the Python Help: Available category.
+"""
+
+AVAILABLE_MSG = f"""
+**Send your question here to claim the channel**
+This channel will be dedicated to answering your question only. Others will try to answer and help you solve the issue.
+
+**Keep in mind:**
+• It's always ok to just ask your question. You don't need permission.
+• Explain what you expect to happen and what actually happens.
+• Include a code sample and error message, if you got any.
+
+For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
+"""
+
+AVAILABLE_TITLE = "Available help channel"
+
+AVAILABLE_FOOTER = f"Closes after {constants.HelpChannels.idle_minutes} minutes of inactivity or when you send !close."
+
+DORMANT_MSG = f"""
+This help channel has been marked as **dormant**, and has been moved into the **Help: Dormant** \
+category at the bottom of the channel list. It is no longer possible to send messages in this \
+channel until it becomes available again.
+
+If your question wasn't answered yet, you can claim a new help channel from the \
+**Help: Available** category by simply asking your question again. Consider rephrasing the \
+question to maximize your chance of getting a good answer. If you're not sure how, have a look \
+through our guide for **[asking a good question]({ASKING_GUIDE_URL})**.
+"""
+
+CoroutineFunc = t.Callable[..., t.Coroutine]
+
+
+class HelpChannels(commands.Cog):
+    """
+    Manage the help channel system of the guild.
+
+    The system is based on a 3-category system:
+
+    Available Category
+
+    * Contains channels which are ready to be occupied by someone who needs help
+    * Will always contain `constants.HelpChannels.max_available` channels; refilled automatically
+      from the pool of dormant channels
+        * Prioritise using the channels which have been dormant for the longest amount of time
+        * If there are no more dormant channels, the bot will automatically create a new one
+        * If there are no dormant channels to move, helpers will be notified (see `notify()`)
+    * When a channel becomes available, the dormant embed will be edited to show `AVAILABLE_MSG`
+    * User can only claim a channel at an interval `constants.HelpChannels.claim_minutes`
+        * To keep track of cooldowns, user which claimed a channel will have a temporary role
+
+    In Use Category
+
+    * Contains all channels which are occupied by someone needing help
+    * Channel moves to dormant category after `constants.HelpChannels.idle_minutes` of being idle
+    * Command can prematurely mark a channel as dormant
+        * Channel claimant is allowed to use the command
+        * Allowed roles for the command are configurable with `constants.HelpChannels.cmd_whitelist`
+    * When a channel becomes dormant, an embed with `DORMANT_MSG` will be sent
+
+    Dormant Category
+
+    * Contains channels which aren't in use
+    * Channels are used to refill the Available category
+
+    Help channels are named after the chemical elements in `bot/resources/elements.json`.
+    """
+
+    # This cache tracks which channels are claimed by which members.
+    # RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
+    help_channel_claimants = RedisCache()
+
+    # This cache maps a help channel to whether it has had any
+    # activity other than the original claimant. True being no other
+    # activity and False being other activity.
+    # RedisCache[discord.TextChannel.id, bool]
+    unanswered = RedisCache()
+
+    # This dictionary maps a help channel to the time it was claimed
+    # RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
+    claim_times = RedisCache()
+
+    # This cache maps a help channel to original question message in same channel.
+    # RedisCache[discord.TextChannel.id, discord.Message.id]
+    question_messages = RedisCache()
+
+    def __init__(self, bot: Bot):
+        self.bot = bot
+        self.scheduler = Scheduler(self.__class__.__name__)
+
+        # Categories
+        self.available_category: discord.CategoryChannel = None
+        self.in_use_category: discord.CategoryChannel = None
+        self.dormant_category: discord.CategoryChannel = None
+
+        # Queues
+        self.channel_queue: asyncio.Queue[discord.TextChannel] = None
+        self.name_queue: t.Deque[str] = None
+
+        self.name_positions = self.get_names()
+        self.last_notification: t.Optional[datetime] = None
+
+        # Asyncio stuff
+        self.queue_tasks: t.List[asyncio.Task] = []
+        self.ready = asyncio.Event()
+        self.on_message_lock = asyncio.Lock()
+        self.init_task = self.bot.loop.create_task(self.init_cog())
+
+    def cog_unload(self) -> None:
+        """Cancel the init task and scheduled tasks when the cog unloads."""
+        log.trace("Cog unload: cancelling the init_cog task")
+        self.init_task.cancel()
+
+        log.trace("Cog unload: cancelling the channel queue tasks")
+        for task in self.queue_tasks:
+            task.cancel()
+
+        self.scheduler.cancel_all()
+
+    def create_channel_queue(self) -> asyncio.Queue:
+        """
+        Return a queue of dormant channels to use for getting the next available channel.
+
+        The channels are added to the queue in a random order.
+        """
+        log.trace("Creating the channel queue.")
+
+        channels = list(self.get_category_channels(self.dormant_category))
+        random.shuffle(channels)
+
+        log.trace("Populating the channel queue with channels.")
+        queue = asyncio.Queue()
+        for channel in channels:
+            queue.put_nowait(channel)
+
+        return queue
+
+    async def create_dormant(self) -> t.Optional[discord.TextChannel]:
+        """
+        Create and return a new channel in the Dormant category.
+
+        The new channel will sync its permission overwrites with the category.
+
+        Return None if no more channel names are available.
+        """
+        log.trace("Getting a name for a new dormant channel.")
+
+        try:
+            name = self.name_queue.popleft()
+        except IndexError:
+            log.debug("No more names available for new dormant channels.")
+            return None
+
+        log.debug(f"Creating a new dormant channel named {name}.")
+        return await self.dormant_category.create_text_channel(name, topic=HELP_CHANNEL_TOPIC)
+
+    def create_name_queue(self) -> deque:
+        """Return a queue of element names to use for creating new channels."""
+        log.trace("Creating the chemical element name queue.")
+
+        used_names = self.get_used_names()
+
+        log.trace("Determining the available names.")
+        available_names = (name for name in self.name_positions if name not in used_names)
+
+        log.trace("Populating the name queue with names.")
+        return deque(available_names)
+
+    async def dormant_check(self, ctx: commands.Context) -> bool:
+        """Return True if the user is the help channel claimant or passes the role check."""
+        if await self.help_channel_claimants.get(ctx.channel.id) == ctx.author.id:
+            log.trace(f"{ctx.author} is the help channel claimant, passing the check for dormant.")
+            self.bot.stats.incr("help.dormant_invoke.claimant")
+            return True
+
+        log.trace(f"{ctx.author} is not the help channel claimant, checking roles.")
+        has_role = await commands.has_any_role(*constants.HelpChannels.cmd_whitelist).predicate(ctx)
+
+        if has_role:
+            self.bot.stats.incr("help.dormant_invoke.staff")
+
+        return has_role
+
+    @commands.command(name="close", aliases=["dormant", "solved"], enabled=False)
+    async def close_command(self, ctx: commands.Context) -> None:
+        """
+        Make the current in-use help channel dormant.
+
+        Make the channel dormant if the user passes the `dormant_check`,
+        delete the message that invoked this,
+        and reset the send permissions cooldown for the user who started the session.
+        """
+        log.trace("close command invoked; checking if the channel is in-use.")
+        if ctx.channel.category == self.in_use_category:
+            if await self.dormant_check(ctx):
+                await self.remove_cooldown_role(ctx.author)
+
+                # Ignore missing task when cooldown has passed but the channel still isn't dormant.
+                if ctx.author.id in self.scheduler:
+                    self.scheduler.cancel(ctx.author.id)
+
+                await self.move_to_dormant(ctx.channel, "command")
+                self.scheduler.cancel(ctx.channel.id)
+        else:
+            log.debug(f"{ctx.author} invoked command 'dormant' outside an in-use help channel")
+
+    async def get_available_candidate(self) -> discord.TextChannel:
+        """
+        Return a dormant channel to turn into an available channel.
+
+        If no channel is available, wait indefinitely until one becomes available.
+        """
+        log.trace("Getting an available channel candidate.")
+
+        try:
+            channel = self.channel_queue.get_nowait()
+        except asyncio.QueueEmpty:
+            log.info("No candidate channels in the queue; creating a new channel.")
+            channel = await self.create_dormant()
+
+            if not channel:
+                log.info("Couldn't create a candidate channel; waiting to get one from the queue.")
+                await self.notify()
+                channel = await self.wait_for_dormant_channel()
+
+        return channel
+
+    @staticmethod
+    def get_clean_channel_name(channel: discord.TextChannel) -> str:
+        """Return a clean channel name without status emojis prefix."""
+        prefix = constants.HelpChannels.name_prefix
+        try:
+            # Try to remove the status prefix using the index of the channel prefix
+            name = channel.name[channel.name.index(prefix):]
+            log.trace(f"The clean name for `{channel}` is `{name}`")
+        except ValueError:
+            # If, for some reason, the channel name does not contain "help-" fall back gracefully
+            log.info(f"Can't get clean name because `{channel}` isn't prefixed by `{prefix}`.")
+            name = channel.name
+
+        return name
+
+    @staticmethod
+    def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
+        """Check if a channel should be excluded from the help channel system."""
+        return not isinstance(channel, discord.TextChannel) or channel.id in EXCLUDED_CHANNELS
+
+    def get_category_channels(self, category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
+        """Yield the text channels of the `category` in an unsorted manner."""
+        log.trace(f"Getting text channels in the category '{category}' ({category.id}).")
+
+        # This is faster than using category.channels because the latter sorts them.
+        for channel in self.bot.get_guild(constants.Guild.id).channels:
+            if channel.category_id == category.id and not self.is_excluded_channel(channel):
+                yield channel
+
+    async def get_in_use_time(self, channel_id: int) -> t.Optional[timedelta]:
+        """Return the duration `channel_id` has been in use. Return None if it's not in use."""
+        log.trace(f"Calculating in use time for channel {channel_id}.")
+
+        claimed_timestamp = await self.claim_times.get(channel_id)
+        if claimed_timestamp:
+            claimed = datetime.utcfromtimestamp(claimed_timestamp)
+            return datetime.utcnow() - claimed
+
+    @staticmethod
+    def get_names() -> t.List[str]:
+        """
+        Return a truncated list of prefixed element names.
+
+        The amount of names is configured with `HelpChannels.max_total_channels`.
+        The prefix is configured with `HelpChannels.name_prefix`.
+        """
+        count = constants.HelpChannels.max_total_channels
+        prefix = constants.HelpChannels.name_prefix
+
+        log.trace(f"Getting the first {count} element names from JSON.")
+
+        with Path("bot/resources/elements.json").open(encoding="utf-8") as elements_file:
+            all_names = json.load(elements_file)
+
+        if prefix:
+            return [prefix + name for name in all_names[:count]]
+        else:
+            return all_names[:count]
+
+    def get_used_names(self) -> t.Set[str]:
+        """Return channel names which are already being used."""
+        log.trace("Getting channel names which are already being used.")
+
+        names = set()
+        for cat in (self.available_category, self.in_use_category, self.dormant_category):
+            for channel in self.get_category_channels(cat):
+                names.add(self.get_clean_channel_name(channel))
+
+        if len(names) > MAX_CHANNELS_PER_CATEGORY:
+            log.warning(
+                f"Too many help channels ({len(names)}) already exist! "
+                f"Discord only supports {MAX_CHANNELS_PER_CATEGORY} in a category."
+            )
+
+        log.trace(f"Got {len(names)} used names: {names}")
+        return names
+
+    @classmethod
+    async def get_idle_time(cls, channel: discord.TextChannel) -> t.Optional[int]:
+        """
+        Return the time elapsed, in seconds, since the last message sent in the `channel`.
+
+        Return None if the channel has no messages.
+        """
+        log.trace(f"Getting the idle time for #{channel} ({channel.id}).")
+
+        msg = await cls.get_last_message(channel)
+        if not msg:
+            log.debug(f"No idle time available; #{channel} ({channel.id}) has no messages.")
+            return None
+
+        idle_time = (datetime.utcnow() - msg.created_at).seconds
+
+        log.trace(f"#{channel} ({channel.id}) has been idle for {idle_time} seconds.")
+        return idle_time
+
+    @staticmethod
+    async def get_last_message(channel: discord.TextChannel) -> t.Optional[discord.Message]:
+        """Return the last message sent in the channel or None if no messages exist."""
+        log.trace(f"Getting the last message in #{channel} ({channel.id}).")
+
+        try:
+            return await channel.history(limit=1).next()  # noqa: B305
+        except discord.NoMoreItems:
+            log.debug(f"No last message available; #{channel} ({channel.id}) has no messages.")
+            return None
+
+    async def init_available(self) -> None:
+        """Initialise the Available category with channels."""
+        log.trace("Initialising the Available category with channels.")
+
+        channels = list(self.get_category_channels(self.available_category))
+        missing = constants.HelpChannels.max_available - len(channels)
+
+        # If we've got less than `max_available` channel available, we should add some.
+        if missing > 0:
+            log.trace(f"Moving {missing} missing channels to the Available category.")
+            for _ in range(missing):
+                await self.move_to_available()
+
+        # If for some reason we have more than `max_available` channels available,
+        # we should move the superfluous ones over to dormant.
+        elif missing < 0:
+            log.trace(f"Moving {abs(missing)} superfluous available channels over to the Dormant category.")
+            for channel in channels[:abs(missing)]:
+                await self.move_to_dormant(channel, "auto")
+
+    async def init_categories(self) -> None:
+        """Get the help category objects. Remove the cog if retrieval fails."""
+        log.trace("Getting the CategoryChannel objects for the help categories.")
+
+        try:
+            self.available_category = await channel_utils.try_get_channel(
+                constants.Categories.help_available
+            )
+            self.in_use_category = await channel_utils.try_get_channel(
+                constants.Categories.help_in_use
+            )
+            self.dormant_category = await channel_utils.try_get_channel(
+                constants.Categories.help_dormant
+            )
+        except discord.HTTPException:
+            log.exception("Failed to get a category; cog will be removed")
+            self.bot.remove_cog(self.qualified_name)
+
+    async def init_cog(self) -> None:
+        """Initialise the help channel system."""
+        log.trace("Waiting for the guild to be available before initialisation.")
+        await self.bot.wait_until_guild_available()
+
+        log.trace("Initialising the cog.")
+        await self.init_categories()
+        await self.check_cooldowns()
+
+        self.channel_queue = self.create_channel_queue()
+        self.name_queue = self.create_name_queue()
+
+        log.trace("Moving or rescheduling in-use channels.")
+        for channel in self.get_category_channels(self.in_use_category):
+            await self.move_idle_channel(channel, has_task=False)
+
+        # Prevent the command from being used until ready.
+        # The ready event wasn't used because channels could change categories between the time
+        # the command is invoked and the cog is ready (e.g. if move_idle_channel wasn't called yet).
+        # This may confuse users. So would potentially long delays for the cog to become ready.
+        self.close_command.enabled = True
+
+        await self.init_available()
+
+        log.info("Cog is ready!")
+        self.ready.set()
+
+        self.report_stats()
+
+    def report_stats(self) -> None:
+        """Report the channel count stats."""
+        total_in_use = sum(1 for _ in self.get_category_channels(self.in_use_category))
+        total_available = sum(1 for _ in self.get_category_channels(self.available_category))
+        total_dormant = sum(1 for _ in self.get_category_channels(self.dormant_category))
+
+        self.bot.stats.gauge("help.total.in_use", total_in_use)
+        self.bot.stats.gauge("help.total.available", total_available)
+        self.bot.stats.gauge("help.total.dormant", total_dormant)
+
+    @staticmethod
+    def is_claimant(member: discord.Member) -> bool:
+        """Return True if `member` has the 'Help Cooldown' role."""
+        return any(constants.Roles.help_cooldown == role.id for role in member.roles)
+
+    def match_bot_embed(self, message: t.Optional[discord.Message], description: str) -> bool:
+        """Return `True` if the bot's `message`'s embed description matches `description`."""
+        if not message or not message.embeds:
+            return False
+
+        bot_msg_desc = message.embeds[0].description
+        if bot_msg_desc is discord.Embed.Empty:
+            log.trace("Last message was a bot embed but it was empty.")
+            return False
+        return message.author == self.bot.user and bot_msg_desc.strip() == description.strip()
+
+    async def move_idle_channel(self, channel: discord.TextChannel, has_task: bool = True) -> None:
+        """
+        Make the `channel` dormant if idle or schedule the move if still active.
+
+        If `has_task` is True and rescheduling is required, the extant task to make the channel
+        dormant will first be cancelled.
+        """
+        log.trace(f"Handling in-use channel #{channel} ({channel.id}).")
+
+        if not await self.is_empty(channel):
+            idle_seconds = constants.HelpChannels.idle_minutes * 60
+        else:
+            idle_seconds = constants.HelpChannels.deleted_idle_minutes * 60
+
+        time_elapsed = await self.get_idle_time(channel)
+
+        if time_elapsed is None or time_elapsed >= idle_seconds:
+            log.info(
+                f"#{channel} ({channel.id}) is idle longer than {idle_seconds} seconds "
+                f"and will be made dormant."
+            )
+
+            await self.move_to_dormant(channel, "auto")
+        else:
+            # Cancel the existing task, if any.
+            if has_task:
+                self.scheduler.cancel(channel.id)
+
+            delay = idle_seconds - time_elapsed
+            log.info(
+                f"#{channel} ({channel.id}) is still active; "
+                f"scheduling it to be moved after {delay} seconds."
+            )
+
+            self.scheduler.schedule_later(delay, channel.id, self.move_idle_channel(channel))
+
+    async def move_to_bottom_position(self, channel: discord.TextChannel, category_id: int, **options) -> None:
+        """
+        Move the `channel` to the bottom position of `category` and edit channel attributes.
+
+        To ensure "stable sorting", we use the `bulk_channel_update` endpoint and provide the current
+        positions of the other channels in the category as-is. This should make sure that the channel
+        really ends up at the bottom of the category.
+
+        If `options` are provided, the channel will be edited after the move is completed. This is the
+        same order of operations that `discord.TextChannel.edit` uses. For information on available
+        options, see the documentation on `discord.TextChannel.edit`. While possible, position-related
+        options should be avoided, as it may interfere with the category move we perform.
+        """
+        # Get a fresh copy of the category from the bot to avoid the cache mismatch issue we had.
+        category = await channel_utils.try_get_channel(category_id)
+
+        payload = [{"id": c.id, "position": c.position} for c in category.channels]
+
+        # Calculate the bottom position based on the current highest position in the category. If the
+        # category is currently empty, we simply use the current position of the channel to avoid making
+        # unnecessary changes to positions in the guild.
+        bottom_position = payload[-1]["position"] + 1 if payload else channel.position
+
+        payload.append(
+            {
+                "id": channel.id,
+                "position": bottom_position,
+                "parent_id": category.id,
+                "lock_permissions": True,
+            }
+        )
+
+        # We use d.py's method to ensure our request is processed by d.py's rate limit manager
+        await self.bot.http.bulk_channel_update(category.guild.id, payload)
+
+        # Now that the channel is moved, we can edit the other attributes
+        if options:
+            await channel.edit(**options)
+
+    async def move_to_available(self) -> None:
+        """Make a channel available."""
+        log.trace("Making a channel available.")
+
+        channel = await self.get_available_candidate()
+        log.info(f"Making #{channel} ({channel.id}) available.")
+
+        await self.send_available_message(channel)
+
+        log.trace(f"Moving #{channel} ({channel.id}) to the Available category.")
+
+        await self.move_to_bottom_position(
+            channel=channel,
+            category_id=constants.Categories.help_available,
+        )
+
+        self.report_stats()
+
+    async def move_to_dormant(self, channel: discord.TextChannel, caller: str) -> None:
+        """
+        Make the `channel` dormant.
+
+        A caller argument is provided for metrics.
+        """
+        log.info(f"Moving #{channel} ({channel.id}) to the Dormant category.")
+
+        await self.help_channel_claimants.delete(channel.id)
+        await self.move_to_bottom_position(
+            channel=channel,
+            category_id=constants.Categories.help_dormant,
+        )
+
+        self.bot.stats.incr(f"help.dormant_calls.{caller}")
+
+        in_use_time = await self.get_in_use_time(channel.id)
+        if in_use_time:
+            self.bot.stats.timing("help.in_use_time", in_use_time)
+
+        unanswered = await self.unanswered.get(channel.id)
+        if unanswered:
+            self.bot.stats.incr("help.sessions.unanswered")
+        elif unanswered is not None:
+            self.bot.stats.incr("help.sessions.answered")
+
+        log.trace(f"Position of #{channel} ({channel.id}) is actually {channel.position}.")
+        log.trace(f"Sending dormant message for #{channel} ({channel.id}).")
+        embed = discord.Embed(description=DORMANT_MSG)
+        await channel.send(embed=embed)
+
+        await self.unpin(channel)
+
+        log.trace(f"Pushing #{channel} ({channel.id}) into the channel queue.")
+        self.channel_queue.put_nowait(channel)
+        self.report_stats()
+
+    async def move_to_in_use(self, channel: discord.TextChannel) -> None:
+        """Make a channel in-use and schedule it to be made dormant."""
+        log.info(f"Moving #{channel} ({channel.id}) to the In Use category.")
+
+        await self.move_to_bottom_position(
+            channel=channel,
+            category_id=constants.Categories.help_in_use,
+        )
+
+        timeout = constants.HelpChannels.idle_minutes * 60
+
+        log.trace(f"Scheduling #{channel} ({channel.id}) to become dormant in {timeout} sec.")
+        self.scheduler.schedule_later(timeout, channel.id, self.move_idle_channel(channel))
+        self.report_stats()
+
+    async def notify(self) -> None:
+        """
+        Send a message notifying about a lack of available help channels.
+
+        Configuration:
+
+        * `HelpChannels.notify` - toggle notifications
+        * `HelpChannels.notify_channel` - destination channel for notifications
+        * `HelpChannels.notify_minutes` - minimum interval between notifications
+        * `HelpChannels.notify_roles` - roles mentioned in notifications
+        """
+        if not constants.HelpChannels.notify:
+            return
+
+        log.trace("Notifying about lack of channels.")
+
+        if self.last_notification:
+            elapsed = (datetime.utcnow() - self.last_notification).seconds
+            minimum_interval = constants.HelpChannels.notify_minutes * 60
+            should_send = elapsed >= minimum_interval
+        else:
+            should_send = True
+
+        if not should_send:
+            log.trace("Notification not sent because it's too recent since the previous one.")
+            return
+
+        try:
+            log.trace("Sending notification message.")
+
+            channel = self.bot.get_channel(constants.HelpChannels.notify_channel)
+            mentions = " ".join(f"<@&{role}>" for role in constants.HelpChannels.notify_roles)
+            allowed_roles = [discord.Object(id_) for id_ in constants.HelpChannels.notify_roles]
+
+            message = await channel.send(
+                f"{mentions} A new available help channel is needed but there "
+                f"are no more dormant ones. Consider freeing up some in-use channels manually by "
+                f"using the `{constants.Bot.prefix}dormant` command within the channels.",
+                allowed_mentions=discord.AllowedMentions(everyone=False, roles=allowed_roles)
+            )
+
+            self.bot.stats.incr("help.out_of_channel_alerts")
+
+            self.last_notification = message.created_at
+        except Exception:
+            # Handle it here cause this feature isn't critical for the functionality of the system.
+            log.exception("Failed to send notification about lack of dormant channels!")
+
+    async def check_for_answer(self, message: discord.Message) -> None:
+        """Checks for whether new content in a help channel comes from non-claimants."""
+        channel = message.channel
+
+        # Confirm the channel is an in use help channel
+        if channel_utils.is_in_category(channel, constants.Categories.help_in_use):
+            log.trace(f"Checking if #{channel} ({channel.id}) has been answered.")
+
+            # Check if there is an entry in unanswered
+            if await self.unanswered.contains(channel.id):
+                claimant_id = await self.help_channel_claimants.get(channel.id)
+                if not claimant_id:
+                    # The mapping for this channel doesn't exist, we can't do anything.
+                    return
+
+                # Check the message did not come from the claimant
+                if claimant_id != message.author.id:
+                    # Mark the channel as answered
+                    await self.unanswered.set(channel.id, False)
+
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message) -> None:
+        """Move an available channel to the In Use category and replace it with a dormant one."""
+        if message.author.bot:
+            return  # Ignore messages sent by bots.
+
+        channel = message.channel
+
+        await self.check_for_answer(message)
+
+        is_available = channel_utils.is_in_category(channel, constants.Categories.help_available)
+        if not is_available or self.is_excluded_channel(channel):
+            return  # Ignore messages outside the Available category or in excluded channels.
+
+        log.trace("Waiting for the cog to be ready before processing messages.")
+        await self.ready.wait()
+
+        log.trace("Acquiring lock to prevent a channel from being processed twice...")
+        async with self.on_message_lock:
+            log.trace(f"on_message lock acquired for {message.id}.")
+
+            if not channel_utils.is_in_category(channel, constants.Categories.help_available):
+                log.debug(
+                    f"Message {message.id} will not make #{channel} ({channel.id}) in-use "
+                    f"because another message in the channel already triggered that."
+                )
+                return
+
+            log.info(f"Channel #{channel} was claimed by `{message.author.id}`.")
+            await self.move_to_in_use(channel)
+            await self.revoke_send_permissions(message.author)
+
+            await self.pin(message)
+
+            # Add user with channel for dormant check.
+            await self.help_channel_claimants.set(channel.id, message.author.id)
+
+            self.bot.stats.incr("help.claimed")
+
+            # Must use a timezone-aware datetime to ensure a correct POSIX timestamp.
+            timestamp = datetime.now(timezone.utc).timestamp()
+            await self.claim_times.set(channel.id, timestamp)
+
+            await self.unanswered.set(channel.id, True)
+
+            log.trace(f"Releasing on_message lock for {message.id}.")
+
+        # Move a dormant channel to the Available category to fill in the gap.
+        # This is done last and outside the lock because it may wait indefinitely for a channel to
+        # be put in the queue.
+        await self.move_to_available()
+
+    @commands.Cog.listener()
+    async def on_message_delete(self, msg: discord.Message) -> None:
+        """
+        Reschedule an in-use channel to become dormant sooner if the channel is empty.
+
+        The new time for the dormant task is configured with `HelpChannels.deleted_idle_minutes`.
+        """
+        if not channel_utils.is_in_category(msg.channel, constants.Categories.help_in_use):
+            return
+
+        if not await self.is_empty(msg.channel):
+            return
+
+        log.info(f"Claimant of #{msg.channel} ({msg.author}) deleted message, channel is empty now. Rescheduling task.")
+
+        # Cancel existing dormant task before scheduling new.
+        self.scheduler.cancel(msg.channel.id)
+
+        delay = constants.HelpChannels.deleted_idle_minutes * 60
+        self.scheduler.schedule_later(delay, msg.channel.id, self.move_idle_channel(msg.channel))
+
+    async def is_empty(self, channel: discord.TextChannel) -> bool:
+        """Return True if there's an AVAILABLE_MSG and the messages leading up are bot messages."""
+        log.trace(f"Checking if #{channel} ({channel.id}) is empty.")
+
+        # A limit of 100 results in a single API call.
+        # If AVAILABLE_MSG isn't found within 100 messages, then assume the channel is not empty.
+        # Not gonna do an extensive search for it cause it's too expensive.
+        async for msg in channel.history(limit=100):
+            if not msg.author.bot:
+                log.trace(f"#{channel} ({channel.id}) has a non-bot message.")
+                return False
+
+            if self.match_bot_embed(msg, AVAILABLE_MSG):
+                log.trace(f"#{channel} ({channel.id}) has the available message embed.")
+                return True
+
+        return False
+
+    async def check_cooldowns(self) -> None:
+        """Remove expired cooldowns and re-schedule active ones."""
+        log.trace("Checking all cooldowns to remove or re-schedule them.")
+        guild = self.bot.get_guild(constants.Guild.id)
+        cooldown = constants.HelpChannels.claim_minutes * 60
+
+        for channel_id, member_id in await self.help_channel_claimants.items():
+            member = guild.get_member(member_id)
+            if not member:
+                continue  # Member probably left the guild.
+
+            in_use_time = await self.get_in_use_time(channel_id)
+
+            if not in_use_time or in_use_time.seconds > cooldown:
+                # Remove the role if no claim time could be retrieved or if the cooldown expired.
+                # Since the channel is in the claimants cache, it is definitely strange for a time
+                # to not exist. However, it isn't a reason to keep the user stuck with a cooldown.
+                await self.remove_cooldown_role(member)
+            else:
+                # The member is still on a cooldown; re-schedule it for the remaining time.
+                delay = cooldown - in_use_time.seconds
+                self.scheduler.schedule_later(delay, member.id, self.remove_cooldown_role(member))
+
+    async def add_cooldown_role(self, member: discord.Member) -> None:
+        """Add the help cooldown role to `member`."""
+        log.trace(f"Adding cooldown role for {member} ({member.id}).")
+        await self._change_cooldown_role(member, member.add_roles)
+
+    async def remove_cooldown_role(self, member: discord.Member) -> None:
+        """Remove the help cooldown role from `member`."""
+        log.trace(f"Removing cooldown role for {member} ({member.id}).")
+        await self._change_cooldown_role(member, member.remove_roles)
+
+    async def _change_cooldown_role(self, member: discord.Member, coro_func: CoroutineFunc) -> None:
+        """
+        Change `member`'s cooldown role via awaiting `coro_func` and handle errors.
+
+        `coro_func` is intended to be `discord.Member.add_roles` or `discord.Member.remove_roles`.
+        """
+        guild = self.bot.get_guild(constants.Guild.id)
+        role = guild.get_role(constants.Roles.help_cooldown)
+        if role is None:
+            log.warning(f"Help cooldown role ({constants.Roles.help_cooldown}) could not be found!")
+            return
+
+        try:
+            await coro_func(role)
+        except discord.NotFound:
+            log.debug(f"Failed to change role for {member} ({member.id}): member not found")
+        except discord.Forbidden:
+            log.debug(
+                f"Forbidden to change role for {member} ({member.id}); "
+                f"possibly due to role hierarchy"
+            )
+        except discord.HTTPException as e:
+            log.error(f"Failed to change role for {member} ({member.id}): {e.status} {e.code}")
+
+    async def revoke_send_permissions(self, member: discord.Member) -> None:
+        """
+        Disallow `member` to send messages in the Available category for a certain time.
+
+        The time until permissions are reinstated can be configured with
+        `HelpChannels.claim_minutes`.
+        """
+        log.trace(
+            f"Revoking {member}'s ({member.id}) send message permissions in the Available category."
+        )
+
+        await self.add_cooldown_role(member)
+
+        # Cancel the existing task, if any.
+        # Would mean the user somehow bypassed the lack of permissions (e.g. user is guild owner).
+        if member.id in self.scheduler:
+            self.scheduler.cancel(member.id)
+
+        delay = constants.HelpChannels.claim_minutes * 60
+        self.scheduler.schedule_later(delay, member.id, self.remove_cooldown_role(member))
+
+    async def send_available_message(self, channel: discord.TextChannel) -> None:
+        """Send the available message by editing a dormant message or sending a new message."""
+        channel_info = f"#{channel} ({channel.id})"
+        log.trace(f"Sending available message in {channel_info}.")
+
+        embed = discord.Embed(
+            color=constants.Colours.bright_green,
+            description=AVAILABLE_MSG,
+        )
+        embed.set_author(name=AVAILABLE_TITLE, icon_url=constants.Icons.green_checkmark)
+        embed.set_footer(text=AVAILABLE_FOOTER)
+
+        msg = await self.get_last_message(channel)
+        if self.match_bot_embed(msg, DORMANT_MSG):
+            log.trace(f"Found dormant message {msg.id} in {channel_info}; editing it.")
+            await msg.edit(embed=embed)
+        else:
+            log.trace(f"Dormant message not found in {channel_info}; sending a new message.")
+            await channel.send(embed=embed)
+
+    async def pin_wrapper(self, msg_id: int, channel: discord.TextChannel, *, pin: bool) -> bool:
+        """
+        Pin message `msg_id` in `channel` if `pin` is True or unpin if it's False.
+
+        Return True if successful and False otherwise.
+        """
+        channel_str = f"#{channel} ({channel.id})"
+        if pin:
+            func = self.bot.http.pin_message
+            verb = "pin"
+        else:
+            func = self.bot.http.unpin_message
+            verb = "unpin"
+
+        try:
+            await func(channel.id, msg_id)
+        except discord.HTTPException as e:
+            if e.code == 10008:
+                log.debug(f"Message {msg_id} in {channel_str} doesn't exist; can't {verb}.")
+            else:
+                log.exception(
+                    f"Error {verb}ning message {msg_id} in {channel_str}: {e.status} ({e.code})"
+                )
+            return False
+        else:
+            log.trace(f"{verb.capitalize()}ned message {msg_id} in {channel_str}.")
+            return True
+
+    async def pin(self, message: discord.Message) -> None:
+        """Pin an initial question `message` and store it in a cache."""
+        if await self.pin_wrapper(message.id, message.channel, pin=True):
+            await self.question_messages.set(message.channel.id, message.id)
+
+    async def unpin(self, channel: discord.TextChannel) -> None:
+        """Unpin the initial question message sent in `channel`."""
+        msg_id = await self.question_messages.pop(channel.id)
+        if msg_id is None:
+            log.debug(f"#{channel} ({channel.id}) doesn't have a message pinned.")
+        else:
+            await self.pin_wrapper(msg_id, channel, pin=False)
+
+    async def wait_for_dormant_channel(self) -> discord.TextChannel:
+        """Wait for a dormant channel to become available in the queue and return it."""
+        log.trace("Waiting for a dormant channel.")
+
+        task = asyncio.create_task(self.channel_queue.get())
+        self.queue_tasks.append(task)
+        channel = await task
+
+        log.trace(f"Channel #{channel} ({channel.id}) finally retrieved from the queue.")
+        self.queue_tasks.remove(task)
+
+        return channel
+
+
+def validate_config() -> None:
+    """Raise a ValueError if the cog's config is invalid."""
+    log.trace("Validating config.")
+    total = constants.HelpChannels.max_total_channels
+    available = constants.HelpChannels.max_available
+
+    if total == 0 or available == 0:
+        raise ValueError("max_total_channels and max_available and must be greater than 0.")
+
+    if total < available:
+        raise ValueError(
+            f"max_total_channels ({total}) must be greater than or equal to max_available "
+            f"({available})."
+        )
+
+    if total > MAX_CHANNELS_PER_CATEGORY:
+        raise ValueError(
+            f"max_total_channels ({total}) must be less than or equal to "
+            f"{MAX_CHANNELS_PER_CATEGORY} due to Discord's limit on channels per category."
+        )
-- 
cgit v1.2.3


From a1b2e8e9bff23ad5c9c8db8fa35116e7ce6a4965 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 11:44:23 -0700
Subject: Help channels: remove get_clean_channel_name

Emoji are no longer used in channel names due to harsher rate limits
for renaming channels. Therefore, the function is obsolete.
---
 bot/exts/help_channels/_cog.py | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 5e2a7dd71..00dd36304 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -251,21 +251,6 @@ class HelpChannels(commands.Cog):
 
         return channel
 
-    @staticmethod
-    def get_clean_channel_name(channel: discord.TextChannel) -> str:
-        """Return a clean channel name without status emojis prefix."""
-        prefix = constants.HelpChannels.name_prefix
-        try:
-            # Try to remove the status prefix using the index of the channel prefix
-            name = channel.name[channel.name.index(prefix):]
-            log.trace(f"The clean name for `{channel}` is `{name}`")
-        except ValueError:
-            # If, for some reason, the channel name does not contain "help-" fall back gracefully
-            log.info(f"Can't get clean name because `{channel}` isn't prefixed by `{prefix}`.")
-            name = channel.name
-
-        return name
-
     @staticmethod
     def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
         """Check if a channel should be excluded from the help channel system."""
@@ -317,7 +302,7 @@ class HelpChannels(commands.Cog):
         names = set()
         for cat in (self.available_category, self.in_use_category, self.dormant_category):
             for channel in self.get_category_channels(cat):
-                names.add(self.get_clean_channel_name(channel))
+                names.add(channel.name)
 
         if len(names) > MAX_CHANNELS_PER_CATEGORY:
             log.warning(
-- 
cgit v1.2.3


From abd6953a0f1567b6ff25d971a97eed966f469743 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 12:10:46 -0700
Subject: Help channels: move name and channel funcs to separate modules

---
 bot/exts/help_channels/_channels.py | 26 +++++++++++
 bot/exts/help_channels/_cog.py      | 93 ++++++-------------------------------
 bot/exts/help_channels/_names.py    | 69 +++++++++++++++++++++++++++
 3 files changed, 109 insertions(+), 79 deletions(-)
 create mode 100644 bot/exts/help_channels/_channels.py
 create mode 100644 bot/exts/help_channels/_names.py

diff --git a/bot/exts/help_channels/_channels.py b/bot/exts/help_channels/_channels.py
new file mode 100644
index 000000000..047f41e89
--- /dev/null
+++ b/bot/exts/help_channels/_channels.py
@@ -0,0 +1,26 @@
+import logging
+import typing as t
+
+import discord
+
+from bot import constants
+
+log = logging.getLogger(__name__)
+
+MAX_CHANNELS_PER_CATEGORY = 50
+EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
+
+
+def get_category_channels(category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
+    """Yield the text channels of the `category` in an unsorted manner."""
+    log.trace(f"Getting text channels in the category '{category}' ({category.id}).")
+
+    # This is faster than using category.channels because the latter sorts them.
+    for channel in category.guild.channels:
+        if channel.category_id == category.id and not is_excluded_channel(channel):
+            yield channel
+
+
+def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
+    """Check if a channel should be excluded from the help channel system."""
+    return not isinstance(channel, discord.TextChannel) or channel.id in EXCLUDED_CHANNELS
diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 00dd36304..1db597e6c 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -1,11 +1,8 @@
 import asyncio
-import json
 import logging
 import random
 import typing as t
-from collections import deque
 from datetime import datetime, timedelta, timezone
-from pathlib import Path
 
 import discord
 import discord.abc
@@ -14,14 +11,14 @@ from discord.ext import commands
 
 from bot import constants
 from bot.bot import Bot
+from bot.exts.help_channels import _channels
+from bot.exts.help_channels._names import MAX_CHANNELS_PER_CATEGORY, create_name_queue
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
 
 log = logging.getLogger(__name__)
 
 ASKING_GUIDE_URL = "https://pythondiscord.com/pages/asking-good-questions/"
-MAX_CHANNELS_PER_CATEGORY = 50
-EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
 
 HELP_CHANNEL_TOPIC = """
 This is a Python help channel. You can claim your own help channel in the Python Help: Available category.
@@ -123,7 +120,6 @@ class HelpChannels(commands.Cog):
         self.channel_queue: asyncio.Queue[discord.TextChannel] = None
         self.name_queue: t.Deque[str] = None
 
-        self.name_positions = self.get_names()
         self.last_notification: t.Optional[datetime] = None
 
         # Asyncio stuff
@@ -151,7 +147,7 @@ class HelpChannels(commands.Cog):
         """
         log.trace("Creating the channel queue.")
 
-        channels = list(self.get_category_channels(self.dormant_category))
+        channels = list(_channels.get_category_channels(self.dormant_category))
         random.shuffle(channels)
 
         log.trace("Populating the channel queue with channels.")
@@ -180,18 +176,6 @@ class HelpChannels(commands.Cog):
         log.debug(f"Creating a new dormant channel named {name}.")
         return await self.dormant_category.create_text_channel(name, topic=HELP_CHANNEL_TOPIC)
 
-    def create_name_queue(self) -> deque:
-        """Return a queue of element names to use for creating new channels."""
-        log.trace("Creating the chemical element name queue.")
-
-        used_names = self.get_used_names()
-
-        log.trace("Determining the available names.")
-        available_names = (name for name in self.name_positions if name not in used_names)
-
-        log.trace("Populating the name queue with names.")
-        return deque(available_names)
-
     async def dormant_check(self, ctx: commands.Context) -> bool:
         """Return True if the user is the help channel claimant or passes the role check."""
         if await self.help_channel_claimants.get(ctx.channel.id) == ctx.author.id:
@@ -251,20 +235,6 @@ class HelpChannels(commands.Cog):
 
         return channel
 
-    @staticmethod
-    def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
-        """Check if a channel should be excluded from the help channel system."""
-        return not isinstance(channel, discord.TextChannel) or channel.id in EXCLUDED_CHANNELS
-
-    def get_category_channels(self, category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
-        """Yield the text channels of the `category` in an unsorted manner."""
-        log.trace(f"Getting text channels in the category '{category}' ({category.id}).")
-
-        # This is faster than using category.channels because the latter sorts them.
-        for channel in self.bot.get_guild(constants.Guild.id).channels:
-            if channel.category_id == category.id and not self.is_excluded_channel(channel):
-                yield channel
-
     async def get_in_use_time(self, channel_id: int) -> t.Optional[timedelta]:
         """Return the duration `channel_id` has been in use. Return None if it's not in use."""
         log.trace(f"Calculating in use time for channel {channel_id}.")
@@ -274,45 +244,6 @@ class HelpChannels(commands.Cog):
             claimed = datetime.utcfromtimestamp(claimed_timestamp)
             return datetime.utcnow() - claimed
 
-    @staticmethod
-    def get_names() -> t.List[str]:
-        """
-        Return a truncated list of prefixed element names.
-
-        The amount of names is configured with `HelpChannels.max_total_channels`.
-        The prefix is configured with `HelpChannels.name_prefix`.
-        """
-        count = constants.HelpChannels.max_total_channels
-        prefix = constants.HelpChannels.name_prefix
-
-        log.trace(f"Getting the first {count} element names from JSON.")
-
-        with Path("bot/resources/elements.json").open(encoding="utf-8") as elements_file:
-            all_names = json.load(elements_file)
-
-        if prefix:
-            return [prefix + name for name in all_names[:count]]
-        else:
-            return all_names[:count]
-
-    def get_used_names(self) -> t.Set[str]:
-        """Return channel names which are already being used."""
-        log.trace("Getting channel names which are already being used.")
-
-        names = set()
-        for cat in (self.available_category, self.in_use_category, self.dormant_category):
-            for channel in self.get_category_channels(cat):
-                names.add(channel.name)
-
-        if len(names) > MAX_CHANNELS_PER_CATEGORY:
-            log.warning(
-                f"Too many help channels ({len(names)}) already exist! "
-                f"Discord only supports {MAX_CHANNELS_PER_CATEGORY} in a category."
-            )
-
-        log.trace(f"Got {len(names)} used names: {names}")
-        return names
-
     @classmethod
     async def get_idle_time(cls, channel: discord.TextChannel) -> t.Optional[int]:
         """
@@ -347,7 +278,7 @@ class HelpChannels(commands.Cog):
         """Initialise the Available category with channels."""
         log.trace("Initialising the Available category with channels.")
 
-        channels = list(self.get_category_channels(self.available_category))
+        channels = list(_channels.get_category_channels(self.available_category))
         missing = constants.HelpChannels.max_available - len(channels)
 
         # If we've got less than `max_available` channel available, we should add some.
@@ -391,10 +322,14 @@ class HelpChannels(commands.Cog):
         await self.check_cooldowns()
 
         self.channel_queue = self.create_channel_queue()
-        self.name_queue = self.create_name_queue()
+        self.name_queue = create_name_queue(
+            self.available_category,
+            self.in_use_category,
+            self.dormant_category,
+        )
 
         log.trace("Moving or rescheduling in-use channels.")
-        for channel in self.get_category_channels(self.in_use_category):
+        for channel in _channels.get_category_channels(self.in_use_category):
             await self.move_idle_channel(channel, has_task=False)
 
         # Prevent the command from being used until ready.
@@ -412,9 +347,9 @@ class HelpChannels(commands.Cog):
 
     def report_stats(self) -> None:
         """Report the channel count stats."""
-        total_in_use = sum(1 for _ in self.get_category_channels(self.in_use_category))
-        total_available = sum(1 for _ in self.get_category_channels(self.available_category))
-        total_dormant = sum(1 for _ in self.get_category_channels(self.dormant_category))
+        total_in_use = sum(1 for _ in _channels.get_category_channels(self.in_use_category))
+        total_available = sum(1 for _ in _channels.get_category_channels(self.available_category))
+        total_dormant = sum(1 for _ in _channels.get_category_channels(self.dormant_category))
 
         self.bot.stats.gauge("help.total.in_use", total_in_use)
         self.bot.stats.gauge("help.total.available", total_available)
@@ -660,7 +595,7 @@ class HelpChannels(commands.Cog):
         await self.check_for_answer(message)
 
         is_available = channel_utils.is_in_category(channel, constants.Categories.help_available)
-        if not is_available or self.is_excluded_channel(channel):
+        if not is_available or _channels.is_excluded_channel(channel):
             return  # Ignore messages outside the Available category or in excluded channels.
 
         log.trace("Waiting for the cog to be ready before processing messages.")
diff --git a/bot/exts/help_channels/_names.py b/bot/exts/help_channels/_names.py
new file mode 100644
index 000000000..9959c105e
--- /dev/null
+++ b/bot/exts/help_channels/_names.py
@@ -0,0 +1,69 @@
+import json
+import logging
+import typing as t
+from collections import deque
+from pathlib import Path
+
+import discord
+
+from bot import constants
+from bot.exts.help_channels._channels import MAX_CHANNELS_PER_CATEGORY, get_category_channels
+
+log = logging.getLogger(__name__)
+
+
+def create_name_queue(*categories: discord.CategoryChannel) -> deque:
+    """
+    Return a queue of element names to use for creating new channels.
+
+    Skip names that are already in use by channels in `categories`.
+    """
+    log.trace("Creating the chemical element name queue.")
+
+    used_names = _get_used_names(*categories)
+
+    log.trace("Determining the available names.")
+    available_names = (name for name in _get_names() if name not in used_names)
+
+    log.trace("Populating the name queue with names.")
+    return deque(available_names)
+
+
+def _get_names() -> t.List[str]:
+    """
+    Return a truncated list of prefixed element names.
+
+    The amount of names is configured with `HelpChannels.max_total_channels`.
+    The prefix is configured with `HelpChannels.name_prefix`.
+    """
+    count = constants.HelpChannels.max_total_channels
+    prefix = constants.HelpChannels.name_prefix
+
+    log.trace(f"Getting the first {count} element names from JSON.")
+
+    with Path("bot/resources/elements.json").open(encoding="utf-8") as elements_file:
+        all_names = json.load(elements_file)
+
+    if prefix:
+        return [prefix + name for name in all_names[:count]]
+    else:
+        return all_names[:count]
+
+
+def _get_used_names(*categories: discord.CategoryChannel) -> t.Set[str]:
+    """Return names which are already being used by channels in `categories`."""
+    log.trace("Getting channel names which are already being used.")
+
+    names = set()
+    for cat in categories:
+        for channel in get_category_channels(cat):
+            names.add(channel.name)
+
+    if len(names) > MAX_CHANNELS_PER_CATEGORY:
+        log.warning(
+            f"Too many help channels ({len(names)}) already exist! "
+            f"Discord only supports {MAX_CHANNELS_PER_CATEGORY} in a category."
+        )
+
+    log.trace(f"Got {len(names)} used names: {names}")
+    return names
-- 
cgit v1.2.3


From 0cc221a6169bd12ddcc605eb02f2785716d2446e Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 12:14:19 -0700
Subject: Help channels: move validation code to __init__.py

---
 bot/exts/help_channels/__init__.py | 32 ++++++++++++++++++++++++++++----
 bot/exts/help_channels/_cog.py     | 24 +-----------------------
 2 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/bot/exts/help_channels/__init__.py b/bot/exts/help_channels/__init__.py
index 38444b707..6ed94ebda 100644
--- a/bot/exts/help_channels/__init__.py
+++ b/bot/exts/help_channels/__init__.py
@@ -1,17 +1,41 @@
 import logging
 
+from bot import constants
 from bot.bot import Bot
+from bot.exts.help_channels._channels import MAX_CHANNELS_PER_CATEGORY
 
 log = logging.getLogger(__name__)
 
 
+def validate_config() -> None:
+    """Raise a ValueError if the cog's config is invalid."""
+    log.trace("Validating config.")
+    total = constants.HelpChannels.max_total_channels
+    available = constants.HelpChannels.max_available
+
+    if total == 0 or available == 0:
+        raise ValueError("max_total_channels and max_available and must be greater than 0.")
+
+    if total < available:
+        raise ValueError(
+            f"max_total_channels ({total}) must be greater than or equal to max_available "
+            f"({available})."
+        )
+
+    if total > MAX_CHANNELS_PER_CATEGORY:
+        raise ValueError(
+            f"max_total_channels ({total}) must be less than or equal to "
+            f"{MAX_CHANNELS_PER_CATEGORY} due to Discord's limit on channels per category."
+        )
+
+
 def setup(bot: Bot) -> None:
     """Load the HelpChannels cog."""
-    # Defer import to reduce side effects from importing the sync package.
-    from bot.exts.help_channels import _cog
+    # Defer import to reduce side effects from importing the help_channels package.
+    from bot.exts.help_channels._cog import HelpChannels
     try:
-        _cog.validate_config()
+        validate_config()
     except ValueError as e:
         log.error(f"HelpChannels cog will not be loaded due to misconfiguration: {e}")
     else:
-        bot.add_cog(_cog.HelpChannels(bot))
+        bot.add_cog(HelpChannels(bot))
diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 1db597e6c..d8fb3b830 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -12,7 +12,7 @@ from discord.ext import commands
 from bot import constants
 from bot.bot import Bot
 from bot.exts.help_channels import _channels
-from bot.exts.help_channels._names import MAX_CHANNELS_PER_CATEGORY, create_name_queue
+from bot.exts.help_channels._names import create_name_queue
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
 
@@ -826,25 +826,3 @@ class HelpChannels(commands.Cog):
         self.queue_tasks.remove(task)
 
         return channel
-
-
-def validate_config() -> None:
-    """Raise a ValueError if the cog's config is invalid."""
-    log.trace("Validating config.")
-    total = constants.HelpChannels.max_total_channels
-    available = constants.HelpChannels.max_available
-
-    if total == 0 or available == 0:
-        raise ValueError("max_total_channels and max_available and must be greater than 0.")
-
-    if total < available:
-        raise ValueError(
-            f"max_total_channels ({total}) must be greater than or equal to max_available "
-            f"({available})."
-        )
-
-    if total > MAX_CHANNELS_PER_CATEGORY:
-        raise ValueError(
-            f"max_total_channels ({total}) must be less than or equal to "
-            f"{MAX_CHANNELS_PER_CATEGORY} due to Discord's limit on channels per category."
-        )
-- 
cgit v1.2.3


From aa7eff22759e18bcbe0373e5397eb225f563e001 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 12:18:19 -0700
Subject: Help channels: rename modules to use singular tense

Plural names imply the modules contain homogenous content. For example,
"channels" implies the module contains multiple kinds of channels.
---
 bot/exts/help_channels/__init__.py  |  2 +-
 bot/exts/help_channels/_channel.py  | 26 ++++++++++++++
 bot/exts/help_channels/_channels.py | 26 --------------
 bot/exts/help_channels/_cog.py      | 18 +++++-----
 bot/exts/help_channels/_name.py     | 69 +++++++++++++++++++++++++++++++++++++
 bot/exts/help_channels/_names.py    | 69 -------------------------------------
 6 files changed, 105 insertions(+), 105 deletions(-)
 create mode 100644 bot/exts/help_channels/_channel.py
 delete mode 100644 bot/exts/help_channels/_channels.py
 create mode 100644 bot/exts/help_channels/_name.py
 delete mode 100644 bot/exts/help_channels/_names.py

diff --git a/bot/exts/help_channels/__init__.py b/bot/exts/help_channels/__init__.py
index 6ed94ebda..781f40449 100644
--- a/bot/exts/help_channels/__init__.py
+++ b/bot/exts/help_channels/__init__.py
@@ -2,7 +2,7 @@ import logging
 
 from bot import constants
 from bot.bot import Bot
-from bot.exts.help_channels._channels import MAX_CHANNELS_PER_CATEGORY
+from bot.exts.help_channels._channel import MAX_CHANNELS_PER_CATEGORY
 
 log = logging.getLogger(__name__)
 
diff --git a/bot/exts/help_channels/_channel.py b/bot/exts/help_channels/_channel.py
new file mode 100644
index 000000000..047f41e89
--- /dev/null
+++ b/bot/exts/help_channels/_channel.py
@@ -0,0 +1,26 @@
+import logging
+import typing as t
+
+import discord
+
+from bot import constants
+
+log = logging.getLogger(__name__)
+
+MAX_CHANNELS_PER_CATEGORY = 50
+EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
+
+
+def get_category_channels(category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
+    """Yield the text channels of the `category` in an unsorted manner."""
+    log.trace(f"Getting text channels in the category '{category}' ({category.id}).")
+
+    # This is faster than using category.channels because the latter sorts them.
+    for channel in category.guild.channels:
+        if channel.category_id == category.id and not is_excluded_channel(channel):
+            yield channel
+
+
+def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
+    """Check if a channel should be excluded from the help channel system."""
+    return not isinstance(channel, discord.TextChannel) or channel.id in EXCLUDED_CHANNELS
diff --git a/bot/exts/help_channels/_channels.py b/bot/exts/help_channels/_channels.py
deleted file mode 100644
index 047f41e89..000000000
--- a/bot/exts/help_channels/_channels.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import logging
-import typing as t
-
-import discord
-
-from bot import constants
-
-log = logging.getLogger(__name__)
-
-MAX_CHANNELS_PER_CATEGORY = 50
-EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
-
-
-def get_category_channels(category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
-    """Yield the text channels of the `category` in an unsorted manner."""
-    log.trace(f"Getting text channels in the category '{category}' ({category.id}).")
-
-    # This is faster than using category.channels because the latter sorts them.
-    for channel in category.guild.channels:
-        if channel.category_id == category.id and not is_excluded_channel(channel):
-            yield channel
-
-
-def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
-    """Check if a channel should be excluded from the help channel system."""
-    return not isinstance(channel, discord.TextChannel) or channel.id in EXCLUDED_CHANNELS
diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index d8fb3b830..e58660af8 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -11,8 +11,8 @@ from discord.ext import commands
 
 from bot import constants
 from bot.bot import Bot
-from bot.exts.help_channels import _channels
-from bot.exts.help_channels._names import create_name_queue
+from bot.exts.help_channels import _channel
+from bot.exts.help_channels._name import create_name_queue
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
 
@@ -147,7 +147,7 @@ class HelpChannels(commands.Cog):
         """
         log.trace("Creating the channel queue.")
 
-        channels = list(_channels.get_category_channels(self.dormant_category))
+        channels = list(_channel.get_category_channels(self.dormant_category))
         random.shuffle(channels)
 
         log.trace("Populating the channel queue with channels.")
@@ -278,7 +278,7 @@ class HelpChannels(commands.Cog):
         """Initialise the Available category with channels."""
         log.trace("Initialising the Available category with channels.")
 
-        channels = list(_channels.get_category_channels(self.available_category))
+        channels = list(_channel.get_category_channels(self.available_category))
         missing = constants.HelpChannels.max_available - len(channels)
 
         # If we've got less than `max_available` channel available, we should add some.
@@ -329,7 +329,7 @@ class HelpChannels(commands.Cog):
         )
 
         log.trace("Moving or rescheduling in-use channels.")
-        for channel in _channels.get_category_channels(self.in_use_category):
+        for channel in _channel.get_category_channels(self.in_use_category):
             await self.move_idle_channel(channel, has_task=False)
 
         # Prevent the command from being used until ready.
@@ -347,9 +347,9 @@ class HelpChannels(commands.Cog):
 
     def report_stats(self) -> None:
         """Report the channel count stats."""
-        total_in_use = sum(1 for _ in _channels.get_category_channels(self.in_use_category))
-        total_available = sum(1 for _ in _channels.get_category_channels(self.available_category))
-        total_dormant = sum(1 for _ in _channels.get_category_channels(self.dormant_category))
+        total_in_use = sum(1 for _ in _channel.get_category_channels(self.in_use_category))
+        total_available = sum(1 for _ in _channel.get_category_channels(self.available_category))
+        total_dormant = sum(1 for _ in _channel.get_category_channels(self.dormant_category))
 
         self.bot.stats.gauge("help.total.in_use", total_in_use)
         self.bot.stats.gauge("help.total.available", total_available)
@@ -595,7 +595,7 @@ class HelpChannels(commands.Cog):
         await self.check_for_answer(message)
 
         is_available = channel_utils.is_in_category(channel, constants.Categories.help_available)
-        if not is_available or _channels.is_excluded_channel(channel):
+        if not is_available or _channel.is_excluded_channel(channel):
             return  # Ignore messages outside the Available category or in excluded channels.
 
         log.trace("Waiting for the cog to be ready before processing messages.")
diff --git a/bot/exts/help_channels/_name.py b/bot/exts/help_channels/_name.py
new file mode 100644
index 000000000..728234b1e
--- /dev/null
+++ b/bot/exts/help_channels/_name.py
@@ -0,0 +1,69 @@
+import json
+import logging
+import typing as t
+from collections import deque
+from pathlib import Path
+
+import discord
+
+from bot import constants
+from bot.exts.help_channels._channel import MAX_CHANNELS_PER_CATEGORY, get_category_channels
+
+log = logging.getLogger(__name__)
+
+
+def create_name_queue(*categories: discord.CategoryChannel) -> deque:
+    """
+    Return a queue of element names to use for creating new channels.
+
+    Skip names that are already in use by channels in `categories`.
+    """
+    log.trace("Creating the chemical element name queue.")
+
+    used_names = _get_used_names(*categories)
+
+    log.trace("Determining the available names.")
+    available_names = (name for name in _get_names() if name not in used_names)
+
+    log.trace("Populating the name queue with names.")
+    return deque(available_names)
+
+
+def _get_names() -> t.List[str]:
+    """
+    Return a truncated list of prefixed element names.
+
+    The amount of names is configured with `HelpChannels.max_total_channels`.
+    The prefix is configured with `HelpChannels.name_prefix`.
+    """
+    count = constants.HelpChannels.max_total_channels
+    prefix = constants.HelpChannels.name_prefix
+
+    log.trace(f"Getting the first {count} element names from JSON.")
+
+    with Path("bot/resources/elements.json").open(encoding="utf-8") as elements_file:
+        all_names = json.load(elements_file)
+
+    if prefix:
+        return [prefix + name for name in all_names[:count]]
+    else:
+        return all_names[:count]
+
+
+def _get_used_names(*categories: discord.CategoryChannel) -> t.Set[str]:
+    """Return names which are already being used by channels in `categories`."""
+    log.trace("Getting channel names which are already being used.")
+
+    names = set()
+    for cat in categories:
+        for channel in get_category_channels(cat):
+            names.add(channel.name)
+
+    if len(names) > MAX_CHANNELS_PER_CATEGORY:
+        log.warning(
+            f"Too many help channels ({len(names)}) already exist! "
+            f"Discord only supports {MAX_CHANNELS_PER_CATEGORY} in a category."
+        )
+
+    log.trace(f"Got {len(names)} used names: {names}")
+    return names
diff --git a/bot/exts/help_channels/_names.py b/bot/exts/help_channels/_names.py
deleted file mode 100644
index 9959c105e..000000000
--- a/bot/exts/help_channels/_names.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import json
-import logging
-import typing as t
-from collections import deque
-from pathlib import Path
-
-import discord
-
-from bot import constants
-from bot.exts.help_channels._channels import MAX_CHANNELS_PER_CATEGORY, get_category_channels
-
-log = logging.getLogger(__name__)
-
-
-def create_name_queue(*categories: discord.CategoryChannel) -> deque:
-    """
-    Return a queue of element names to use for creating new channels.
-
-    Skip names that are already in use by channels in `categories`.
-    """
-    log.trace("Creating the chemical element name queue.")
-
-    used_names = _get_used_names(*categories)
-
-    log.trace("Determining the available names.")
-    available_names = (name for name in _get_names() if name not in used_names)
-
-    log.trace("Populating the name queue with names.")
-    return deque(available_names)
-
-
-def _get_names() -> t.List[str]:
-    """
-    Return a truncated list of prefixed element names.
-
-    The amount of names is configured with `HelpChannels.max_total_channels`.
-    The prefix is configured with `HelpChannels.name_prefix`.
-    """
-    count = constants.HelpChannels.max_total_channels
-    prefix = constants.HelpChannels.name_prefix
-
-    log.trace(f"Getting the first {count} element names from JSON.")
-
-    with Path("bot/resources/elements.json").open(encoding="utf-8") as elements_file:
-        all_names = json.load(elements_file)
-
-    if prefix:
-        return [prefix + name for name in all_names[:count]]
-    else:
-        return all_names[:count]
-
-
-def _get_used_names(*categories: discord.CategoryChannel) -> t.Set[str]:
-    """Return names which are already being used by channels in `categories`."""
-    log.trace("Getting channel names which are already being used.")
-
-    names = set()
-    for cat in categories:
-        for channel in get_category_channels(cat):
-            names.add(channel.name)
-
-    if len(names) > MAX_CHANNELS_PER_CATEGORY:
-        log.warning(
-            f"Too many help channels ({len(names)}) already exist! "
-            f"Discord only supports {MAX_CHANNELS_PER_CATEGORY} in a category."
-        )
-
-    log.trace(f"Got {len(names)} used names: {names}")
-    return names
-- 
cgit v1.2.3


From e7d6b2ba81e3609bd52e2d0c4c9d999e7deb14e8 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 13:31:13 -0700
Subject: Help channels: move pin functions to a separate module

---
 bot/exts/help_channels/_cog.py     | 50 ++--------------------------------
 bot/exts/help_channels/_message.py | 56 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 47 deletions(-)
 create mode 100644 bot/exts/help_channels/_message.py

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index e58660af8..b3d720b24 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -12,6 +12,7 @@ from discord.ext import commands
 from bot import constants
 from bot.bot import Bot
 from bot.exts.help_channels import _channel
+from bot.exts.help_channels._message import pin, unpin
 from bot.exts.help_channels._name import create_name_queue
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
@@ -103,10 +104,6 @@ class HelpChannels(commands.Cog):
     # RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
     claim_times = RedisCache()
 
-    # This cache maps a help channel to original question message in same channel.
-    # RedisCache[discord.TextChannel.id, discord.Message.id]
-    question_messages = RedisCache()
-
     def __init__(self, bot: Bot):
         self.bot = bot
         self.scheduler = Scheduler(self.__class__.__name__)
@@ -495,7 +492,7 @@ class HelpChannels(commands.Cog):
         embed = discord.Embed(description=DORMANT_MSG)
         await channel.send(embed=embed)
 
-        await self.unpin(channel)
+        await unpin(channel)
 
         log.trace(f"Pushing #{channel} ({channel.id}) into the channel queue.")
         self.channel_queue.put_nowait(channel)
@@ -616,7 +613,7 @@ class HelpChannels(commands.Cog):
             await self.move_to_in_use(channel)
             await self.revoke_send_permissions(message.author)
 
-            await self.pin(message)
+            await pin(message)
 
             # Add user with channel for dormant check.
             await self.help_channel_claimants.set(channel.id, message.author.id)
@@ -773,47 +770,6 @@ class HelpChannels(commands.Cog):
             log.trace(f"Dormant message not found in {channel_info}; sending a new message.")
             await channel.send(embed=embed)
 
-    async def pin_wrapper(self, msg_id: int, channel: discord.TextChannel, *, pin: bool) -> bool:
-        """
-        Pin message `msg_id` in `channel` if `pin` is True or unpin if it's False.
-
-        Return True if successful and False otherwise.
-        """
-        channel_str = f"#{channel} ({channel.id})"
-        if pin:
-            func = self.bot.http.pin_message
-            verb = "pin"
-        else:
-            func = self.bot.http.unpin_message
-            verb = "unpin"
-
-        try:
-            await func(channel.id, msg_id)
-        except discord.HTTPException as e:
-            if e.code == 10008:
-                log.debug(f"Message {msg_id} in {channel_str} doesn't exist; can't {verb}.")
-            else:
-                log.exception(
-                    f"Error {verb}ning message {msg_id} in {channel_str}: {e.status} ({e.code})"
-                )
-            return False
-        else:
-            log.trace(f"{verb.capitalize()}ned message {msg_id} in {channel_str}.")
-            return True
-
-    async def pin(self, message: discord.Message) -> None:
-        """Pin an initial question `message` and store it in a cache."""
-        if await self.pin_wrapper(message.id, message.channel, pin=True):
-            await self.question_messages.set(message.channel.id, message.id)
-
-    async def unpin(self, channel: discord.TextChannel) -> None:
-        """Unpin the initial question message sent in `channel`."""
-        msg_id = await self.question_messages.pop(channel.id)
-        if msg_id is None:
-            log.debug(f"#{channel} ({channel.id}) doesn't have a message pinned.")
-        else:
-            await self.pin_wrapper(msg_id, channel, pin=False)
-
     async def wait_for_dormant_channel(self) -> discord.TextChannel:
         """Wait for a dormant channel to become available in the queue and return it."""
         log.trace("Waiting for a dormant channel.")
diff --git a/bot/exts/help_channels/_message.py b/bot/exts/help_channels/_message.py
new file mode 100644
index 000000000..e593aacc9
--- /dev/null
+++ b/bot/exts/help_channels/_message.py
@@ -0,0 +1,56 @@
+import logging
+
+import discord
+from async_rediscache import RedisCache
+
+import bot
+
+log = logging.getLogger(__name__)
+
+# This cache maps a help channel to original question message in same channel.
+# RedisCache[discord.TextChannel.id, discord.Message.id]
+_question_messages = RedisCache(namespace="HelpChannels.question_messages")
+
+
+async def pin(message: discord.Message) -> None:
+    """Pin an initial question `message` and store it in a cache."""
+    if await _pin_wrapper(message.id, message.channel, pin=True):
+        await _question_messages.set(message.channel.id, message.id)
+
+
+async def unpin(channel: discord.TextChannel) -> None:
+    """Unpin the initial question message sent in `channel`."""
+    msg_id = await _question_messages.pop(channel.id)
+    if msg_id is None:
+        log.debug(f"#{channel} ({channel.id}) doesn't have a message pinned.")
+    else:
+        await _pin_wrapper(msg_id, channel, pin=False)
+
+
+async def _pin_wrapper(msg_id: int, channel: discord.TextChannel, *, pin: bool) -> bool:
+    """
+    Pin message `msg_id` in `channel` if `pin` is True or unpin if it's False.
+
+    Return True if successful and False otherwise.
+    """
+    channel_str = f"#{channel} ({channel.id})"
+    if pin:
+        func = bot.instance.http.pin_message
+        verb = "pin"
+    else:
+        func = bot.instance.http.unpin_message
+        verb = "unpin"
+
+    try:
+        await func(channel.id, msg_id)
+    except discord.HTTPException as e:
+        if e.code == 10008:
+            log.debug(f"Message {msg_id} in {channel_str} doesn't exist; can't {verb}.")
+        else:
+            log.exception(
+                f"Error {verb}ning message {msg_id} in {channel_str}: {e.status} ({e.code})"
+            )
+        return False
+    else:
+        log.trace(f"{verb.capitalize()}ned message {msg_id} in {channel_str}.")
+        return True
-- 
cgit v1.2.3


From e30d69f18dbfefefbc4034d744d0fad5198567c1 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 14:01:20 -0700
Subject: Help channels: move message functions to message module

---
 bot/exts/help_channels/_cog.py     | 197 ++++---------------------------------
 bot/exts/help_channels/_message.py | 172 ++++++++++++++++++++++++++++++++
 2 files changed, 191 insertions(+), 178 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index b3d720b24..174c40096 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -11,47 +11,17 @@ from discord.ext import commands
 
 from bot import constants
 from bot.bot import Bot
-from bot.exts.help_channels import _channel
-from bot.exts.help_channels._message import pin, unpin
+from bot.exts.help_channels import _channel, _message
 from bot.exts.help_channels._name import create_name_queue
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
 
 log = logging.getLogger(__name__)
 
-ASKING_GUIDE_URL = "https://pythondiscord.com/pages/asking-good-questions/"
-
 HELP_CHANNEL_TOPIC = """
 This is a Python help channel. You can claim your own help channel in the Python Help: Available category.
 """
 
-AVAILABLE_MSG = f"""
-**Send your question here to claim the channel**
-This channel will be dedicated to answering your question only. Others will try to answer and help you solve the issue.
-
-**Keep in mind:**
-• It's always ok to just ask your question. You don't need permission.
-• Explain what you expect to happen and what actually happens.
-• Include a code sample and error message, if you got any.
-
-For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
-"""
-
-AVAILABLE_TITLE = "Available help channel"
-
-AVAILABLE_FOOTER = f"Closes after {constants.HelpChannels.idle_minutes} minutes of inactivity or when you send !close."
-
-DORMANT_MSG = f"""
-This help channel has been marked as **dormant**, and has been moved into the **Help: Dormant** \
-category at the bottom of the channel list. It is no longer possible to send messages in this \
-channel until it becomes available again.
-
-If your question wasn't answered yet, you can claim a new help channel from the \
-**Help: Available** category by simply asking your question again. Consider rephrasing the \
-question to maximize your chance of getting a good answer. If you're not sure how, have a look \
-through our guide for **[asking a good question]({ASKING_GUIDE_URL})**.
-"""
-
 CoroutineFunc = t.Callable[..., t.Coroutine]
 
 
@@ -94,12 +64,6 @@ class HelpChannels(commands.Cog):
     # RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
     help_channel_claimants = RedisCache()
 
-    # This cache maps a help channel to whether it has had any
-    # activity other than the original claimant. True being no other
-    # activity and False being other activity.
-    # RedisCache[discord.TextChannel.id, bool]
-    unanswered = RedisCache()
-
     # This dictionary maps a help channel to the time it was claimed
     # RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
     claim_times = RedisCache()
@@ -227,7 +191,12 @@ class HelpChannels(commands.Cog):
 
             if not channel:
                 log.info("Couldn't create a candidate channel; waiting to get one from the queue.")
-                await self.notify()
+                notify_channel = self.bot.get_channel(constants.HelpChannels.notify_channel)
+                last_notification = await _message.notify(notify_channel, self.last_notification)
+                if last_notification:
+                    self.last_notification = last_notification
+                    self.bot.stats.incr("help.out_of_channel_alerts")
+
                 channel = await self.wait_for_dormant_channel()
 
         return channel
@@ -241,8 +210,8 @@ class HelpChannels(commands.Cog):
             claimed = datetime.utcfromtimestamp(claimed_timestamp)
             return datetime.utcnow() - claimed
 
-    @classmethod
-    async def get_idle_time(cls, channel: discord.TextChannel) -> t.Optional[int]:
+    @staticmethod
+    async def get_idle_time(channel: discord.TextChannel) -> t.Optional[int]:
         """
         Return the time elapsed, in seconds, since the last message sent in the `channel`.
 
@@ -250,7 +219,7 @@ class HelpChannels(commands.Cog):
         """
         log.trace(f"Getting the idle time for #{channel} ({channel.id}).")
 
-        msg = await cls.get_last_message(channel)
+        msg = await _message.get_last_message(channel)
         if not msg:
             log.debug(f"No idle time available; #{channel} ({channel.id}) has no messages.")
             return None
@@ -260,17 +229,6 @@ class HelpChannels(commands.Cog):
         log.trace(f"#{channel} ({channel.id}) has been idle for {idle_time} seconds.")
         return idle_time
 
-    @staticmethod
-    async def get_last_message(channel: discord.TextChannel) -> t.Optional[discord.Message]:
-        """Return the last message sent in the channel or None if no messages exist."""
-        log.trace(f"Getting the last message in #{channel} ({channel.id}).")
-
-        try:
-            return await channel.history(limit=1).next()  # noqa: B305
-        except discord.NoMoreItems:
-            log.debug(f"No last message available; #{channel} ({channel.id}) has no messages.")
-            return None
-
     async def init_available(self) -> None:
         """Initialise the Available category with channels."""
         log.trace("Initialising the Available category with channels.")
@@ -357,17 +315,6 @@ class HelpChannels(commands.Cog):
         """Return True if `member` has the 'Help Cooldown' role."""
         return any(constants.Roles.help_cooldown == role.id for role in member.roles)
 
-    def match_bot_embed(self, message: t.Optional[discord.Message], description: str) -> bool:
-        """Return `True` if the bot's `message`'s embed description matches `description`."""
-        if not message or not message.embeds:
-            return False
-
-        bot_msg_desc = message.embeds[0].description
-        if bot_msg_desc is discord.Embed.Empty:
-            log.trace("Last message was a bot embed but it was empty.")
-            return False
-        return message.author == self.bot.user and bot_msg_desc.strip() == description.strip()
-
     async def move_idle_channel(self, channel: discord.TextChannel, has_task: bool = True) -> None:
         """
         Make the `channel` dormant if idle or schedule the move if still active.
@@ -377,7 +324,7 @@ class HelpChannels(commands.Cog):
         """
         log.trace(f"Handling in-use channel #{channel} ({channel.id}).")
 
-        if not await self.is_empty(channel):
+        if not await _message.is_empty(channel):
             idle_seconds = constants.HelpChannels.idle_minutes * 60
         else:
             idle_seconds = constants.HelpChannels.deleted_idle_minutes * 60
@@ -450,7 +397,7 @@ class HelpChannels(commands.Cog):
         channel = await self.get_available_candidate()
         log.info(f"Making #{channel} ({channel.id}) available.")
 
-        await self.send_available_message(channel)
+        await _message.send_available_message(channel)
 
         log.trace(f"Moving #{channel} ({channel.id}) to the Available category.")
 
@@ -481,7 +428,7 @@ class HelpChannels(commands.Cog):
         if in_use_time:
             self.bot.stats.timing("help.in_use_time", in_use_time)
 
-        unanswered = await self.unanswered.get(channel.id)
+        unanswered = await _message.unanswered.get(channel.id)
         if unanswered:
             self.bot.stats.incr("help.sessions.unanswered")
         elif unanswered is not None:
@@ -489,10 +436,10 @@ class HelpChannels(commands.Cog):
 
         log.trace(f"Position of #{channel} ({channel.id}) is actually {channel.position}.")
         log.trace(f"Sending dormant message for #{channel} ({channel.id}).")
-        embed = discord.Embed(description=DORMANT_MSG)
+        embed = discord.Embed(description=_message.DORMANT_MSG)
         await channel.send(embed=embed)
 
-        await unpin(channel)
+        await _message.unpin(channel)
 
         log.trace(f"Pushing #{channel} ({channel.id}) into the channel queue.")
         self.channel_queue.put_nowait(channel)
@@ -513,74 +460,6 @@ class HelpChannels(commands.Cog):
         self.scheduler.schedule_later(timeout, channel.id, self.move_idle_channel(channel))
         self.report_stats()
 
-    async def notify(self) -> None:
-        """
-        Send a message notifying about a lack of available help channels.
-
-        Configuration:
-
-        * `HelpChannels.notify` - toggle notifications
-        * `HelpChannels.notify_channel` - destination channel for notifications
-        * `HelpChannels.notify_minutes` - minimum interval between notifications
-        * `HelpChannels.notify_roles` - roles mentioned in notifications
-        """
-        if not constants.HelpChannels.notify:
-            return
-
-        log.trace("Notifying about lack of channels.")
-
-        if self.last_notification:
-            elapsed = (datetime.utcnow() - self.last_notification).seconds
-            minimum_interval = constants.HelpChannels.notify_minutes * 60
-            should_send = elapsed >= minimum_interval
-        else:
-            should_send = True
-
-        if not should_send:
-            log.trace("Notification not sent because it's too recent since the previous one.")
-            return
-
-        try:
-            log.trace("Sending notification message.")
-
-            channel = self.bot.get_channel(constants.HelpChannels.notify_channel)
-            mentions = " ".join(f"<@&{role}>" for role in constants.HelpChannels.notify_roles)
-            allowed_roles = [discord.Object(id_) for id_ in constants.HelpChannels.notify_roles]
-
-            message = await channel.send(
-                f"{mentions} A new available help channel is needed but there "
-                f"are no more dormant ones. Consider freeing up some in-use channels manually by "
-                f"using the `{constants.Bot.prefix}dormant` command within the channels.",
-                allowed_mentions=discord.AllowedMentions(everyone=False, roles=allowed_roles)
-            )
-
-            self.bot.stats.incr("help.out_of_channel_alerts")
-
-            self.last_notification = message.created_at
-        except Exception:
-            # Handle it here cause this feature isn't critical for the functionality of the system.
-            log.exception("Failed to send notification about lack of dormant channels!")
-
-    async def check_for_answer(self, message: discord.Message) -> None:
-        """Checks for whether new content in a help channel comes from non-claimants."""
-        channel = message.channel
-
-        # Confirm the channel is an in use help channel
-        if channel_utils.is_in_category(channel, constants.Categories.help_in_use):
-            log.trace(f"Checking if #{channel} ({channel.id}) has been answered.")
-
-            # Check if there is an entry in unanswered
-            if await self.unanswered.contains(channel.id):
-                claimant_id = await self.help_channel_claimants.get(channel.id)
-                if not claimant_id:
-                    # The mapping for this channel doesn't exist, we can't do anything.
-                    return
-
-                # Check the message did not come from the claimant
-                if claimant_id != message.author.id:
-                    # Mark the channel as answered
-                    await self.unanswered.set(channel.id, False)
-
     @commands.Cog.listener()
     async def on_message(self, message: discord.Message) -> None:
         """Move an available channel to the In Use category and replace it with a dormant one."""
@@ -589,7 +468,7 @@ class HelpChannels(commands.Cog):
 
         channel = message.channel
 
-        await self.check_for_answer(message)
+        await _message.check_for_answer(message)
 
         is_available = channel_utils.is_in_category(channel, constants.Categories.help_available)
         if not is_available or _channel.is_excluded_channel(channel):
@@ -613,7 +492,7 @@ class HelpChannels(commands.Cog):
             await self.move_to_in_use(channel)
             await self.revoke_send_permissions(message.author)
 
-            await pin(message)
+            await _message.pin(message)
 
             # Add user with channel for dormant check.
             await self.help_channel_claimants.set(channel.id, message.author.id)
@@ -624,7 +503,7 @@ class HelpChannels(commands.Cog):
             timestamp = datetime.now(timezone.utc).timestamp()
             await self.claim_times.set(channel.id, timestamp)
 
-            await self.unanswered.set(channel.id, True)
+            await _message.unanswered.set(channel.id, True)
 
             log.trace(f"Releasing on_message lock for {message.id}.")
 
@@ -643,7 +522,7 @@ class HelpChannels(commands.Cog):
         if not channel_utils.is_in_category(msg.channel, constants.Categories.help_in_use):
             return
 
-        if not await self.is_empty(msg.channel):
+        if not await _message.is_empty(msg.channel):
             return
 
         log.info(f"Claimant of #{msg.channel} ({msg.author}) deleted message, channel is empty now. Rescheduling task.")
@@ -654,24 +533,6 @@ class HelpChannels(commands.Cog):
         delay = constants.HelpChannels.deleted_idle_minutes * 60
         self.scheduler.schedule_later(delay, msg.channel.id, self.move_idle_channel(msg.channel))
 
-    async def is_empty(self, channel: discord.TextChannel) -> bool:
-        """Return True if there's an AVAILABLE_MSG and the messages leading up are bot messages."""
-        log.trace(f"Checking if #{channel} ({channel.id}) is empty.")
-
-        # A limit of 100 results in a single API call.
-        # If AVAILABLE_MSG isn't found within 100 messages, then assume the channel is not empty.
-        # Not gonna do an extensive search for it cause it's too expensive.
-        async for msg in channel.history(limit=100):
-            if not msg.author.bot:
-                log.trace(f"#{channel} ({channel.id}) has a non-bot message.")
-                return False
-
-            if self.match_bot_embed(msg, AVAILABLE_MSG):
-                log.trace(f"#{channel} ({channel.id}) has the available message embed.")
-                return True
-
-        return False
-
     async def check_cooldowns(self) -> None:
         """Remove expired cooldowns and re-schedule active ones."""
         log.trace("Checking all cooldowns to remove or re-schedule them.")
@@ -750,26 +611,6 @@ class HelpChannels(commands.Cog):
         delay = constants.HelpChannels.claim_minutes * 60
         self.scheduler.schedule_later(delay, member.id, self.remove_cooldown_role(member))
 
-    async def send_available_message(self, channel: discord.TextChannel) -> None:
-        """Send the available message by editing a dormant message or sending a new message."""
-        channel_info = f"#{channel} ({channel.id})"
-        log.trace(f"Sending available message in {channel_info}.")
-
-        embed = discord.Embed(
-            color=constants.Colours.bright_green,
-            description=AVAILABLE_MSG,
-        )
-        embed.set_author(name=AVAILABLE_TITLE, icon_url=constants.Icons.green_checkmark)
-        embed.set_footer(text=AVAILABLE_FOOTER)
-
-        msg = await self.get_last_message(channel)
-        if self.match_bot_embed(msg, DORMANT_MSG):
-            log.trace(f"Found dormant message {msg.id} in {channel_info}; editing it.")
-            await msg.edit(embed=embed)
-        else:
-            log.trace(f"Dormant message not found in {channel_info}; sending a new message.")
-            await channel.send(embed=embed)
-
     async def wait_for_dormant_channel(self) -> discord.TextChannel:
         """Wait for a dormant channel to become available in the queue and return it."""
         log.trace("Waiting for a dormant channel.")
diff --git a/bot/exts/help_channels/_message.py b/bot/exts/help_channels/_message.py
index e593aacc9..eaf8b0ab5 100644
--- a/bot/exts/help_channels/_message.py
+++ b/bot/exts/help_channels/_message.py
@@ -1,23 +1,183 @@
 import logging
+import typing as t
+from datetime import datetime
 
 import discord
 from async_rediscache import RedisCache
 
 import bot
+from bot import constants
+from bot.utils.channel import is_in_category
 
 log = logging.getLogger(__name__)
 
+ASKING_GUIDE_URL = "https://pythondiscord.com/pages/asking-good-questions/"
+
+AVAILABLE_MSG = f"""
+**Send your question here to claim the channel**
+This channel will be dedicated to answering your question only. Others will try to answer and help you solve the issue.
+
+**Keep in mind:**
+• It's always ok to just ask your question. You don't need permission.
+• Explain what you expect to happen and what actually happens.
+• Include a code sample and error message, if you got any.
+
+For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
+"""
+
+AVAILABLE_TITLE = "Available help channel"
+
+AVAILABLE_FOOTER = f"Closes after {constants.HelpChannels.idle_minutes} minutes of inactivity or when you send !close."
+
+DORMANT_MSG = f"""
+This help channel has been marked as **dormant**, and has been moved into the **Help: Dormant** \
+category at the bottom of the channel list. It is no longer possible to send messages in this \
+channel until it becomes available again.
+
+If your question wasn't answered yet, you can claim a new help channel from the \
+**Help: Available** category by simply asking your question again. Consider rephrasing the \
+question to maximize your chance of getting a good answer. If you're not sure how, have a look \
+through our guide for **[asking a good question]({ASKING_GUIDE_URL})**.
+"""
+
+# This cache maps a help channel to whether it has had any
+# activity other than the original claimant. True being no other
+# activity and False being other activity.
+# RedisCache[discord.TextChannel.id, bool]
+unanswered = RedisCache(namespace="HelpChannels.unanswered")
+
+# This cache tracks which channels are claimed by which members.
+# RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
+_help_channel_claimants = RedisCache(namespace="HelpChannels.help_channel_claimants")
+
 # This cache maps a help channel to original question message in same channel.
 # RedisCache[discord.TextChannel.id, discord.Message.id]
 _question_messages = RedisCache(namespace="HelpChannels.question_messages")
 
 
+async def check_for_answer(message: discord.Message) -> None:
+    """Checks for whether new content in a help channel comes from non-claimants."""
+    channel = message.channel
+
+    # Confirm the channel is an in use help channel
+    if is_in_category(channel, constants.Categories.help_in_use):
+        log.trace(f"Checking if #{channel} ({channel.id}) has been answered.")
+
+        # Check if there is an entry in unanswered
+        if await unanswered.contains(channel.id):
+            claimant_id = await _help_channel_claimants.get(channel.id)
+            if not claimant_id:
+                # The mapping for this channel doesn't exist, we can't do anything.
+                return
+
+            # Check the message did not come from the claimant
+            if claimant_id != message.author.id:
+                # Mark the channel as answered
+                await unanswered.set(channel.id, False)
+
+
+async def get_last_message(channel: discord.TextChannel) -> t.Optional[discord.Message]:
+    """Return the last message sent in the channel or None if no messages exist."""
+    log.trace(f"Getting the last message in #{channel} ({channel.id}).")
+
+    try:
+        return await channel.history(limit=1).next()  # noqa: B305
+    except discord.NoMoreItems:
+        log.debug(f"No last message available; #{channel} ({channel.id}) has no messages.")
+        return None
+
+
+async def is_empty(channel: discord.TextChannel) -> bool:
+    """Return True if there's an AVAILABLE_MSG and the messages leading up are bot messages."""
+    log.trace(f"Checking if #{channel} ({channel.id}) is empty.")
+
+    # A limit of 100 results in a single API call.
+    # If AVAILABLE_MSG isn't found within 100 messages, then assume the channel is not empty.
+    # Not gonna do an extensive search for it cause it's too expensive.
+    async for msg in channel.history(limit=100):
+        if not msg.author.bot:
+            log.trace(f"#{channel} ({channel.id}) has a non-bot message.")
+            return False
+
+        if _match_bot_embed(msg, AVAILABLE_MSG):
+            log.trace(f"#{channel} ({channel.id}) has the available message embed.")
+            return True
+
+    return False
+
+
+async def notify(channel: discord.TextChannel, last_notification: t.Optional[datetime]) -> t.Optional[datetime]:
+    """
+    Send a message in `channel` notifying about a lack of available help channels.
+
+    Configuration:
+
+    * `HelpChannels.notify` - toggle notifications
+    * `HelpChannels.notify_minutes` - minimum interval between notifications
+    * `HelpChannels.notify_roles` - roles mentioned in notifications
+    """
+    if not constants.HelpChannels.notify:
+        return
+
+    log.trace("Notifying about lack of channels.")
+
+    if last_notification:
+        elapsed = (datetime.utcnow() - last_notification).seconds
+        minimum_interval = constants.HelpChannels.notify_minutes * 60
+        should_send = elapsed >= minimum_interval
+    else:
+        should_send = True
+
+    if not should_send:
+        log.trace("Notification not sent because it's too recent since the previous one.")
+        return
+
+    try:
+        log.trace("Sending notification message.")
+
+        mentions = " ".join(f"<@&{role}>" for role in constants.HelpChannels.notify_roles)
+        allowed_roles = [discord.Object(id_) for id_ in constants.HelpChannels.notify_roles]
+
+        message = await channel.send(
+            f"{mentions} A new available help channel is needed but there "
+            f"are no more dormant ones. Consider freeing up some in-use channels manually by "
+            f"using the `{constants.Bot.prefix}dormant` command within the channels.",
+            allowed_mentions=discord.AllowedMentions(everyone=False, roles=allowed_roles)
+        )
+
+        return message.created_at
+    except Exception:
+        # Handle it here cause this feature isn't critical for the functionality of the system.
+        log.exception("Failed to send notification about lack of dormant channels!")
+
+
 async def pin(message: discord.Message) -> None:
     """Pin an initial question `message` and store it in a cache."""
     if await _pin_wrapper(message.id, message.channel, pin=True):
         await _question_messages.set(message.channel.id, message.id)
 
 
+async def send_available_message(channel: discord.TextChannel) -> None:
+    """Send the available message by editing a dormant message or sending a new message."""
+    channel_info = f"#{channel} ({channel.id})"
+    log.trace(f"Sending available message in {channel_info}.")
+
+    embed = discord.Embed(
+        color=constants.Colours.bright_green,
+        description=AVAILABLE_MSG,
+    )
+    embed.set_author(name=AVAILABLE_TITLE, icon_url=constants.Icons.green_checkmark)
+    embed.set_footer(text=AVAILABLE_FOOTER)
+
+    msg = await get_last_message(channel)
+    if _match_bot_embed(msg, DORMANT_MSG):
+        log.trace(f"Found dormant message {msg.id} in {channel_info}; editing it.")
+        await msg.edit(embed=embed)
+    else:
+        log.trace(f"Dormant message not found in {channel_info}; sending a new message.")
+        await channel.send(embed=embed)
+
+
 async def unpin(channel: discord.TextChannel) -> None:
     """Unpin the initial question message sent in `channel`."""
     msg_id = await _question_messages.pop(channel.id)
@@ -27,6 +187,18 @@ async def unpin(channel: discord.TextChannel) -> None:
         await _pin_wrapper(msg_id, channel, pin=False)
 
 
+def _match_bot_embed(message: t.Optional[discord.Message], description: str) -> bool:
+    """Return `True` if the bot's `message`'s embed description matches `description`."""
+    if not message or not message.embeds:
+        return False
+
+    bot_msg_desc = message.embeds[0].description
+    if bot_msg_desc is discord.Embed.Empty:
+        log.trace("Last message was a bot embed but it was empty.")
+        return False
+    return message.author == bot.instance.user and bot_msg_desc.strip() == description.strip()
+
+
 async def _pin_wrapper(msg_id: int, channel: discord.TextChannel, *, pin: bool) -> bool:
     """
     Pin message `msg_id` in `channel` if `pin` is True or unpin if it's False.
-- 
cgit v1.2.3


From 44fe885de67135dd16a44539fc97d8e7fc543400 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 18 Oct 2020 18:56:08 -0700
Subject: Help channels: move time functions to channel module

---
 bot/exts/help_channels/_channel.py | 36 ++++++++++++++++++++++++++++++++++++
 bot/exts/help_channels/_cog.py     | 34 +++-------------------------------
 2 files changed, 39 insertions(+), 31 deletions(-)

diff --git a/bot/exts/help_channels/_channel.py b/bot/exts/help_channels/_channel.py
index 047f41e89..93c0c7fc9 100644
--- a/bot/exts/help_channels/_channel.py
+++ b/bot/exts/help_channels/_channel.py
@@ -1,15 +1,22 @@
 import logging
 import typing as t
+from datetime import datetime, timedelta
 
 import discord
+from async_rediscache import RedisCache
 
 from bot import constants
+from bot.exts.help_channels import _message
 
 log = logging.getLogger(__name__)
 
 MAX_CHANNELS_PER_CATEGORY = 50
 EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
 
+# This dictionary maps a help channel to the time it was claimed
+# RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
+_claim_times = RedisCache(namespace="HelpChannels.claim_times")
+
 
 def get_category_channels(category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
     """Yield the text channels of the `category` in an unsorted manner."""
@@ -21,6 +28,35 @@ def get_category_channels(category: discord.CategoryChannel) -> t.Iterable[disco
             yield channel
 
 
+async def get_idle_time(channel: discord.TextChannel) -> t.Optional[int]:
+    """
+    Return the time elapsed, in seconds, since the last message sent in the `channel`.
+
+    Return None if the channel has no messages.
+    """
+    log.trace(f"Getting the idle time for #{channel} ({channel.id}).")
+
+    msg = await _message.get_last_message(channel)
+    if not msg:
+        log.debug(f"No idle time available; #{channel} ({channel.id}) has no messages.")
+        return None
+
+    idle_time = (datetime.utcnow() - msg.created_at).seconds
+
+    log.trace(f"#{channel} ({channel.id}) has been idle for {idle_time} seconds.")
+    return idle_time
+
+
+async def get_in_use_time(channel_id: int) -> t.Optional[timedelta]:
+    """Return the duration `channel_id` has been in use. Return None if it's not in use."""
+    log.trace(f"Calculating in use time for channel {channel_id}.")
+
+    claimed_timestamp = await _claim_times.get(channel_id)
+    if claimed_timestamp:
+        claimed = datetime.utcfromtimestamp(claimed_timestamp)
+        return datetime.utcnow() - claimed
+
+
 def is_excluded_channel(channel: discord.abc.GuildChannel) -> bool:
     """Check if a channel should be excluded from the help channel system."""
     return not isinstance(channel, discord.TextChannel) or channel.id in EXCLUDED_CHANNELS
diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 174c40096..390528fde 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -2,7 +2,7 @@ import asyncio
 import logging
 import random
 import typing as t
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 
 import discord
 import discord.abc
@@ -201,34 +201,6 @@ class HelpChannels(commands.Cog):
 
         return channel
 
-    async def get_in_use_time(self, channel_id: int) -> t.Optional[timedelta]:
-        """Return the duration `channel_id` has been in use. Return None if it's not in use."""
-        log.trace(f"Calculating in use time for channel {channel_id}.")
-
-        claimed_timestamp = await self.claim_times.get(channel_id)
-        if claimed_timestamp:
-            claimed = datetime.utcfromtimestamp(claimed_timestamp)
-            return datetime.utcnow() - claimed
-
-    @staticmethod
-    async def get_idle_time(channel: discord.TextChannel) -> t.Optional[int]:
-        """
-        Return the time elapsed, in seconds, since the last message sent in the `channel`.
-
-        Return None if the channel has no messages.
-        """
-        log.trace(f"Getting the idle time for #{channel} ({channel.id}).")
-
-        msg = await _message.get_last_message(channel)
-        if not msg:
-            log.debug(f"No idle time available; #{channel} ({channel.id}) has no messages.")
-            return None
-
-        idle_time = (datetime.utcnow() - msg.created_at).seconds
-
-        log.trace(f"#{channel} ({channel.id}) has been idle for {idle_time} seconds.")
-        return idle_time
-
     async def init_available(self) -> None:
         """Initialise the Available category with channels."""
         log.trace("Initialising the Available category with channels.")
@@ -329,7 +301,7 @@ class HelpChannels(commands.Cog):
         else:
             idle_seconds = constants.HelpChannels.deleted_idle_minutes * 60
 
-        time_elapsed = await self.get_idle_time(channel)
+        time_elapsed = await _channel.get_idle_time(channel)
 
         if time_elapsed is None or time_elapsed >= idle_seconds:
             log.info(
@@ -424,7 +396,7 @@ class HelpChannels(commands.Cog):
 
         self.bot.stats.incr(f"help.dormant_calls.{caller}")
 
-        in_use_time = await self.get_in_use_time(channel.id)
+        in_use_time = await _channel.get_in_use_time(channel.id)
         if in_use_time:
             self.bot.stats.timing("help.in_use_time", in_use_time)
 
-- 
cgit v1.2.3


From 3843ae1546a1a1cbf7ca05756eee223bf7c2f317 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 18 Oct 2020 10:40:17 -0700
Subject: Help channels: move cooldown/role functions to cooldown module

---
 bot/exts/help_channels/_cog.py      |  88 ++-----------------------------
 bot/exts/help_channels/_cooldown.py | 100 ++++++++++++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 84 deletions(-)
 create mode 100644 bot/exts/help_channels/_cooldown.py

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 390528fde..169238937 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -11,7 +11,7 @@ from discord.ext import commands
 
 from bot import constants
 from bot.bot import Bot
-from bot.exts.help_channels import _channel, _message
+from bot.exts.help_channels import _channel, _cooldown, _message
 from bot.exts.help_channels._name import create_name_queue
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
@@ -22,8 +22,6 @@ HELP_CHANNEL_TOPIC = """
 This is a Python help channel. You can claim your own help channel in the Python Help: Available category.
 """
 
-CoroutineFunc = t.Callable[..., t.Coroutine]
-
 
 class HelpChannels(commands.Cog):
     """
@@ -164,7 +162,7 @@ class HelpChannels(commands.Cog):
         log.trace("close command invoked; checking if the channel is in-use.")
         if ctx.channel.category == self.in_use_category:
             if await self.dormant_check(ctx):
-                await self.remove_cooldown_role(ctx.author)
+                await _cooldown.remove_cooldown_role(ctx.author)
 
                 # Ignore missing task when cooldown has passed but the channel still isn't dormant.
                 if ctx.author.id in self.scheduler:
@@ -246,7 +244,7 @@ class HelpChannels(commands.Cog):
 
         log.trace("Initialising the cog.")
         await self.init_categories()
-        await self.check_cooldowns()
+        await _cooldown.check_cooldowns(self.scheduler)
 
         self.channel_queue = self.create_channel_queue()
         self.name_queue = create_name_queue(
@@ -462,7 +460,7 @@ class HelpChannels(commands.Cog):
 
             log.info(f"Channel #{channel} was claimed by `{message.author.id}`.")
             await self.move_to_in_use(channel)
-            await self.revoke_send_permissions(message.author)
+            await _cooldown.revoke_send_permissions(message.author, self.scheduler)
 
             await _message.pin(message)
 
@@ -505,84 +503,6 @@ class HelpChannels(commands.Cog):
         delay = constants.HelpChannels.deleted_idle_minutes * 60
         self.scheduler.schedule_later(delay, msg.channel.id, self.move_idle_channel(msg.channel))
 
-    async def check_cooldowns(self) -> None:
-        """Remove expired cooldowns and re-schedule active ones."""
-        log.trace("Checking all cooldowns to remove or re-schedule them.")
-        guild = self.bot.get_guild(constants.Guild.id)
-        cooldown = constants.HelpChannels.claim_minutes * 60
-
-        for channel_id, member_id in await self.help_channel_claimants.items():
-            member = guild.get_member(member_id)
-            if not member:
-                continue  # Member probably left the guild.
-
-            in_use_time = await self.get_in_use_time(channel_id)
-
-            if not in_use_time or in_use_time.seconds > cooldown:
-                # Remove the role if no claim time could be retrieved or if the cooldown expired.
-                # Since the channel is in the claimants cache, it is definitely strange for a time
-                # to not exist. However, it isn't a reason to keep the user stuck with a cooldown.
-                await self.remove_cooldown_role(member)
-            else:
-                # The member is still on a cooldown; re-schedule it for the remaining time.
-                delay = cooldown - in_use_time.seconds
-                self.scheduler.schedule_later(delay, member.id, self.remove_cooldown_role(member))
-
-    async def add_cooldown_role(self, member: discord.Member) -> None:
-        """Add the help cooldown role to `member`."""
-        log.trace(f"Adding cooldown role for {member} ({member.id}).")
-        await self._change_cooldown_role(member, member.add_roles)
-
-    async def remove_cooldown_role(self, member: discord.Member) -> None:
-        """Remove the help cooldown role from `member`."""
-        log.trace(f"Removing cooldown role for {member} ({member.id}).")
-        await self._change_cooldown_role(member, member.remove_roles)
-
-    async def _change_cooldown_role(self, member: discord.Member, coro_func: CoroutineFunc) -> None:
-        """
-        Change `member`'s cooldown role via awaiting `coro_func` and handle errors.
-
-        `coro_func` is intended to be `discord.Member.add_roles` or `discord.Member.remove_roles`.
-        """
-        guild = self.bot.get_guild(constants.Guild.id)
-        role = guild.get_role(constants.Roles.help_cooldown)
-        if role is None:
-            log.warning(f"Help cooldown role ({constants.Roles.help_cooldown}) could not be found!")
-            return
-
-        try:
-            await coro_func(role)
-        except discord.NotFound:
-            log.debug(f"Failed to change role for {member} ({member.id}): member not found")
-        except discord.Forbidden:
-            log.debug(
-                f"Forbidden to change role for {member} ({member.id}); "
-                f"possibly due to role hierarchy"
-            )
-        except discord.HTTPException as e:
-            log.error(f"Failed to change role for {member} ({member.id}): {e.status} {e.code}")
-
-    async def revoke_send_permissions(self, member: discord.Member) -> None:
-        """
-        Disallow `member` to send messages in the Available category for a certain time.
-
-        The time until permissions are reinstated can be configured with
-        `HelpChannels.claim_minutes`.
-        """
-        log.trace(
-            f"Revoking {member}'s ({member.id}) send message permissions in the Available category."
-        )
-
-        await self.add_cooldown_role(member)
-
-        # Cancel the existing task, if any.
-        # Would mean the user somehow bypassed the lack of permissions (e.g. user is guild owner).
-        if member.id in self.scheduler:
-            self.scheduler.cancel(member.id)
-
-        delay = constants.HelpChannels.claim_minutes * 60
-        self.scheduler.schedule_later(delay, member.id, self.remove_cooldown_role(member))
-
     async def wait_for_dormant_channel(self) -> discord.TextChannel:
         """Wait for a dormant channel to become available in the queue and return it."""
         log.trace("Waiting for a dormant channel.")
diff --git a/bot/exts/help_channels/_cooldown.py b/bot/exts/help_channels/_cooldown.py
new file mode 100644
index 000000000..c4fd4b662
--- /dev/null
+++ b/bot/exts/help_channels/_cooldown.py
@@ -0,0 +1,100 @@
+import logging
+from typing import Callable, Coroutine
+
+import discord
+from async_rediscache import RedisCache
+
+import bot
+from bot import constants
+from bot.exts.help_channels import _channel
+from bot.utils.scheduling import Scheduler
+
+log = logging.getLogger(__name__)
+CoroutineFunc = Callable[..., Coroutine]
+
+# This cache tracks which channels are claimed by which members.
+# RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
+_help_channel_claimants = RedisCache(namespace="HelpChannels.help_channel_claimants")
+
+
+async def add_cooldown_role(member: discord.Member) -> None:
+    """Add the help cooldown role to `member`."""
+    log.trace(f"Adding cooldown role for {member} ({member.id}).")
+    await _change_cooldown_role(member, member.add_roles)
+
+
+async def check_cooldowns(scheduler: Scheduler) -> None:
+    """Remove expired cooldowns and re-schedule active ones."""
+    log.trace("Checking all cooldowns to remove or re-schedule them.")
+    guild = bot.instance.get_guild(constants.Guild.id)
+    cooldown = constants.HelpChannels.claim_minutes * 60
+
+    for channel_id, member_id in await _help_channel_claimants.items():
+        member = guild.get_member(member_id)
+        if not member:
+            continue  # Member probably left the guild.
+
+        in_use_time = await _channel.get_in_use_time(channel_id)
+
+        if not in_use_time or in_use_time.seconds > cooldown:
+            # Remove the role if no claim time could be retrieved or if the cooldown expired.
+            # Since the channel is in the claimants cache, it is definitely strange for a time
+            # to not exist. However, it isn't a reason to keep the user stuck with a cooldown.
+            await remove_cooldown_role(member)
+        else:
+            # The member is still on a cooldown; re-schedule it for the remaining time.
+            delay = cooldown - in_use_time.seconds
+            scheduler.schedule_later(delay, member.id, remove_cooldown_role(member))
+
+
+async def remove_cooldown_role(member: discord.Member) -> None:
+    """Remove the help cooldown role from `member`."""
+    log.trace(f"Removing cooldown role for {member} ({member.id}).")
+    await _change_cooldown_role(member, member.remove_roles)
+
+
+async def revoke_send_permissions(member: discord.Member, scheduler: Scheduler) -> None:
+    """
+    Disallow `member` to send messages in the Available category for a certain time.
+
+    The time until permissions are reinstated can be configured with
+    `HelpChannels.claim_minutes`.
+    """
+    log.trace(
+        f"Revoking {member}'s ({member.id}) send message permissions in the Available category."
+    )
+
+    await add_cooldown_role(member)
+
+    # Cancel the existing task, if any.
+    # Would mean the user somehow bypassed the lack of permissions (e.g. user is guild owner).
+    if member.id in scheduler:
+        scheduler.cancel(member.id)
+
+    delay = constants.HelpChannels.claim_minutes * 60
+    scheduler.schedule_later(delay, member.id, remove_cooldown_role(member))
+
+
+async def _change_cooldown_role(member: discord.Member, coro_func: CoroutineFunc) -> None:
+    """
+    Change `member`'s cooldown role via awaiting `coro_func` and handle errors.
+
+    `coro_func` is intended to be `discord.Member.add_roles` or `discord.Member.remove_roles`.
+    """
+    guild = bot.instance.get_guild(constants.Guild.id)
+    role = guild.get_role(constants.Roles.help_cooldown)
+    if role is None:
+        log.warning(f"Help cooldown role ({constants.Roles.help_cooldown}) could not be found!")
+        return
+
+    try:
+        await coro_func(role)
+    except discord.NotFound:
+        log.debug(f"Failed to change role for {member} ({member.id}): member not found")
+    except discord.Forbidden:
+        log.debug(
+            f"Forbidden to change role for {member} ({member.id}); "
+            f"possibly due to role hierarchy"
+        )
+    except discord.HTTPException as e:
+        log.error(f"Failed to change role for {member} ({member.id}): {e.status} {e.code}")
-- 
cgit v1.2.3


From b9593039a1663c983b84970dc8832900ce9e4cbb Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 18 Oct 2020 18:58:43 -0700
Subject: Help channels: remove obsolete function

---
 bot/exts/help_channels/_cog.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 169238937..5c4a0d972 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -280,11 +280,6 @@ class HelpChannels(commands.Cog):
         self.bot.stats.gauge("help.total.available", total_available)
         self.bot.stats.gauge("help.total.dormant", total_dormant)
 
-    @staticmethod
-    def is_claimant(member: discord.Member) -> bool:
-        """Return True if `member` has the 'Help Cooldown' role."""
-        return any(constants.Roles.help_cooldown == role.id for role in member.roles)
-
     async def move_idle_channel(self, channel: discord.TextChannel, has_task: bool = True) -> None:
         """
         Make the `channel` dormant if idle or schedule the move if still active.
-- 
cgit v1.2.3


From 2eb56e4f863475307eafa070d22e71d061641f6a Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 19 Oct 2020 13:08:05 -0700
Subject: Help channels: replace ready event with awaiting the init task

The event is redundant since awaiting the task accomplishes the same
thing. If the task is already done, the await will finish immediately.
If the task gets cancelled, the error is raised but discord.py suppress
it in both commands and event listeners.
---
 bot/exts/help_channels/_cog.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 5c4a0d972..bea1f65e6 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -83,7 +83,6 @@ class HelpChannels(commands.Cog):
 
         # Asyncio stuff
         self.queue_tasks: t.List[asyncio.Task] = []
-        self.ready = asyncio.Event()
         self.on_message_lock = asyncio.Lock()
         self.init_task = self.bot.loop.create_task(self.init_cog())
 
@@ -264,11 +263,9 @@ class HelpChannels(commands.Cog):
         self.close_command.enabled = True
 
         await self.init_available()
+        self.report_stats()
 
         log.info("Cog is ready!")
-        self.ready.set()
-
-        self.report_stats()
 
     def report_stats(self) -> None:
         """Report the channel count stats."""
@@ -439,8 +436,9 @@ class HelpChannels(commands.Cog):
         if not is_available or _channel.is_excluded_channel(channel):
             return  # Ignore messages outside the Available category or in excluded channels.
 
-        log.trace("Waiting for the cog to be ready before processing messages.")
-        await self.ready.wait()
+        if not self.init_task.done():
+            log.trace("Waiting for the cog to be ready before processing messages.")
+            await self.init_task
 
         log.trace("Acquiring lock to prevent a channel from being processed twice...")
         async with self.on_message_lock:
-- 
cgit v1.2.3


From 9debf8d649e0f63753f0f486cd8b7490d90c324c Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 19 Oct 2020 13:08:29 -0700
Subject: Help channels: wait for cog to be ready in deleted msg listener

---
 bot/exts/help_channels/_cog.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index bea1f65e6..29570bab3 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -488,6 +488,10 @@ class HelpChannels(commands.Cog):
         if not await _message.is_empty(msg.channel):
             return
 
+        if not self.init_task.done():
+            log.trace("Waiting for the cog to be ready before processing deleted messages.")
+            await self.init_task
+
         log.info(f"Claimant of #{msg.channel} ({msg.author}) deleted message, channel is empty now. Rescheduling task.")
 
         # Cancel existing dormant task before scheduling new.
-- 
cgit v1.2.3


From 21f6a9a5f799c88f746b2bbda250ec1a6bb8f845 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 20 Oct 2020 12:31:40 -0700
Subject: Help channels: move all caches to a separate module

Some need to be shared among modules, so it became redundant to redefine
them in each module.
---
 bot/exts/help_channels/_caches.py   | 19 +++++++++++++++++++
 bot/exts/help_channels/_channel.py  |  9 ++-------
 bot/exts/help_channels/_cog.py      | 23 +++++++----------------
 bot/exts/help_channels/_cooldown.py |  9 ++-------
 bot/exts/help_channels/_message.py  | 26 ++++++--------------------
 5 files changed, 36 insertions(+), 50 deletions(-)
 create mode 100644 bot/exts/help_channels/_caches.py

diff --git a/bot/exts/help_channels/_caches.py b/bot/exts/help_channels/_caches.py
new file mode 100644
index 000000000..4cea385b7
--- /dev/null
+++ b/bot/exts/help_channels/_caches.py
@@ -0,0 +1,19 @@
+from async_rediscache import RedisCache
+
+# This dictionary maps a help channel to the time it was claimed
+# RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
+claim_times = RedisCache(namespace="HelpChannels.claim_times")
+
+# This cache tracks which channels are claimed by which members.
+# RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
+claimants = RedisCache(namespace="HelpChannels.help_channel_claimants")
+
+# This cache maps a help channel to original question message in same channel.
+# RedisCache[discord.TextChannel.id, discord.Message.id]
+question_messages = RedisCache(namespace="HelpChannels.question_messages")
+
+# This cache maps a help channel to whether it has had any
+# activity other than the original claimant. True being no other
+# activity and False being other activity.
+# RedisCache[discord.TextChannel.id, bool]
+unanswered = RedisCache(namespace="HelpChannels.unanswered")
diff --git a/bot/exts/help_channels/_channel.py b/bot/exts/help_channels/_channel.py
index 93c0c7fc9..d6d6f1245 100644
--- a/bot/exts/help_channels/_channel.py
+++ b/bot/exts/help_channels/_channel.py
@@ -3,20 +3,15 @@ import typing as t
 from datetime import datetime, timedelta
 
 import discord
-from async_rediscache import RedisCache
 
 from bot import constants
-from bot.exts.help_channels import _message
+from bot.exts.help_channels import _caches, _message
 
 log = logging.getLogger(__name__)
 
 MAX_CHANNELS_PER_CATEGORY = 50
 EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
 
-# This dictionary maps a help channel to the time it was claimed
-# RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
-_claim_times = RedisCache(namespace="HelpChannels.claim_times")
-
 
 def get_category_channels(category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
     """Yield the text channels of the `category` in an unsorted manner."""
@@ -51,7 +46,7 @@ async def get_in_use_time(channel_id: int) -> t.Optional[timedelta]:
     """Return the duration `channel_id` has been in use. Return None if it's not in use."""
     log.trace(f"Calculating in use time for channel {channel_id}.")
 
-    claimed_timestamp = await _claim_times.get(channel_id)
+    claimed_timestamp = await _caches.claim_times.get(channel_id)
     if claimed_timestamp:
         claimed = datetime.utcfromtimestamp(claimed_timestamp)
         return datetime.utcnow() - claimed
diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 29570bab3..a17213323 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -6,12 +6,11 @@ from datetime import datetime, timezone
 
 import discord
 import discord.abc
-from async_rediscache import RedisCache
 from discord.ext import commands
 
 from bot import constants
 from bot.bot import Bot
-from bot.exts.help_channels import _channel, _cooldown, _message
+from bot.exts.help_channels import _caches, _channel, _cooldown, _message
 from bot.exts.help_channels._name import create_name_queue
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
@@ -58,14 +57,6 @@ class HelpChannels(commands.Cog):
     Help channels are named after the chemical elements in `bot/resources/elements.json`.
     """
 
-    # This cache tracks which channels are claimed by which members.
-    # RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
-    help_channel_claimants = RedisCache()
-
-    # This dictionary maps a help channel to the time it was claimed
-    # RedisCache[discord.TextChannel.id, UtcPosixTimestamp]
-    claim_times = RedisCache()
-
     def __init__(self, bot: Bot):
         self.bot = bot
         self.scheduler = Scheduler(self.__class__.__name__)
@@ -136,7 +127,7 @@ class HelpChannels(commands.Cog):
 
     async def dormant_check(self, ctx: commands.Context) -> bool:
         """Return True if the user is the help channel claimant or passes the role check."""
-        if await self.help_channel_claimants.get(ctx.channel.id) == ctx.author.id:
+        if await _caches.claimants.get(ctx.channel.id) == ctx.author.id:
             log.trace(f"{ctx.author} is the help channel claimant, passing the check for dormant.")
             self.bot.stats.incr("help.dormant_invoke.claimant")
             return True
@@ -378,7 +369,7 @@ class HelpChannels(commands.Cog):
         """
         log.info(f"Moving #{channel} ({channel.id}) to the Dormant category.")
 
-        await self.help_channel_claimants.delete(channel.id)
+        await _caches.claimants.delete(channel.id)
         await self.move_to_bottom_position(
             channel=channel,
             category_id=constants.Categories.help_dormant,
@@ -390,7 +381,7 @@ class HelpChannels(commands.Cog):
         if in_use_time:
             self.bot.stats.timing("help.in_use_time", in_use_time)
 
-        unanswered = await _message.unanswered.get(channel.id)
+        unanswered = await _caches.unanswered.get(channel.id)
         if unanswered:
             self.bot.stats.incr("help.sessions.unanswered")
         elif unanswered is not None:
@@ -458,15 +449,15 @@ class HelpChannels(commands.Cog):
             await _message.pin(message)
 
             # Add user with channel for dormant check.
-            await self.help_channel_claimants.set(channel.id, message.author.id)
+            await _caches.claimants.set(channel.id, message.author.id)
 
             self.bot.stats.incr("help.claimed")
 
             # Must use a timezone-aware datetime to ensure a correct POSIX timestamp.
             timestamp = datetime.now(timezone.utc).timestamp()
-            await self.claim_times.set(channel.id, timestamp)
+            await _caches.claim_times.set(channel.id, timestamp)
 
-            await _message.unanswered.set(channel.id, True)
+            await _caches.unanswered.set(channel.id, True)
 
             log.trace(f"Releasing on_message lock for {message.id}.")
 
diff --git a/bot/exts/help_channels/_cooldown.py b/bot/exts/help_channels/_cooldown.py
index c4fd4b662..c5c39297f 100644
--- a/bot/exts/help_channels/_cooldown.py
+++ b/bot/exts/help_channels/_cooldown.py
@@ -2,20 +2,15 @@ import logging
 from typing import Callable, Coroutine
 
 import discord
-from async_rediscache import RedisCache
 
 import bot
 from bot import constants
-from bot.exts.help_channels import _channel
+from bot.exts.help_channels import _caches, _channel
 from bot.utils.scheduling import Scheduler
 
 log = logging.getLogger(__name__)
 CoroutineFunc = Callable[..., Coroutine]
 
-# This cache tracks which channels are claimed by which members.
-# RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
-_help_channel_claimants = RedisCache(namespace="HelpChannels.help_channel_claimants")
-
 
 async def add_cooldown_role(member: discord.Member) -> None:
     """Add the help cooldown role to `member`."""
@@ -29,7 +24,7 @@ async def check_cooldowns(scheduler: Scheduler) -> None:
     guild = bot.instance.get_guild(constants.Guild.id)
     cooldown = constants.HelpChannels.claim_minutes * 60
 
-    for channel_id, member_id in await _help_channel_claimants.items():
+    for channel_id, member_id in await _caches.claimants.items():
         member = guild.get_member(member_id)
         if not member:
             continue  # Member probably left the guild.
diff --git a/bot/exts/help_channels/_message.py b/bot/exts/help_channels/_message.py
index eaf8b0ab5..8b058d5aa 100644
--- a/bot/exts/help_channels/_message.py
+++ b/bot/exts/help_channels/_message.py
@@ -3,10 +3,10 @@ import typing as t
 from datetime import datetime
 
 import discord
-from async_rediscache import RedisCache
 
 import bot
 from bot import constants
+from bot.exts.help_channels import _caches
 from bot.utils.channel import is_in_category
 
 log = logging.getLogger(__name__)
@@ -40,20 +40,6 @@ question to maximize your chance of getting a good answer. If you're not sure ho
 through our guide for **[asking a good question]({ASKING_GUIDE_URL})**.
 """
 
-# This cache maps a help channel to whether it has had any
-# activity other than the original claimant. True being no other
-# activity and False being other activity.
-# RedisCache[discord.TextChannel.id, bool]
-unanswered = RedisCache(namespace="HelpChannels.unanswered")
-
-# This cache tracks which channels are claimed by which members.
-# RedisCache[discord.TextChannel.id, t.Union[discord.User.id, discord.Member.id]]
-_help_channel_claimants = RedisCache(namespace="HelpChannels.help_channel_claimants")
-
-# This cache maps a help channel to original question message in same channel.
-# RedisCache[discord.TextChannel.id, discord.Message.id]
-_question_messages = RedisCache(namespace="HelpChannels.question_messages")
-
 
 async def check_for_answer(message: discord.Message) -> None:
     """Checks for whether new content in a help channel comes from non-claimants."""
@@ -64,8 +50,8 @@ async def check_for_answer(message: discord.Message) -> None:
         log.trace(f"Checking if #{channel} ({channel.id}) has been answered.")
 
         # Check if there is an entry in unanswered
-        if await unanswered.contains(channel.id):
-            claimant_id = await _help_channel_claimants.get(channel.id)
+        if await _caches.unanswered.contains(channel.id):
+            claimant_id = await _caches.claimants.get(channel.id)
             if not claimant_id:
                 # The mapping for this channel doesn't exist, we can't do anything.
                 return
@@ -73,7 +59,7 @@ async def check_for_answer(message: discord.Message) -> None:
             # Check the message did not come from the claimant
             if claimant_id != message.author.id:
                 # Mark the channel as answered
-                await unanswered.set(channel.id, False)
+                await _caches.unanswered.set(channel.id, False)
 
 
 async def get_last_message(channel: discord.TextChannel) -> t.Optional[discord.Message]:
@@ -154,7 +140,7 @@ async def notify(channel: discord.TextChannel, last_notification: t.Optional[dat
 async def pin(message: discord.Message) -> None:
     """Pin an initial question `message` and store it in a cache."""
     if await _pin_wrapper(message.id, message.channel, pin=True):
-        await _question_messages.set(message.channel.id, message.id)
+        await _caches.question_messages.set(message.channel.id, message.id)
 
 
 async def send_available_message(channel: discord.TextChannel) -> None:
@@ -180,7 +166,7 @@ async def send_available_message(channel: discord.TextChannel) -> None:
 
 async def unpin(channel: discord.TextChannel) -> None:
     """Unpin the initial question message sent in `channel`."""
-    msg_id = await _question_messages.pop(channel.id)
+    msg_id = await _caches.question_messages.pop(channel.id)
     if msg_id is None:
         log.debug(f"#{channel} ({channel.id}) doesn't have a message pinned.")
     else:
-- 
cgit v1.2.3


From 47d65fca599d138098d5021d403db78e4abc0e7a Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 20 Nov 2020 16:42:24 -0800
Subject: Help channels: merge 2 imports into 1

The import was an outlier compared to how the other modules were
imported. It's nicer to keep the imports consistent.
---
 bot/exts/help_channels/_cog.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index a17213323..638d00e4a 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -10,8 +10,7 @@ from discord.ext import commands
 
 from bot import constants
 from bot.bot import Bot
-from bot.exts.help_channels import _caches, _channel, _cooldown, _message
-from bot.exts.help_channels._name import create_name_queue
+from bot.exts.help_channels import _caches, _channel, _cooldown, _message, _name
 from bot.utils import channel as channel_utils
 from bot.utils.scheduling import Scheduler
 
@@ -237,7 +236,7 @@ class HelpChannels(commands.Cog):
         await _cooldown.check_cooldowns(self.scheduler)
 
         self.channel_queue = self.create_channel_queue()
-        self.name_queue = create_name_queue(
+        self.name_queue = _name.create_name_queue(
             self.available_category,
             self.in_use_category,
             self.dormant_category,
-- 
cgit v1.2.3


From 8ea13768378deadef6e666ed40ed88ff8a08e16d Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Fri, 20 Nov 2020 22:22:10 -0500
Subject: `!close` removes the cooldown role from the claimant even when
 invoked by someone else; flattened `close_command`

---
 bot/exts/help_channels.py | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index f5a8b251b..e50fab7fc 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -213,18 +213,23 @@ class HelpChannels(commands.Cog):
         and reset the send permissions cooldown for the user who started the session.
         """
         log.trace("close command invoked; checking if the channel is in-use.")
-        if ctx.channel.category == self.in_use_category:
-            if await self.dormant_check(ctx):
-                await self.remove_cooldown_role(ctx.author)
+        if ctx.channel.category != self.in_use_category:
+            log.debug(f"{ctx.author} invoked command 'dormant' outside an in-use help channel")
+            return
 
-                # Ignore missing task when cooldown has passed but the channel still isn't dormant.
-                if ctx.author.id in self.scheduler:
-                    self.scheduler.cancel(ctx.author.id)
+        if not await self.dormant_check(ctx):
+            return
 
-                await self.move_to_dormant(ctx.channel, "command")
-                self.scheduler.cancel(ctx.channel.id)
-        else:
-            log.debug(f"{ctx.author} invoked command 'dormant' outside an in-use help channel")
+        guild = self.bot.get_guild(constants.Guild.id)
+        claimant = guild.get_member(await self.help_channel_claimants.get(ctx.channel.id))
+        await self.move_to_dormant(ctx.channel, "command")
+        await self.remove_cooldown_role(claimant)
+
+        # Ignore missing task when cooldown has passed but the channel still isn't dormant.
+        if ctx.author.id in self.scheduler:
+            self.scheduler.cancel(ctx.author.id)
+
+        self.scheduler.cancel(ctx.channel.id)
 
     async def get_available_candidate(self) -> discord.TextChannel:
         """
-- 
cgit v1.2.3

-- 
cgit v1.2.3


From 436cdcd1d4e1fc6dbf32a65d8cd76f644f653770 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Mon, 23 Nov 2020 23:48:21 +0100
Subject: Narrow down repository events that trigger a build

I've narrowed down repository events that trigger a Build to the "push"
event specifically. This means that we never build for a "pull request"
trigger, even if the source branch is called "master".

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 706ab462f..6152f1543 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,7 +10,7 @@ on:
 
 jobs:
   build:
-    if: github.event.workflow_run.conclusion == 'success'
+    if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event == 'push'
     name: Build & Push
     runs-on: ubuntu-latest
 
-- 
cgit v1.2.3


From 7b67df5d427a43b57df9a7f6e5ca13530958dfb4 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Mon, 23 Nov 2020 23:55:43 +0100
Subject: Open deployment.yaml from kubernetes repository

We will now use the deployment information located in the private
python-discord/kubernetes repository. The workflow will use a GitHub
Personal Access Token to access this private repository.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/deploy.yml |  5 ++++-
 deployment.yaml              | 21 ---------------------
 2 files changed, 4 insertions(+), 22 deletions(-)
 delete mode 100644 deployment.yaml

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 90555a8ee..5a4aede30 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -23,6 +23,9 @@ jobs:
 
       - name: Checkout code
         uses: actions/checkout@v2
+        with:
+          repository: python-discord/kubernetes
+          token: ${{ secrets.REPO_TOKEN }}
 
       - name: Authenticate with Kubernetes
         uses: azure/k8s-set-context@v1
@@ -34,6 +37,6 @@ jobs:
         uses: Azure/k8s-deploy@v1
         with:
           manifests: |
-              deployment.yaml
+              bot/deployment.yaml
           images: 'ghcr.io/python-discord/bot:${{ steps.sha_tag.outputs.tag }}'
           kubectl-version: 'latest'
diff --git a/deployment.yaml b/deployment.yaml
deleted file mode 100644
index ca5ff5941..000000000
--- a/deployment.yaml
+++ /dev/null
@@ -1,21 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: bot
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: bot
-  template:
-    metadata:
-      labels:
-        app: bot
-    spec:
-      containers:
-      - name: bot
-        image: ghcr.io/python-discord/bot:latest
-        imagePullPolicy: Always
-        envFrom:
-        - secretRef:
-            name: bot-env
-- 
cgit v1.2.3


From 17b9c1a895855414bc28060bc615280f22449062 Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Tue, 24 Nov 2020 09:06:38 +0000
Subject: Update CODEOWNERS

---
 .github/CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index cf5f1590d..8b1378917 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1 +1 @@
-* @python-discord/core-developers
+
-- 
cgit v1.2.3


From ed8160f3e73e2060630b10e1fb0b762e0a51294a Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Tue, 24 Nov 2020 09:11:03 +0000
Subject: Update CODEOWNERS

---
 .github/CODEOWNERS | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 8b1378917..cf343e5f0 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1 +1,2 @@
-
+# Request Joe for any PR
+* @jb3
-- 
cgit v1.2.3


From 6204906c734e0f0d44f7c1c544fbf4eb2443acc8 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
Date: Tue, 24 Nov 2020 21:56:34 +0300
Subject: Adds VoiceChannels and Related Chats to Config

Updates config-default.yml to include voice channels, and the text chat
channel they map to.

Signed-off-by: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
---
 bot/constants.py   |  7 +++++++
 config-default.yml | 13 ++++++++++---
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/bot/constants.py b/bot/constants.py
index 6bb6aacd2..ecbf5f98e 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -398,6 +398,9 @@ class Channels(metaclass=YAMLGetter):
     change_log: int
     code_help_voice: int
     code_help_voice_2: int
+    general_voice: int
+    admins_voice: int
+    staff_voice: int
     cooldown: int
     defcon: int
     dev_contrib: int
@@ -430,7 +433,11 @@ class Channels(metaclass=YAMLGetter):
     user_event_announcements: int
     user_log: int
     verification: int
+    code_help_chat: int
+    code_help_chat_2: int
     voice_chat: int
+    admins_voice_chat: int
+    staff_voice_chat: int
     voice_gate: int
     voice_log: int
 
diff --git a/config-default.yml b/config-default.yml
index 60eb437af..8ba3b7175 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -196,10 +196,17 @@ guild:
         mod_announcements:      &MOD_ANNOUNCEMENTS      372115205867700225
         admin_announcements:    &ADMIN_ANNOUNCEMENTS    749736155569848370
 
-        # Voice
-        code_help_voice:                    755154969761677312
-        code_help_voice_2:                  766330079135268884
+        # Voice Chat
+        code_help_chat:                     755154969761677312
+        code_help_chat_2:                   766330079135268884
         voice_chat:                         412357430186344448
+        admins_voice_chat:                  000000000000000000 # FIXME
+        staff_voice_chat:                   541638762007101470
+
+        # Voice Channels
+        code_help_voice:                    751592231726481530
+        code_help_voice_2:                  764232549840846858
+        general_voice:                      751591688538947646
         admins_voice:       &ADMINS_VOICE   500734494840717332
         staff_voice:        &STAFF_VOICE    412375055910043655
 
-- 
cgit v1.2.3


From 94bd6133be0eb284f20af5ae1da4f477cab59975 Mon Sep 17 00:00:00 2001
From: Dennis Pham <dennis@dennispham.me>
Date: Tue, 24 Nov 2020 15:18:38 -0500
Subject: Update CODEOWNERS

---
 .github/CODEOWNERS | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index cf343e5f0..1707c0244 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,2 +1,2 @@
-# Request Joe for any PR
-* @jb3
+# Request Joe and Dennis for any PR
+* @jb3 @Den4200
-- 
cgit v1.2.3


From 851f5a5ccc65a3f4d51cbfbc59472e8a3b6cdd8e Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 24 Nov 2020 13:35:33 -0800
Subject: Specify code ownership for Mark

---
 .github/CODEOWNERS | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 1707c0244..5cdbc76bd 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,2 +1,21 @@
 # Request Joe and Dennis for any PR
 * @jb3 @Den4200
+
+# Extensions
+**/bot/exts/backend/sync/**             @MarkKoz
+**/bot/exts/filters/*token_remover.py   @MarkKoz
+**/bot/exts/moderation/*silence.py      @MarkKoz
+bot/exts/info/codeblock/**              @MarkKoz
+bot/exts/utils/extensions.py            @MarkKoz
+bot/exts/utils/snekbox.py               @MarkKoz
+bot/exts/help_channels.py               @MarkKoz
+
+# Utils
+bot/utils/extensions.py                 @MarkKoz
+bot/utils/function.py                   @MarkKoz
+bot/utils/lock.py                       @MarkKoz
+bot/utils/scheduling.py                 @MarkKoz
+
+# Tests
+tests/_autospec.py                      @MarkKoz
+tests/bot/exts/test_cogs.py             @MarkKoz
-- 
cgit v1.2.3


From 0a49cb61085c2ceb8974decc69b200905bcf14e7 Mon Sep 17 00:00:00 2001
From: Mark <kozlovmark@gmail.com>
Date: Tue, 24 Nov 2020 13:46:09 -0800
Subject: Add Mark as a code owner of CI and Docker files

---
 .github/CODEOWNERS | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 5cdbc76bd..5f5386222 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -19,3 +19,8 @@ bot/utils/scheduling.py                 @MarkKoz
 # Tests
 tests/_autospec.py                      @MarkKoz
 tests/bot/exts/test_cogs.py             @MarkKoz
+
+# CI & Docker
+.github/workflows/**                    @MarkKoz
+Dockerfile                              @MarkKoz
+docker-compose.yml                      @MarkKoz
-- 
cgit v1.2.3


From 089efa35345af32c8f5475bb49bd09b9cd3f06c3 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Wed, 25 Nov 2020 16:09:40 -0500
Subject: `!close` removes role when they have no help channels left; needs to
 be fixed so role is removed when the channel times out

---
 bot/exts/help_channels.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index e50fab7fc..e1d28ece3 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -223,7 +223,10 @@ class HelpChannels(commands.Cog):
         guild = self.bot.get_guild(constants.Guild.id)
         claimant = guild.get_member(await self.help_channel_claimants.get(ctx.channel.id))
         await self.move_to_dormant(ctx.channel, "command")
-        await self.remove_cooldown_role(claimant)
+
+        # Remove the cooldown role if they have no other channels left
+        if claimant.id not in {user_id for _, user_id in await self.help_channel_claimants.items()}:
+            await self.remove_cooldown_role(claimant)
 
         # Ignore missing task when cooldown has passed but the channel still isn't dormant.
         if ctx.author.id in self.scheduler:
@@ -413,6 +416,8 @@ class HelpChannels(commands.Cog):
         for channel in self.get_category_channels(self.in_use_category):
             await self.move_idle_channel(channel, has_task=False)
 
+        log.trace(f'Initial state of help_channel_claimants: {await self.help_channel_claimants.items()}')
+
         # Prevent the command from being used until ready.
         # The ready event wasn't used because channels could change categories between the time
         # the command is invoked and the cog is ready (e.g. if move_idle_channel wasn't called yet).
-- 
cgit v1.2.3


From 731fea162705583e1ee6edeb5da270b628a018d5 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Wed, 25 Nov 2020 16:44:37 -0500
Subject: Moved the removal of the cooldown role from `close_command` to
 `move_to_dormant`

---
 bot/exts/help_channels.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index e1d28ece3..4fd4896df 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -220,14 +220,8 @@ class HelpChannels(commands.Cog):
         if not await self.dormant_check(ctx):
             return
 
-        guild = self.bot.get_guild(constants.Guild.id)
-        claimant = guild.get_member(await self.help_channel_claimants.get(ctx.channel.id))
         await self.move_to_dormant(ctx.channel, "command")
 
-        # Remove the cooldown role if they have no other channels left
-        if claimant.id not in {user_id for _, user_id in await self.help_channel_claimants.items()}:
-            await self.remove_cooldown_role(claimant)
-
         # Ignore missing task when cooldown has passed but the channel still isn't dormant.
         if ctx.author.id in self.scheduler:
             self.scheduler.cancel(ctx.author.id)
@@ -552,18 +546,25 @@ class HelpChannels(commands.Cog):
 
     async def move_to_dormant(self, channel: discord.TextChannel, caller: str) -> None:
         """
-        Make the `channel` dormant.
+        Make the `channel` dormant and remove the help cooldown role if it was the claimant's only channel.
 
         A caller argument is provided for metrics.
         """
         log.info(f"Moving #{channel} ({channel.id}) to the Dormant category.")
 
+        guild = self.bot.get_guild(constants.Guild.id)
+        claimant = guild.get_member(await self.help_channel_claimants.get(channel.id))
+
         await self.help_channel_claimants.delete(channel.id)
         await self.move_to_bottom_position(
             channel=channel,
             category_id=constants.Categories.help_dormant,
         )
 
+        # Remove the cooldown role if the claimant has no other channels left
+        if claimant.id not in {user_id for _, user_id in await self.help_channel_claimants.items()}:
+            await self.remove_cooldown_role(claimant)
+
         self.bot.stats.incr(f"help.dormant_calls.{caller}")
 
         in_use_time = await self.get_in_use_time(channel.id)
-- 
cgit v1.2.3


From 8c2e7ed9026219ecc6fdd528c1bfe55b5dc7700f Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Thu, 26 Nov 2020 17:16:55 +0100
Subject: Add voice_ban to supported types of the scheduler

The `voice_ban` infraction was not listed as a supported type for the
infraction scheduler. This meant that the scheduler did not schedule the
expiry of `voice_ban` infractions after a restart. Those unlucky users
were voice-banned perpetually.
---
 bot/exts/moderation/infraction/infractions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index 746d4e154..6056df1d2 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"})
+        super().__init__(bot, supported_infractions={"ban", "kick", "mute", "note", "warning", "voice_ban"})
 
         self.category = "Moderation"
         self._muted_role = discord.Object(constants.Roles.muted)
-- 
cgit v1.2.3


From 3f490ab413b64474bc7e40a2d66d3c3178d615ba Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Thu, 26 Nov 2020 13:34:03 -0500
Subject: Changes requested by @MarkKoz, new `unclaim_channel` method

Deleted expensive logging operation; moved cooldown role removal functionality to new `unclaim_channel` method; handle possibility that claimant has left the guild; optimized redis cache iteration with `any`
---
 bot/exts/help_channels.py | 46 ++++++++++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 20 deletions(-)

diff --git a/bot/exts/help_channels.py b/bot/exts/help_channels.py
index 5676728e9..25ca67d47 100644
--- a/bot/exts/help_channels.py
+++ b/bot/exts/help_channels.py
@@ -221,16 +221,9 @@ class HelpChannels(commands.Cog):
             log.debug(f"{ctx.author} invoked command 'dormant' outside an in-use help channel")
             return
 
-        if not await self.dormant_check(ctx):
-            return
-
-        await self.move_to_dormant(ctx.channel, "command")
-
-        # Ignore missing task when cooldown has passed but the channel still isn't dormant.
-        if ctx.author.id in self.scheduler:
-            self.scheduler.cancel(ctx.author.id)
-
-        self.scheduler.cancel(ctx.channel.id)
+        if await self.dormant_check(ctx):
+            await self.move_to_dormant(ctx.channel, "command")
+            self.scheduler.cancel(ctx.channel.id)
 
     async def get_available_candidate(self) -> discord.TextChannel:
         """
@@ -414,8 +407,6 @@ class HelpChannels(commands.Cog):
         for channel in self.get_category_channels(self.in_use_category):
             await self.move_idle_channel(channel, has_task=False)
 
-        log.trace(f'Initial state of help_channel_claimants: {await self.help_channel_claimants.items()}')
-
         # Prevent the command from being used until ready.
         # The ready event wasn't used because channels could change categories between the time
         # the command is invoked and the cog is ready (e.g. if move_idle_channel wasn't called yet).
@@ -550,24 +541,18 @@ class HelpChannels(commands.Cog):
 
     async def move_to_dormant(self, channel: discord.TextChannel, caller: str) -> None:
         """
-        Make the `channel` dormant and remove the help cooldown role if it was the claimant's only channel.
+        Make the `channel` dormant.
 
         A caller argument is provided for metrics.
         """
         log.info(f"Moving #{channel} ({channel.id}) to the Dormant category.")
 
-        guild = self.bot.get_guild(constants.Guild.id)
-        claimant = guild.get_member(await self.help_channel_claimants.get(channel.id))
-
-        await self.help_channel_claimants.delete(channel.id)
         await self.move_to_bottom_position(
             channel=channel,
             category_id=constants.Categories.help_dormant,
         )
 
-        # Remove the cooldown role if the claimant has no other channels left
-        if claimant.id not in {user_id for _, user_id in await self.help_channel_claimants.items()}:
-            await self.remove_cooldown_role(claimant)
+        await self.unclaim_channel(channel)
 
         self.bot.stats.incr(f"help.dormant_calls.{caller}")
 
@@ -592,6 +577,27 @@ class HelpChannels(commands.Cog):
         self.channel_queue.put_nowait(channel)
         self.report_stats()
 
+    async def unclaim_channel(self, channel: discord.TextChannel) -> None:
+        """
+        Deletes `channel` from the mapping of channels to claimants and removes the help cooldown
+        role from the claimant if it was their only channel
+        """
+        claimant_id = await self.help_channel_claimants.pop(channel.id)
+
+        # Ignore missing task when cooldown has passed but the channel still isn't dormant.
+        if claimant_id in self.scheduler:
+            self.scheduler.cancel(claimant_id)
+
+        claimant = self.bot.get_guild(constants.Guild.id).get_member(claimant_id)
+
+        if claimant is None:
+            # `claimant` has left the guild, so the cooldown role need not be removed
+            return
+
+        # Remove the cooldown role if the claimant has no other channels left
+        if not any(claimant.id == user_id for _, user_id in await self.help_channel_claimants.items()):
+            await self.remove_cooldown_role(claimant)
+
     async def move_to_in_use(self, channel: discord.TextChannel) -> None:
         """Make a channel in-use and schedule it to be made dormant."""
         log.info(f"Moving #{channel} ({channel.id}) to the In Use category.")
-- 
cgit v1.2.3


From 0242b4ed4145edf3e3e6ea6ebcef62aaff77d7ec Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 26 Nov 2020 13:57:55 -0800
Subject: Help channels: remove how_to_get_help from excluded channels

The channel as moved out of this category. Delete the constant too
since it isn't used anywhere else. Keep the excluded channels a tuple
to conveniently support excluding multiple channels in the future.
---
 bot/constants.py                   | 1 -
 bot/exts/help_channels/_channel.py | 2 +-
 config-default.yml                 | 1 -
 3 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/bot/constants.py b/bot/constants.py
index 6bb6aacd2..fb280b042 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -406,7 +406,6 @@ class Channels(metaclass=YAMLGetter):
     dm_log: int
     esoteric: int
     helpers: int
-    how_to_get_help: int
     incidents: int
     incidents_archive: int
     mailing_lists: int
diff --git a/bot/exts/help_channels/_channel.py b/bot/exts/help_channels/_channel.py
index d6d6f1245..e717d7af8 100644
--- a/bot/exts/help_channels/_channel.py
+++ b/bot/exts/help_channels/_channel.py
@@ -10,7 +10,7 @@ from bot.exts.help_channels import _caches, _message
 log = logging.getLogger(__name__)
 
 MAX_CHANNELS_PER_CATEGORY = 50
-EXCLUDED_CHANNELS = (constants.Channels.how_to_get_help, constants.Channels.cooldown)
+EXCLUDED_CHANNELS = (constants.Channels.cooldown,)
 
 
 def get_category_channels(category: discord.CategoryChannel) -> t.Iterable[discord.TextChannel]:
diff --git a/config-default.yml b/config-default.yml
index 60eb437af..82023aae1 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -155,7 +155,6 @@ guild:
         python_discussion:  &PY_DISCUSSION  267624335836053506
 
         # Python Help: Available
-        how_to_get_help:    704250143020417084
         cooldown:           720603994149486673
 
         # Logs
-- 
cgit v1.2.3


From d9f87cc867a93d5f2d14d16eaac86ccb5adef447 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 26 Nov 2020 14:07:29 -0800
Subject: Help channels: don't check if task is done before awaiting

Awaiting a done task is effectively a no-op, so it's redundant to check
if the task is done before awaiting it.

Furthermore, a task is also considered done if it was cancelled or an
exception was raised. Therefore, avoiding awaiting in such cases doesn't
allow the errors to be propagated and incorrectly allows the awaiter to
keep executing.
---
 bot/exts/help_channels/_cog.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 638d00e4a..e22d4663e 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -426,9 +426,8 @@ class HelpChannels(commands.Cog):
         if not is_available or _channel.is_excluded_channel(channel):
             return  # Ignore messages outside the Available category or in excluded channels.
 
-        if not self.init_task.done():
-            log.trace("Waiting for the cog to be ready before processing messages.")
-            await self.init_task
+        log.trace("Waiting for the cog to be ready before processing messages.")
+        await self.init_task
 
         log.trace("Acquiring lock to prevent a channel from being processed twice...")
         async with self.on_message_lock:
@@ -478,9 +477,8 @@ class HelpChannels(commands.Cog):
         if not await _message.is_empty(msg.channel):
             return
 
-        if not self.init_task.done():
-            log.trace("Waiting for the cog to be ready before processing deleted messages.")
-            await self.init_task
+        log.trace("Waiting for the cog to be ready before processing deleted messages.")
+        await self.init_task
 
         log.info(f"Claimant of #{msg.channel} ({msg.author}) deleted message, channel is empty now. Rescheduling task.")
 
-- 
cgit v1.2.3


From e5b073c5ee9c7c887a193ec05d813d259eca58ee Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 26 Nov 2020 14:11:40 -0800
Subject: Help channels: document the return value of notify()

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

diff --git a/bot/exts/help_channels/_message.py b/bot/exts/help_channels/_message.py
index 8b058d5aa..2bbd4bdd6 100644
--- a/bot/exts/help_channels/_message.py
+++ b/bot/exts/help_channels/_message.py
@@ -96,6 +96,9 @@ async def notify(channel: discord.TextChannel, last_notification: t.Optional[dat
     """
     Send a message in `channel` notifying about a lack of available help channels.
 
+    If a notification was sent, return the `datetime` at which the message was sent. Otherwise,
+    return None.
+
     Configuration:
 
     * `HelpChannels.notify` - toggle notifications
-- 
cgit v1.2.3


From bff4cd34bbacc7229a3fa2cf5421276c433c8b65 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 26 Nov 2020 14:12:57 -0800
Subject: Update help channels directory for code owners

---
 .github/CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 5f5386222..843f86b71 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -8,7 +8,7 @@
 bot/exts/info/codeblock/**              @MarkKoz
 bot/exts/utils/extensions.py            @MarkKoz
 bot/exts/utils/snekbox.py               @MarkKoz
-bot/exts/help_channels.py               @MarkKoz
+bot/exts/help_channels/**               @MarkKoz
 
 # Utils
 bot/utils/extensions.py                 @MarkKoz
-- 
cgit v1.2.3


From a8891d43484d602d49800ad5a8a39505758a86ba Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Thu, 26 Nov 2020 22:16:31 +0000
Subject: Update CODEOWNERS

---
 .github/CODEOWNERS | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 5f5386222..0d7572e38 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,5 +1,5 @@
-# Request Joe and Dennis for any PR
-* @jb3 @Den4200
+# Request Dennis for any PR
+* @Den4200
 
 # Extensions
 **/bot/exts/backend/sync/**             @MarkKoz
@@ -24,3 +24,7 @@ tests/bot/exts/test_cogs.py             @MarkKoz
 .github/workflows/**                    @MarkKoz
 Dockerfile                              @MarkKoz
 docker-compose.yml                      @MarkKoz
+
+# Statistics
+bot/async_stats.py @jb3
+bot/exts/info/stats.py @jb3
-- 
cgit v1.2.3


From 63abf5cd0dfe831caaf0a854387fca11d0e13ae2 Mon Sep 17 00:00:00 2001
From: Mushinako <8977737+Mushinako@users.noreply.github.com>
Date: Thu, 26 Nov 2020 18:50:20 -0800
Subject: Add `build-tools` tag

Infoblock tag helping people install Microsoft Visual C++ Build Tools on Windows
---
 bot/resources/tags/build-tools.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 bot/resources/tags/build-tools.md

diff --git a/bot/resources/tags/build-tools.md b/bot/resources/tags/build-tools.md
new file mode 100644
index 000000000..23ce15e8a
--- /dev/null
+++ b/bot/resources/tags/build-tools.md
@@ -0,0 +1,15 @@
+**Microsoft Visual C++ Build Tools**
+
+When you install a library through `pip` on Windows, sometimes you may encounter this error:
+
+```
+error: Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools": https://visualstudio.microsoft.com/visual-cpp-build-tools/
+```
+
+This means the library you're installing has code written in other languages and needs additional tools to install. To install these tools, follow the following steps: (Requires 6GB+ disk space)
+
+1. Open [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
+2. Click **`Download Build Tools >`**. A file named `vs_BuildTools` or `vs_BuildTools.exe` should start downloading. If no downloads start after a few seconds, click **`click here to retry`**.
+3. Run the downloaded file. If a **`User Account Control`** dialog pops up, click **`Yes`**. Click **`Continue`** to proceed.
+4. Choose **C++ build tools** and press **`Install`**. You may need a reboot after the installation.
+5. Try installing the library via `pip` again.
-- 
cgit v1.2.3


From c5b7f7b500aeefbb65ff943f8e3a918c9ed75193 Mon Sep 17 00:00:00 2001
From: Mushinako <8977737+Mushinako@users.noreply.github.com>
Date: Thu, 26 Nov 2020 23:06:51 -0800
Subject: Bold numbering

---
 bot/resources/tags/build-tools.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/bot/resources/tags/build-tools.md b/bot/resources/tags/build-tools.md
index 23ce15e8a..db88098e0 100644
--- a/bot/resources/tags/build-tools.md
+++ b/bot/resources/tags/build-tools.md
@@ -8,8 +8,8 @@ error: Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft
 
 This means the library you're installing has code written in other languages and needs additional tools to install. To install these tools, follow the following steps: (Requires 6GB+ disk space)
 
-1. Open [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
-2. Click **`Download Build Tools >`**. A file named `vs_BuildTools` or `vs_BuildTools.exe` should start downloading. If no downloads start after a few seconds, click **`click here to retry`**.
-3. Run the downloaded file. If a **`User Account Control`** dialog pops up, click **`Yes`**. Click **`Continue`** to proceed.
-4. Choose **C++ build tools** and press **`Install`**. You may need a reboot after the installation.
-5. Try installing the library via `pip` again.
+**1.** Open [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
+**2.** Click **`Download Build Tools >`**. A file named `vs_BuildTools` or `vs_BuildTools.exe` should start downloading. If no downloads start after a few seconds, click **`click here to retry`**.
+**3.** Run the downloaded file. If a **`User Account Control`** dialog pops up, click **`Yes`**. Click **`Continue`** to proceed.
+**4.** Choose **C++ build tools** and press **`Install`**. You may need a reboot after the installation.
+**5.** Try installing the library via `pip` again.
-- 
cgit v1.2.3


From c5d885da1e5094c9ee55f2d37dcc01db4ce08e9c Mon Sep 17 00:00:00 2001
From: Mushinako <8977737+Mushinako@users.noreply.github.com>
Date: Thu, 26 Nov 2020 23:08:48 -0800
Subject: Remove UAC prompt info

Assuming Windows users are familiar with UAC
---
 bot/resources/tags/build-tools.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/resources/tags/build-tools.md b/bot/resources/tags/build-tools.md
index db88098e0..7c702e296 100644
--- a/bot/resources/tags/build-tools.md
+++ b/bot/resources/tags/build-tools.md
@@ -10,6 +10,6 @@ This means the library you're installing has code written in other languages and
 
 **1.** Open [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
 **2.** Click **`Download Build Tools >`**. A file named `vs_BuildTools` or `vs_BuildTools.exe` should start downloading. If no downloads start after a few seconds, click **`click here to retry`**.
-**3.** Run the downloaded file. If a **`User Account Control`** dialog pops up, click **`Yes`**. Click **`Continue`** to proceed.
+**3.** Run the downloaded file. Click **`Continue`** to proceed.
 **4.** Choose **C++ build tools** and press **`Install`**. You may need a reboot after the installation.
 **5.** Try installing the library via `pip` again.
-- 
cgit v1.2.3


From 1e1d57f6294eb7c3a8d9a0c76c77eb10c43b3ebe Mon Sep 17 00:00:00 2001
From: Thomas Petersson <thomas@petersson.priv.no>
Date: Fri, 27 Nov 2020 16:00:19 +0100
Subject: fix(bot): PR reivew of bot.py

---
 bot/bot.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/bot/bot.py b/bot/bot.py
index b097513f1..bcce4a118 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -53,20 +53,22 @@ class Bot(commands.Bot):
 
     def _connect_statsd(self, statsd_url: str, retry_after: int = 2, attempt: int = 1) -> None:
         """Callback used to retry a connection to statsd if it should fail."""
-        if self._statsd_timerhandle and not self._statsd_timerhandle.cancelled:
-            self._statsd_timerhandle.cancel()
-
-        if attempt >= 5:
-            log.error("Reached 5 attempts trying to reconnect AsyncStatsClient. Aborting")
+        if attempt >= 8:
+            log.error("Reached 8 attempts trying to reconnect AsyncStatsClient. Aborting")
             return
 
         try:
             self.stats = AsyncStatsClient(self.loop, statsd_url, 8125, prefix="bot")
         except socket.gaierror:
             log.warning(f"Statsd client failed to connect (Attempt(s): {attempt})")
-            # Use a fallback strategy for retrying, up to 5 times.
+            # Use a fallback strategy for retrying, up to 8 times.
             self._statsd_timerhandle = self.loop.call_later(
-                retry_after, self._connect_statsd, statsd_url, retry_after * 5, attempt + 1)
+                retry_after,
+                self._connect_statsd,
+                statsd_url,
+                retry_after * 2,
+                attempt + 1
+            )
 
     async def cache_filter_list_data(self) -> None:
         """Cache all the data in the FilterList on the site."""
@@ -172,7 +174,7 @@ class Bot(commands.Bot):
         if self.redis_session:
             await self.redis_session.close()
 
-        if self._statsd_timerhandle and not self._statsd_timerhandle.cancelled:
+        if self._statsd_timerhandle:
             self._statsd_timerhandle.cancel()
 
     def insert_item_into_filter_list_cache(self, item: Dict[str, str]) -> None:
-- 
cgit v1.2.3


From a7dd1c56dad3e2aa3c1304b6f9cc5bd63150ad91 Mon Sep 17 00:00:00 2001
From: Matteo Bertucci <matteobertucci2004@gmail.com>
Date: Fri, 27 Nov 2020 18:18:22 +0100
Subject: Add @Akarys42 to the codeowners

---
 .github/CODEOWNERS | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 86df4db8d..272fb2ffe 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -7,24 +7,31 @@
 **/bot/exts/moderation/*silence.py      @MarkKoz
 bot/exts/info/codeblock/**              @MarkKoz
 bot/exts/utils/extensions.py            @MarkKoz
-bot/exts/utils/snekbox.py               @MarkKoz
-bot/exts/help_channels/**               @MarkKoz
+bot/exts/utils/snekbox.py               @MarkKoz @Akarys42
+bot/exts/help_channels/**               @MarkKoz @Akarys42
+bot/exts/moderation/**                  @Akarys42
+bot/exts/info/**                        @Akarys42
 
 # Utils
 bot/utils/extensions.py                 @MarkKoz
 bot/utils/function.py                   @MarkKoz
 bot/utils/lock.py                       @MarkKoz
+bot/utils/regex.py                      @Akarys42
 bot/utils/scheduling.py                 @MarkKoz
 
 # Tests
 tests/_autospec.py                      @MarkKoz
 tests/bot/exts/test_cogs.py             @MarkKoz
+tests/**                                @Akarys42
 
 # CI & Docker
-.github/workflows/**                    @MarkKoz
-Dockerfile                              @MarkKoz
-docker-compose.yml                      @MarkKoz
+.github/workflows/**                    @MarkKoz @Akarys42
+Dockerfile                              @MarkKoz @Akarys42
+docker-compose.yml                      @MarkKoz @Akarys42
+
+# Tools
+Pipfile*                                @Akarys42
 
 # Statistics
-bot/async_stats.py @jb3
-bot/exts/info/stats.py @jb3
+bot/async_stats.py                      @jb3
+bot/exts/info/stats.py                  @jb3
-- 
cgit v1.2.3


From 1cde79faa2675638ede0435fbf4cd2911b8a76ba Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Fri, 27 Nov 2020 23:39:13 +0100
Subject: Add myself to CODEOWNERS for CI files

---
 .github/CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 272fb2ffe..495a6e9e2 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -25,7 +25,7 @@ tests/bot/exts/test_cogs.py             @MarkKoz
 tests/**                                @Akarys42
 
 # CI & Docker
-.github/workflows/**                    @MarkKoz @Akarys42
+.github/workflows/**                    @MarkKoz @Akarys42 @SebastiaanZ
 Dockerfile                              @MarkKoz @Akarys42
 docker-compose.yml                      @MarkKoz @Akarys42
 
-- 
cgit v1.2.3


From cb59440d7c7bf5780545a1a31beadaaadd5700f9 Mon Sep 17 00:00:00 2001
From: mbaruh <mbaruh@hotmail.com>
Date: Sat, 28 Nov 2020 01:37:27 +0200
Subject: Remove unnecessary shadow infractions

---
 bot/exts/moderation/infraction/infractions.py | 30 ---------------------------
 1 file changed, 30 deletions(-)

diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index 6056df1d2..8c3451c7a 100644
--- a/bot/exts/moderation/infraction/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -180,11 +180,6 @@ class Infractions(InfractionScheduler, commands.Cog):
 
         await self.apply_infraction(ctx, infraction, user)
 
-    @command(hidden=True, aliases=['shadowkick', 'skick'])
-    async def shadow_kick(self, ctx: Context, user: Member, *, reason: t.Optional[str] = None) -> None:
-        """Kick a user for the given reason without notifying the user."""
-        await self.apply_kick(ctx, user, reason, hidden=True)
-
     @command(hidden=True, aliases=['shadowban', 'sban'])
     async def shadow_ban(self, ctx: Context, user: FetchedMember, *, reason: t.Optional[str] = None) -> None:
         """Permanently ban a user for the given reason without notifying the user."""
@@ -193,31 +188,6 @@ class Infractions(InfractionScheduler, commands.Cog):
     # endregion
     # region: Temporary shadow infractions
 
-    @command(hidden=True, aliases=["shadowtempmute, stempmute", "shadowmute", "smute"])
-    async def shadow_tempmute(
-        self, ctx: Context,
-        user: Member,
-        duration: Expiry,
-        *,
-        reason: t.Optional[str] = None
-    ) -> None:
-        """
-        Temporarily mute a user for the given reason and duration without notifying the user.
-
-        A unit of time should be appended to the duration.
-        Units (∗case-sensitive):
-        \u2003`y` - years
-        \u2003`m` - months∗
-        \u2003`w` - weeks
-        \u2003`d` - days
-        \u2003`h` - hours
-        \u2003`M` - minutes∗
-        \u2003`s` - seconds
-
-        Alternatively, an ISO 8601 timestamp can be provided for the duration.
-        """
-        await self.apply_mute(ctx, user, reason, expires_at=duration, hidden=True)
-
     @command(hidden=True, aliases=["shadowtempban, stempban"])
     async def shadow_tempban(
         self,
-- 
cgit v1.2.3


From f1bb099b90acc870995b5e1a1f02aa20c44e9b6d Mon Sep 17 00:00:00 2001
From: mbaruh <mbaruh@hotmail.com>
Date: Sat, 28 Nov 2020 15:38:08 +0200
Subject: Add default mute duration

---
 bot/exts/moderation/infraction/infractions.py | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index 8c3451c7a..18e937e87 100644
--- a/bot/exts/moderation/infraction/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -10,7 +10,7 @@ from discord.ext.commands import Context, command
 from bot import constants
 from bot.bot import Bot
 from bot.constants import Event
-from bot.converters import Expiry, FetchedMember
+from bot.converters import Duration, Expiry, FetchedMember
 from bot.decorators import respect_role_hierarchy
 from bot.exts.moderation.infraction import _utils
 from bot.exts.moderation.infraction._scheduler import InfractionScheduler
@@ -98,7 +98,13 @@ class Infractions(InfractionScheduler, commands.Cog):
     # region: Temporary infractions
 
     @command(aliases=["mute"])
-    async def tempmute(self, ctx: Context, user: Member, duration: Expiry, *, reason: t.Optional[str] = None) -> None:
+    async def tempmute(
+        self, ctx: Context,
+        user: Member,
+        duration: t.Optional[Expiry] = None,
+        *,
+        reason: t.Optional[str] = None
+    ) -> None:
         """
         Temporarily mute a user for the given reason and duration.
 
@@ -113,7 +119,11 @@ class Infractions(InfractionScheduler, commands.Cog):
         \u2003`s` - seconds
 
         Alternatively, an ISO 8601 timestamp can be provided for the duration.
+
+        If no duration is given, a one hour duration is used by default.
         """
+        if duration is None:
+            duration = await Duration().convert(ctx, "1h")
         await self.apply_mute(ctx, user, reason, expires_at=duration)
 
     @command()
-- 
cgit v1.2.3


From 7b3d8ed6e655b787c2538541ca35301f2fadb508 Mon Sep 17 00:00:00 2001
From: mbaruh <mbaruh@hotmail.com>
Date: Sat, 28 Nov 2020 15:47:50 +0200
Subject: Added infraction edit aliases

---
 bot/exts/moderation/infraction/management.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 394f63da3..4cd7d15bf 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -40,12 +40,12 @@ class ModManagement(commands.Cog):
 
     # region: Edit infraction commands
 
-    @commands.group(name='infraction', aliases=('infr', 'infractions', 'inf'), invoke_without_command=True)
+    @commands.group(name='infraction', aliases=('infr', 'infractions', 'inf', 'i'), invoke_without_command=True)
     async def infraction_group(self, ctx: Context) -> None:
         """Infraction manipulation commands."""
         await ctx.send_help(ctx.command)
 
-    @infraction_group.command(name='edit')
+    @infraction_group.command(name='edit', aliases=('e',))
     async def infraction_edit(
         self,
         ctx: Context,
-- 
cgit v1.2.3


From 67fbb71f7954f4edc2f43b8f1069e3c366dcca4d Mon Sep 17 00:00:00 2001
From: Boris Muratov <8bee278@gmail.com>
Date: Sat, 28 Nov 2020 16:58:58 +0200
Subject: Add myself to CODEOWNERS

---
 .github/CODEOWNERS | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 495a6e9e2..642676078 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -9,8 +9,9 @@ bot/exts/info/codeblock/**              @MarkKoz
 bot/exts/utils/extensions.py            @MarkKoz
 bot/exts/utils/snekbox.py               @MarkKoz @Akarys42
 bot/exts/help_channels/**               @MarkKoz @Akarys42
-bot/exts/moderation/**                  @Akarys42
-bot/exts/info/**                        @Akarys42
+bot/exts/moderation/**                  @Akarys42 @mbaruh
+bot/exts/info/**                        @Akarys42 @mbaruh
+bot/exts/filters/**                     @mbaruh
 
 # Utils
 bot/utils/extensions.py                 @MarkKoz
-- 
cgit v1.2.3


From fde6dd9a37cf5f5a98eed7ffcb05f43dca6886a3 Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
Date: Sat, 28 Nov 2020 21:18:13 +0300
Subject: Removes Non-Existent Channel

Signed-off-by: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
---
 bot/constants.py   | 1 -
 config-default.yml | 1 -
 2 files changed, 2 deletions(-)

diff --git a/bot/constants.py b/bot/constants.py
index ecbf5f98e..5b3779eb6 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -436,7 +436,6 @@ class Channels(metaclass=YAMLGetter):
     code_help_chat: int
     code_help_chat_2: int
     voice_chat: int
-    admins_voice_chat: int
     staff_voice_chat: int
     voice_gate: int
     voice_log: int
diff --git a/config-default.yml b/config-default.yml
index 8ba3b7175..563244819 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -200,7 +200,6 @@ guild:
         code_help_chat:                     755154969761677312
         code_help_chat_2:                   766330079135268884
         voice_chat:                         412357430186344448
-        admins_voice_chat:                  000000000000000000 # FIXME
         staff_voice_chat:                   541638762007101470
 
         # Voice Channels
-- 
cgit v1.2.3


From cd8b4b91fbfe69b9370fec1a89dc82688f7d317b Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
Date: Sat, 28 Nov 2020 21:19:34 +0300
Subject: Renames Code Help Channel

Renames code_help_channel to be more inline with channel 2.

Signed-off-by: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
---
 bot/constants.py   | 4 ++--
 config-default.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/bot/constants.py b/bot/constants.py
index 5b3779eb6..42b3d7008 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -396,7 +396,7 @@ class Channels(metaclass=YAMLGetter):
     big_brother_logs: int
     bot_commands: int
     change_log: int
-    code_help_voice: int
+    code_help_voice_1: int
     code_help_voice_2: int
     general_voice: int
     admins_voice: int
@@ -433,7 +433,7 @@ class Channels(metaclass=YAMLGetter):
     user_event_announcements: int
     user_log: int
     verification: int
-    code_help_chat: int
+    code_help_chat_1: int
     code_help_chat_2: int
     voice_chat: int
     staff_voice_chat: int
diff --git a/config-default.yml b/config-default.yml
index 563244819..f18d08126 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -197,13 +197,13 @@ guild:
         admin_announcements:    &ADMIN_ANNOUNCEMENTS    749736155569848370
 
         # Voice Chat
-        code_help_chat:                     755154969761677312
+        code_help_chat_1:                     755154969761677312
         code_help_chat_2:                   766330079135268884
         voice_chat:                         412357430186344448
         staff_voice_chat:                   541638762007101470
 
         # Voice Channels
-        code_help_voice:                    751592231726481530
+        code_help_voice_1:                    751592231726481530
         code_help_voice_2:                  764232549840846858
         general_voice:                      751591688538947646
         admins_voice:       &ADMINS_VOICE   500734494840717332
-- 
cgit v1.2.3


From d190056ac6fa39ac54b4eafc566c2f05fc0b6f8e Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
Date: Sat, 28 Nov 2020 21:48:51 +0300
Subject: Fixes Alignment

Signed-off-by: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
---
 config-default.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/config-default.yml b/config-default.yml
index f18d08126..df3d971ff 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -197,13 +197,13 @@ guild:
         admin_announcements:    &ADMIN_ANNOUNCEMENTS    749736155569848370
 
         # Voice Chat
-        code_help_chat_1:                     755154969761677312
+        code_help_chat_1:                   755154969761677312
         code_help_chat_2:                   766330079135268884
         voice_chat:                         412357430186344448
         staff_voice_chat:                   541638762007101470
 
         # Voice Channels
-        code_help_voice_1:                    751592231726481530
+        code_help_voice_1:                  751592231726481530
         code_help_voice_2:                  764232549840846858
         general_voice:                      751591688538947646
         admins_voice:       &ADMINS_VOICE   500734494840717332
-- 
cgit v1.2.3


From 54540bf9dcf88f7d3e2e0f389a2127456d6c877f Mon Sep 17 00:00:00 2001
From: Mushinako <8977737+Mushinako@users.noreply.github.com>
Date: Sat, 28 Nov 2020 11:38:32 -0800
Subject: Rename `build-tools` to `microsoft-build-tools`

---
 bot/resources/tags/build-tools.md           | 15 ---------------
 bot/resources/tags/microsoft-build-tools.md | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 15 deletions(-)
 delete mode 100644 bot/resources/tags/build-tools.md
 create mode 100644 bot/resources/tags/microsoft-build-tools.md

diff --git a/bot/resources/tags/build-tools.md b/bot/resources/tags/build-tools.md
deleted file mode 100644
index 7c702e296..000000000
--- a/bot/resources/tags/build-tools.md
+++ /dev/null
@@ -1,15 +0,0 @@
-**Microsoft Visual C++ Build Tools**
-
-When you install a library through `pip` on Windows, sometimes you may encounter this error:
-
-```
-error: Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools": https://visualstudio.microsoft.com/visual-cpp-build-tools/
-```
-
-This means the library you're installing has code written in other languages and needs additional tools to install. To install these tools, follow the following steps: (Requires 6GB+ disk space)
-
-**1.** Open [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
-**2.** Click **`Download Build Tools >`**. A file named `vs_BuildTools` or `vs_BuildTools.exe` should start downloading. If no downloads start after a few seconds, click **`click here to retry`**.
-**3.** Run the downloaded file. Click **`Continue`** to proceed.
-**4.** Choose **C++ build tools** and press **`Install`**. You may need a reboot after the installation.
-**5.** Try installing the library via `pip` again.
diff --git a/bot/resources/tags/microsoft-build-tools.md b/bot/resources/tags/microsoft-build-tools.md
new file mode 100644
index 000000000..7c702e296
--- /dev/null
+++ b/bot/resources/tags/microsoft-build-tools.md
@@ -0,0 +1,15 @@
+**Microsoft Visual C++ Build Tools**
+
+When you install a library through `pip` on Windows, sometimes you may encounter this error:
+
+```
+error: Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools": https://visualstudio.microsoft.com/visual-cpp-build-tools/
+```
+
+This means the library you're installing has code written in other languages and needs additional tools to install. To install these tools, follow the following steps: (Requires 6GB+ disk space)
+
+**1.** Open [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
+**2.** Click **`Download Build Tools >`**. A file named `vs_BuildTools` or `vs_BuildTools.exe` should start downloading. If no downloads start after a few seconds, click **`click here to retry`**.
+**3.** Run the downloaded file. Click **`Continue`** to proceed.
+**4.** Choose **C++ build tools** and press **`Install`**. You may need a reboot after the installation.
+**5.** Try installing the library via `pip` again.
-- 
cgit v1.2.3


From 114e3058ca18cf45a55d7dcdf7d509de44d7ad1a Mon Sep 17 00:00:00 2001
From: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
Date: Sat, 28 Nov 2020 23:52:30 +0300
Subject: Alphabetizes Channel Ordering

Signed-off-by: Hassan Abouelela <47495861+HassanAbouelela@users.noreply.github.com>
---
 bot/constants.py   | 12 ++++++------
 config-default.yml | 14 +++++++-------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/bot/constants.py b/bot/constants.py
index 42b3d7008..a33939537 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -391,16 +391,16 @@ class Channels(metaclass=YAMLGetter):
     admin_announcements: int
     admin_spam: int
     admins: int
+    admins_voice: int
     announcements: int
     attachment_log: int
     big_brother_logs: int
     bot_commands: int
     change_log: int
+    code_help_chat_1: int
+    code_help_chat_2: int
     code_help_voice_1: int
     code_help_voice_2: int
-    general_voice: int
-    admins_voice: int
-    staff_voice: int
     cooldown: int
     defcon: int
     dev_contrib: int
@@ -408,6 +408,7 @@ class Channels(metaclass=YAMLGetter):
     dev_log: int
     dm_log: int
     esoteric: int
+    general_voice: int
     helpers: int
     how_to_get_help: int
     incidents: int
@@ -429,14 +430,13 @@ class Channels(metaclass=YAMLGetter):
     python_news: int
     reddit: int
     staff_announcements: int
+    staff_voice: int
+    staff_voice_chat: int
     talent_pool: int
     user_event_announcements: int
     user_log: int
     verification: int
-    code_help_chat_1: int
-    code_help_chat_2: int
     voice_chat: int
-    staff_voice_chat: int
     voice_gate: int
     voice_log: int
 
diff --git a/config-default.yml b/config-default.yml
index df3d971ff..9dc1ac18e 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -196,19 +196,19 @@ guild:
         mod_announcements:      &MOD_ANNOUNCEMENTS      372115205867700225
         admin_announcements:    &ADMIN_ANNOUNCEMENTS    749736155569848370
 
-        # Voice Chat
-        code_help_chat_1:                   755154969761677312
-        code_help_chat_2:                   766330079135268884
-        voice_chat:                         412357430186344448
-        staff_voice_chat:                   541638762007101470
-
         # Voice Channels
+        admins_voice:       &ADMINS_VOICE   500734494840717332
         code_help_voice_1:                  751592231726481530
         code_help_voice_2:                  764232549840846858
         general_voice:                      751591688538947646
-        admins_voice:       &ADMINS_VOICE   500734494840717332
         staff_voice:        &STAFF_VOICE    412375055910043655
 
+        # Voice Chat
+        code_help_chat_1:                   755154969761677312
+        code_help_chat_2:                   766330079135268884
+        staff_voice_chat:                   541638762007101470
+        voice_chat:                         412357430186344448
+
         # Watch
         big_brother_logs:   &BB_LOGS        468507907357409333
         talent_pool:        &TALENT_POOL    534321732593647616
-- 
cgit v1.2.3


From 65366ead766fa6533fe6c59310a39ca3ee3a06b2 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Mon, 30 Nov 2020 00:47:34 +0800
Subject: Fix unawaited coroutine in Infraction

---
 bot/converters.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/converters.py b/bot/converters.py
index f350e863e..d0a9731d6 100644
--- a/bot/converters.py
+++ b/bot/converters.py
@@ -575,7 +575,7 @@ class Infraction(Converter):
                 return infractions[0]
 
         else:
-            return ctx.bot.api_client.get(f"bot/infractions/{arg}")
+            return await ctx.bot.api_client.get(f"bot/infractions/{arg}")
 
 
 Expiry = t.Union[Duration, ISODateTime]
-- 
cgit v1.2.3


From db2136cd5bd1b86b05f249177e7a68a731404d16 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Mon, 30 Nov 2020 00:49:47 +0800
Subject: Refactor flow for automatically adding punctuation

---
 bot/exts/moderation/infraction/management.py | 11 +++++------
 bot/utils/regex.py                           |  2 --
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index bb7a6737a..10bca5fc5 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -16,7 +16,6 @@ from bot.exts.moderation.modlog import ModLog
 from bot.pagination import LinePaginator
 from bot.utils import messages, time
 from bot.utils.channel import is_mod_channel
-from bot.utils.regex import END_PUNCTUATION_RE
 
 log = logging.getLogger(__name__)
 
@@ -77,13 +76,13 @@ class ModManagement(commands.Cog):
         If a previous infraction reason does not end with an ending punctuation mark, this automatically
         adds a period before the amended reason.
         """
-        add_period = not END_PUNCTUATION_RE.match(infraction["reason"])
+        old_reason = infraction["reason"]
 
-        new_reason = "".join((
-            infraction["reason"], ". " if add_period else " ", reason,
-        ))
+        if old_reason is not None:
+            add_period = not old_reason.endswith((".", "!", "?"))
+            reason = old_reason + (". " if add_period else " ") + reason
 
-        await self.infraction_edit(ctx, infraction, duration, reason=new_reason)
+        await self.infraction_edit(ctx, infraction, duration, reason=reason)
 
     @infraction_group.command(name='edit')
     async def infraction_edit(
diff --git a/bot/utils/regex.py b/bot/utils/regex.py
index cfce52bb3..0d2068f90 100644
--- a/bot/utils/regex.py
+++ b/bot/utils/regex.py
@@ -10,5 +10,3 @@ INVITE_RE = re.compile(
     r"([a-zA-Z0-9\-]+)",                              # the invite code itself
     flags=re.IGNORECASE
 )
-
-END_PUNCTUATION_RE = re.compile("^.+?[.?!]$")
-- 
cgit v1.2.3


From 6ac6786c480ec9919009acca4906a52234f42285 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Sun, 29 Nov 2020 13:04:38 -0500
Subject: `!close` removes role from claimant only, new method
 `unclaim_channel`.

Previously `!close` would remove the cooldown role from the person who issued the command, whereas now `unclaim_channel` handles removing the role from the claimant if it was their only channel open.
---
 bot/exts/help_channels/_cog.py | 42 +++++++++++++++++++++++++++++-------------
 1 file changed, 29 insertions(+), 13 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index e22d4663e..86eb91b02 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -145,22 +145,17 @@ class HelpChannels(commands.Cog):
         Make the current in-use help channel dormant.
 
         Make the channel dormant if the user passes the `dormant_check`,
-        delete the message that invoked this,
-        and reset the send permissions cooldown for the user who started the session.
+        delete the message that invoked this.
         """
         log.trace("close command invoked; checking if the channel is in-use.")
-        if ctx.channel.category == self.in_use_category:
-            if await self.dormant_check(ctx):
-                await _cooldown.remove_cooldown_role(ctx.author)
 
-                # Ignore missing task when cooldown has passed but the channel still isn't dormant.
-                if ctx.author.id in self.scheduler:
-                    self.scheduler.cancel(ctx.author.id)
-
-                await self.move_to_dormant(ctx.channel, "command")
-                self.scheduler.cancel(ctx.channel.id)
-        else:
+        if ctx.channel.category != self.in_use_category:
             log.debug(f"{ctx.author} invoked command 'dormant' outside an in-use help channel")
+            return
+
+        if await self.dormant_check(ctx):
+            await self.move_to_dormant(ctx.channel, "command")
+            self.scheduler.cancel(ctx.channel.id)
 
     async def get_available_candidate(self) -> discord.TextChannel:
         """
@@ -368,12 +363,13 @@ class HelpChannels(commands.Cog):
         """
         log.info(f"Moving #{channel} ({channel.id}) to the Dormant category.")
 
-        await _caches.claimants.delete(channel.id)
         await self.move_to_bottom_position(
             channel=channel,
             category_id=constants.Categories.help_dormant,
         )
 
+        await self.unclaim_channel(channel)
+
         self.bot.stats.incr(f"help.dormant_calls.{caller}")
 
         in_use_time = await _channel.get_in_use_time(channel.id)
@@ -397,6 +393,26 @@ class HelpChannels(commands.Cog):
         self.channel_queue.put_nowait(channel)
         self.report_stats()
 
+    async def unclaim_channel(self, channel: discord.TextChannel) -> None:
+        """
+        Remove the claimant from the claimant cache and remove the cooldown role
+        if it was their last open help channel.
+        """
+        claimant_id = await _caches.claimants.pop(channel.id)
+
+        # Ignore missing task when cooldown has passed but the channel still isn't dormant.
+        if claimant_id in self.scheduler:
+            self.scheduler.cancel(claimant_id)
+
+        claimant = self.bot.get_guild(constants.Guild.id).get_member(claimant_id)
+        if claimant is None:
+            log.info(f"{claimant_id} left the guild during their help session; the cooldown role won't be removed")
+            return
+
+        # Remove the cooldown role if the claimant has no other channels left
+        if not any(claimant.id == user_id for _, user_id in await _caches.claimants.items()):
+            await _cooldown.remove_cooldown_role(claimant)
+
     async def move_to_in_use(self, channel: discord.TextChannel) -> None:
         """Make a channel in-use and schedule it to be made dormant."""
         log.info(f"Moving #{channel} ({channel.id}) to the In Use category.")
-- 
cgit v1.2.3


From 15593de0a1a503a39aa29031061bc17ac26e4230 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Sun, 29 Nov 2020 14:15:19 -0500
Subject: Corrected `unclaim_channel` docstring to comply with style guide

---
 bot/exts/help_channels/_cog.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 86eb91b02..983c5d183 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -395,8 +395,10 @@ class HelpChannels(commands.Cog):
 
     async def unclaim_channel(self, channel: discord.TextChannel) -> None:
         """
-        Remove the claimant from the claimant cache and remove the cooldown role
-        if it was their last open help channel.
+        Mark the channel as unclaimed and remove the cooldown role from the claimant if needed.
+
+        The role is only removed if they have no claimed channels left once the current one is unclaimed.
+        This method also handles canceling the automatic removal of the cooldown role.
         """
         claimant_id = await _caches.claimants.pop(channel.id)
 
-- 
cgit v1.2.3


From ae976d56bd3ce89c1da69f42f59680f7b4763771 Mon Sep 17 00:00:00 2001
From: PureFunctor <purefunctor@gmail.com>
Date: Mon, 30 Nov 2020 17:52:22 +0800
Subject: Remove unused get_latest_infraction helper method

---
 bot/exts/moderation/infraction/management.py | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index 10bca5fc5..3b0719ed2 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -310,20 +310,6 @@ class ModManagement(commands.Cog):
 
         return lines.strip()
 
-    async def get_latest_infraction(self, actor: int) -> t.Optional[dict]:
-        """Obtains the latest infraction from an actor."""
-        params = {
-            "actor__id": actor,
-            "ordering": "-inserted_at"
-        }
-
-        infractions = await self.bot.api_client.get("bot/infractions", params=params)
-
-        if infractions:
-            return infractions[0]
-
-        return None
-
     # endregion
 
     # This cannot be static (must have a __func__ attribute).
-- 
cgit v1.2.3


From 9e4b78b40b407c2bb6d4666767d700b7993a54e5 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Fri, 4 Dec 2020 14:46:50 +0200
Subject: Create command for showing Discord snowflake creation time

---
 bot/exts/utils/utils.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/bot/exts/utils/utils.py b/bot/exts/utils/utils.py
index 6d8d98695..3f16bc10b 100644
--- a/bot/exts/utils/utils.py
+++ b/bot/exts/utils/utils.py
@@ -9,6 +9,7 @@ from typing import Dict, Optional, Tuple, Union
 
 from discord import Colour, Embed, utils
 from discord.ext.commands import BadArgument, Cog, Context, clean_content, command, has_any_role
+from discord.utils import snowflake_time
 
 from bot.bot import Bot
 from bot.constants import Channels, MODERATION_ROLES, STAFF_ROLES
@@ -16,6 +17,7 @@ from bot.decorators import in_whitelist
 from bot.pagination import LinePaginator
 from bot.utils import messages
 from bot.utils.cache import AsyncCache
+from bot.utils.time import time_since
 
 log = logging.getLogger(__name__)
 
@@ -166,6 +168,21 @@ class Utils(Cog):
         embed.description = best_match
         await ctx.send(embed=embed)
 
+    @command(aliases=("snf", "snfl"))
+    @in_whitelist(channels=(Channels.bot_commands,), roles=STAFF_ROLES)
+    async def snowflake(self, ctx: Context, snowflake: int) -> None:
+        """Get Discord snowflake creation time."""
+        created_at = snowflake_time(snowflake)
+        embed = Embed(
+            description=f"**Created at {created_at}** ({time_since(created_at, max_units=3)}).",
+            colour=Colour.blue()
+        )
+        embed.set_author(
+            name=f"Snowflake: {snowflake}",
+            icon_url="https://github.com/twitter/twemoji/blob/master/assets/72x72/2744.png?raw=true"
+        )
+        await ctx.send(embed=embed)
+
     @command(aliases=("poll",))
     @has_any_role(*MODERATION_ROLES)
     async def vote(self, ctx: Context, title: clean_content(fix_channel_mentions=True), *options: str) -> None:
-- 
cgit v1.2.3


From 72f869a81d882acf2eb3f1714d4f52d01384b0ae Mon Sep 17 00:00:00 2001
From: Matteo Bertucci <matteobertucci2004@gmail.com>
Date: Fri, 4 Dec 2020 14:46:58 +0100
Subject: Add the `s` alias to `infraction search`

---
 bot/exts/moderation/infraction/management.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/moderation/infraction/management.py b/bot/exts/moderation/infraction/management.py
index c58410f8c..b3783cd60 100644
--- a/bot/exts/moderation/infraction/management.py
+++ b/bot/exts/moderation/infraction/management.py
@@ -197,7 +197,7 @@ class ModManagement(commands.Cog):
     # endregion
     # region: Search infractions
 
-    @infraction_group.group(name="search", invoke_without_command=True)
+    @infraction_group.group(name="search", aliases=('s',), invoke_without_command=True)
     async def infraction_search_group(self, ctx: Context, query: t.Union[UserMention, Snowflake, str]) -> None:
         """Searches for infractions in the database."""
         if isinstance(query, int):
-- 
cgit v1.2.3


From f537768034a2c9791ca08a91c66b9f97aef8edca Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Sat, 5 Dec 2020 12:08:44 -0500
Subject: Bot relays the infraction reason in the DM.

Previously, the infraction DM from the bot gave a formulaic message about the nickname policy. It now gives a slightly different message along with the reason given by the mod. This means that the message the user gets and the infraction reason that gets recorded are now the same.
---
 bot/exts/moderation/infraction/superstarify.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index 96dfb562f..a4327fb95 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -111,7 +111,7 @@ class Superstarify(InfractionScheduler, Cog):
         member: Member,
         duration: Expiry,
         *,
-        reason: str = None,
+        reason: str = '',
     ) -> None:
         """
         Temporarily force a random superstar name (like Taylor Swift) to be the user's nickname.
@@ -128,15 +128,16 @@ class Superstarify(InfractionScheduler, Cog):
 
         Alternatively, an ISO 8601 timestamp can be provided for the duration.
 
-        An optional reason can be provided. If no reason is given, the original name will be shown
-        in a generated reason.
+        An optional reason can be provided, which would be added to a message stating their old nickname
+        and linking to the nickname policy.
         """
         if await _utils.get_active_infraction(ctx, member, "superstar"):
             return
 
         # Post the infraction to the API
         old_nick = member.display_name
-        reason = reason or f"old nick: {old_nick}"
+        reason = (f"Nickname '{old_nick}' does not comply with our [nickname policy]({NICKNAME_POLICY_URL}). "
+                  f"{reason}")
         infraction = await _utils.post_infraction(ctx, member, "superstar", reason, duration, active=True)
         id_ = infraction["id"]
 
@@ -152,7 +153,6 @@ class Superstarify(InfractionScheduler, Cog):
         old_nick = escape_markdown(old_nick)
         forced_nick = escape_markdown(forced_nick)
 
-        superstar_reason = f"Your nickname didn't comply with our [nickname policy]({NICKNAME_POLICY_URL})."
         nickname_info = textwrap.dedent(f"""
             Old nickname: `{old_nick}`
             New nickname: `{forced_nick}`
@@ -160,7 +160,7 @@ class Superstarify(InfractionScheduler, Cog):
 
         successful = await self.apply_infraction(
             ctx, infraction, member, action(),
-            user_reason=superstar_reason,
+            user_reason=reason,
             additional_info=nickname_info
         )
 
-- 
cgit v1.2.3


From d7e94f2570c69ae04c32bc4bad338b1be0c1da26 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Sat, 5 Dec 2020 12:09:54 -0500
Subject: Add `starify` and `unstarify` as command aliases.

---
 bot/exts/moderation/infraction/superstarify.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index a4327fb95..e7d1c4da8 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -104,7 +104,7 @@ class Superstarify(InfractionScheduler, Cog):
 
             await self.reapply_infraction(infraction, action)
 
-    @command(name="superstarify", aliases=("force_nick", "star"))
+    @command(name="superstarify", aliases=("force_nick", "star", "starify"))
     async def superstarify(
         self,
         ctx: Context,
@@ -182,7 +182,7 @@ class Superstarify(InfractionScheduler, Cog):
             )
             await ctx.send(embed=embed)
 
-    @command(name="unsuperstarify", aliases=("release_nick", "unstar"))
+    @command(name="unsuperstarify", aliases=("release_nick", "unstar", "unstarify"))
     async def unsuperstarify(self, ctx: Context, member: Member) -> None:
         """Remove the superstarify infraction and allow the user to change their nickname."""
         await self.pardon_infraction(ctx, "superstar", member)
-- 
cgit v1.2.3


From e08c39238dabe40abca7ae4eaed6873e26fd051f Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Sun, 6 Dec 2020 14:15:34 +0000
Subject: Create review-policy.yml

---
 .github/review-policy.yml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .github/review-policy.yml

diff --git a/.github/review-policy.yml b/.github/review-policy.yml
new file mode 100644
index 000000000..421b30f8a
--- /dev/null
+++ b/.github/review-policy.yml
@@ -0,0 +1,3 @@
+remote: python-discord/.github
+path: review-policies/core-developers.yml
+ref: main
-- 
cgit v1.2.3


From 0f66fe3040d70de51ece1aa0de38a88b20000221 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Sun, 6 Dec 2020 11:16:56 -0500
Subject: User gets a more detailed message from the bot

Whereas one of my previous commits makes the message the user gets and the infraction that gets recorded the same, the recorded infraction is now shorter, but the message the user gets is more similar to the embed posted in the public channel. We also softened the language of the user-facing message a bit.
---
 bot/exts/moderation/infraction/superstarify.py | 28 +++++++++++++++-----------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index e7d1c4da8..1d512a4c7 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -136,9 +136,8 @@ class Superstarify(InfractionScheduler, Cog):
 
         # Post the infraction to the API
         old_nick = member.display_name
-        reason = (f"Nickname '{old_nick}' does not comply with our [nickname policy]({NICKNAME_POLICY_URL}). "
-                  f"{reason}")
-        infraction = await _utils.post_infraction(ctx, member, "superstar", reason, duration, active=True)
+        infraction_reason = f'Old nickname: {old_nick}. {reason}'
+        infraction = await _utils.post_infraction(ctx, member, "superstar", infraction_reason, duration, active=True)
         id_ = infraction["id"]
 
         forced_nick = self.get_nick(id_, member.id)
@@ -158,9 +157,21 @@ class Superstarify(InfractionScheduler, Cog):
             New nickname: `{forced_nick}`
         """).strip()
 
+        formatted_reason = f'**Additional details:** {reason}\n\n' if reason else ''
+
+        embed_reason = (
+            f"Your previous nickname, **{old_nick}**, "
+            f"didn't comply with our nickname policy. "
+            f"Your new nickname will be **{forced_nick}**.\n\n"
+            f"{formatted_reason}"
+            f"You will be unable to change your nickname until **{expiry_str}**. "
+            "If you're confused by this, please read our "
+            f"[official nickname policy]({NICKNAME_POLICY_URL})."
+        )
+
         successful = await self.apply_infraction(
             ctx, infraction, member, action(),
-            user_reason=reason,
+            user_reason=embed_reason,
             additional_info=nickname_info
         )
 
@@ -171,14 +182,7 @@ class Superstarify(InfractionScheduler, Cog):
             embed = Embed(
                 title="Congratulations!",
                 colour=constants.Colours.soft_orange,
-                description=(
-                    f"Your previous nickname, **{old_nick}**, "
-                    f"was so bad that we have decided to change it. "
-                    f"Your new nickname will be **{forced_nick}**.\n\n"
-                    f"You will be unable to change your nickname until **{expiry_str}**.\n\n"
-                    "If you're confused by this, please read our "
-                    f"[official nickname policy]({NICKNAME_POLICY_URL})."
-                )
+                description=embed_reason
             )
             await ctx.send(embed=embed)
 
-- 
cgit v1.2.3


From 345ee39e7cc5449e563817c4f30895638c66c206 Mon Sep 17 00:00:00 2001
From: Dennis Pham <dennis@dennispham.me>
Date: Sun, 6 Dec 2020 13:29:35 -0500
Subject: Update CODEOWNERS for @Den4200

---
 .github/CODEOWNERS | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 642676078..73e303325 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,6 +1,3 @@
-# Request Dennis for any PR
-* @Den4200
-
 # Extensions
 **/bot/exts/backend/sync/**             @MarkKoz
 **/bot/exts/filters/*token_remover.py   @MarkKoz
@@ -9,8 +6,8 @@ bot/exts/info/codeblock/**              @MarkKoz
 bot/exts/utils/extensions.py            @MarkKoz
 bot/exts/utils/snekbox.py               @MarkKoz @Akarys42
 bot/exts/help_channels/**               @MarkKoz @Akarys42
-bot/exts/moderation/**                  @Akarys42 @mbaruh
-bot/exts/info/**                        @Akarys42 @mbaruh
+bot/exts/moderation/**                  @Akarys42 @mbaruh @Den4200
+bot/exts/info/**                        @Akarys42 @mbaruh @Den4200
 bot/exts/filters/**                     @mbaruh
 
 # Utils
@@ -26,9 +23,9 @@ tests/bot/exts/test_cogs.py             @MarkKoz
 tests/**                                @Akarys42
 
 # CI & Docker
-.github/workflows/**                    @MarkKoz @Akarys42 @SebastiaanZ
-Dockerfile                              @MarkKoz @Akarys42
-docker-compose.yml                      @MarkKoz @Akarys42
+.github/workflows/**                    @MarkKoz @Akarys42 @SebastiaanZ @Den4200
+Dockerfile                              @MarkKoz @Akarys42 @Den4200
+docker-compose.yml                      @MarkKoz @Akarys42 @Den4200
 
 # Tools
 Pipfile*                                @Akarys42
-- 
cgit v1.2.3


From 032b64f625d9d16f532ba0e895a412bc24ee9659 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Mon, 7 Dec 2020 11:04:38 -0500
Subject: Use the original wording of the public embed, but change the title to
 "Superstarified!"

Per internal staff discussion, we'll keep the wording of the message.
---
 bot/exts/moderation/infraction/superstarify.py | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/bot/exts/moderation/infraction/superstarify.py b/bot/exts/moderation/infraction/superstarify.py
index 1d512a4c7..ffc470c54 100644
--- a/bot/exts/moderation/infraction/superstarify.py
+++ b/bot/exts/moderation/infraction/superstarify.py
@@ -157,32 +157,29 @@ class Superstarify(InfractionScheduler, Cog):
             New nickname: `{forced_nick}`
         """).strip()
 
-        formatted_reason = f'**Additional details:** {reason}\n\n' if reason else ''
-
-        embed_reason = (
+        user_message = (
             f"Your previous nickname, **{old_nick}**, "
-            f"didn't comply with our nickname policy. "
+            f"was so bad that we have decided to change it. "
             f"Your new nickname will be **{forced_nick}**.\n\n"
-            f"{formatted_reason}"
+            "{reason}"
             f"You will be unable to change your nickname until **{expiry_str}**. "
             "If you're confused by this, please read our "
             f"[official nickname policy]({NICKNAME_POLICY_URL})."
-        )
+        ).format
 
         successful = await self.apply_infraction(
             ctx, infraction, member, action(),
-            user_reason=embed_reason,
+            user_reason=user_message(reason=f'**Additional details:** {reason}\n\n' if reason else ''),
             additional_info=nickname_info
         )
 
-        # Send an embed with the infraction information to the invoking context if
-        # superstar was successful.
+        # Send an embed with to the invoking context if superstar was successful.
         if successful:
             log.trace(f"Sending superstar #{id_} embed.")
             embed = Embed(
-                title="Congratulations!",
+                title="Superstarified!",
                 colour=constants.Colours.soft_orange,
-                description=embed_reason
+                description=user_message(reason='')
             )
             await ctx.send(embed=embed)
 
-- 
cgit v1.2.3


From 9d00ef35afd5b64c070003a7941cc38d98bdf9cc Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Wed, 9 Dec 2020 07:56:21 +0200
Subject: Add sf alias to snowflake command

---
 bot/exts/utils/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bot/exts/utils/utils.py b/bot/exts/utils/utils.py
index 3f16bc10b..87abbe4de 100644
--- a/bot/exts/utils/utils.py
+++ b/bot/exts/utils/utils.py
@@ -168,7 +168,7 @@ class Utils(Cog):
         embed.description = best_match
         await ctx.send(embed=embed)
 
-    @command(aliases=("snf", "snfl"))
+    @command(aliases=("snf", "snfl", "sf"))
     @in_whitelist(channels=(Channels.bot_commands,), roles=STAFF_ROLES)
     async def snowflake(self, ctx: Context, snowflake: int) -> None:
         """Get Discord snowflake creation time."""
-- 
cgit v1.2.3


From e0335bbb3fe1c35259647be2e23fb09fb2b09284 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Wed, 9 Dec 2020 19:58:25 -0500
Subject: Create Verify cog for new `!verify` command.

`!verify` command allows moderators to apply the Developer role to a
user. `!verify` is therefore removed as an alias for `!accept`.
---
 bot/exts/moderation/verification.py |  2 +-
 bot/exts/moderation/verify.py       | 45 +++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)
 create mode 100644 bot/exts/moderation/verify.py

diff --git a/bot/exts/moderation/verification.py b/bot/exts/moderation/verification.py
index c599156d0..b1c94185a 100644
--- a/bot/exts/moderation/verification.py
+++ b/bot/exts/moderation/verification.py
@@ -756,7 +756,7 @@ class Verification(Cog):
         log.trace(f"Bumping verification stats in category: {category}")
         self.bot.stats.incr(f"verification.{category}")
 
-    @command(name='accept', aliases=('verify', 'verified', 'accepted'), hidden=True)
+    @command(name='accept', aliases=('verified', 'accepted'), hidden=True)
     @has_no_roles(constants.Roles.verified)
     @in_whitelist(channels=(constants.Channels.verification,))
     async def accept_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
diff --git a/bot/exts/moderation/verify.py b/bot/exts/moderation/verify.py
new file mode 100644
index 000000000..09f50efde
--- /dev/null
+++ b/bot/exts/moderation/verify.py
@@ -0,0 +1,45 @@
+import logging
+
+from discord import Member, Role
+from discord.ext.commands import Cog, Context, command, has_any_role
+
+from bot.bot import Bot
+from bot.constants import Emojis, Guild, MODERATION_ROLES, Roles
+
+log = logging.getLogger(__name__)
+
+
+class Verify(Cog):
+    """Command for applying verification roles."""
+
+    def __init__(self, bot: Bot) -> None:
+        self.bot = bot
+        self.developer_role: Role = None
+
+    @Cog.listener()
+    async def on_ready(self) -> None:
+        """Sets `self.developer_role` to the Role object once the bot is online."""
+        await self.bot.wait_until_guild_available()
+        self.developer_role = self.bot.get_guild(Guild.id).get_role(Roles.verified)
+
+    @command(name='verify')
+    @has_any_role(*MODERATION_ROLES)
+    async def apply_developer_role(self, ctx: Context, user: Member) -> None:
+        """Command for moderators to apply the Developer role to any user."""
+        log.trace(f'verify command called by {ctx.author} for {user.id}.')
+        if self.developer_role is None:
+            await self.on_ready()
+
+        if self.developer_role in user.roles:
+            log.trace(f'{user.id} is already a developer, aborting.')
+            await ctx.send(f'{Emojis.cross_mark} {user} is already a developer.')
+            return
+
+        await user.add_roles(self.developer_role)
+        log.trace(f'Developer role successfully applied to {user.id}')
+        await ctx.send(f'{Emojis.check_mark} Developer role role applied to {user}.')
+
+
+def setup(bot: Bot) -> None:
+    """Load the Verify cog."""
+    bot.add_cog(Verify(bot))
-- 
cgit v1.2.3


From 0833ad51cfbd93df2d5a655255e6161334b4efe6 Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Wed, 9 Dec 2020 22:59:02 -0500
Subject: Delete verify.py, integrate `!verify` command into verification.py.

There wasn't any reason the command needed its own cog, so the exact
same functionality is now in the Verification cog.
---
 bot/exts/moderation/verification.py | 16 +++++++++++++
 bot/exts/moderation/verify.py       | 45 -------------------------------------
 2 files changed, 16 insertions(+), 45 deletions(-)
 delete mode 100644 bot/exts/moderation/verify.py

diff --git a/bot/exts/moderation/verification.py b/bot/exts/moderation/verification.py
index b1c94185a..c42c6588f 100644
--- a/bot/exts/moderation/verification.py
+++ b/bot/exts/moderation/verification.py
@@ -848,6 +848,22 @@ class Verification(Cog):
         else:
             return True
 
+    @command(name='verify')
+    @has_any_role(*constants.MODERATION_ROLES)
+    async def apply_developer_role(self, ctx: Context, user: discord.Member) -> None:
+        """Command for moderators to apply the Developer role to any user."""
+        log.trace(f'verify command called by {ctx.author} for {user.id}.')
+        developer_role = self.bot.get_guild(constants.Guild.id).get_role(constants.Roles.verified)
+
+        if developer_role in user.roles:
+            log.trace(f'{user.id} is already a developer, aborting.')
+            await ctx.send(f'{constants.Emojis.cross_mark} {user} is already a developer.')
+            return
+
+        await user.add_roles(developer_role)
+        log.trace(f'Developer role successfully applied to {user.id}')
+        await ctx.send(f'{constants.Emojis.check_mark} Developer role applied to {user}.')
+
     # endregion
 
 
diff --git a/bot/exts/moderation/verify.py b/bot/exts/moderation/verify.py
deleted file mode 100644
index 09f50efde..000000000
--- a/bot/exts/moderation/verify.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import logging
-
-from discord import Member, Role
-from discord.ext.commands import Cog, Context, command, has_any_role
-
-from bot.bot import Bot
-from bot.constants import Emojis, Guild, MODERATION_ROLES, Roles
-
-log = logging.getLogger(__name__)
-
-
-class Verify(Cog):
-    """Command for applying verification roles."""
-
-    def __init__(self, bot: Bot) -> None:
-        self.bot = bot
-        self.developer_role: Role = None
-
-    @Cog.listener()
-    async def on_ready(self) -> None:
-        """Sets `self.developer_role` to the Role object once the bot is online."""
-        await self.bot.wait_until_guild_available()
-        self.developer_role = self.bot.get_guild(Guild.id).get_role(Roles.verified)
-
-    @command(name='verify')
-    @has_any_role(*MODERATION_ROLES)
-    async def apply_developer_role(self, ctx: Context, user: Member) -> None:
-        """Command for moderators to apply the Developer role to any user."""
-        log.trace(f'verify command called by {ctx.author} for {user.id}.')
-        if self.developer_role is None:
-            await self.on_ready()
-
-        if self.developer_role in user.roles:
-            log.trace(f'{user.id} is already a developer, aborting.')
-            await ctx.send(f'{Emojis.cross_mark} {user} is already a developer.')
-            return
-
-        await user.add_roles(self.developer_role)
-        log.trace(f'Developer role successfully applied to {user.id}')
-        await ctx.send(f'{Emojis.check_mark} Developer role role applied to {user}.')
-
-
-def setup(bot: Bot) -> None:
-    """Load the Verify cog."""
-    bot.add_cog(Verify(bot))
-- 
cgit v1.2.3


From 47a2607ac85c7cf808152c301fb6969723915389 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Thu, 10 Dec 2020 15:39:09 +0200
Subject: Use Snowflake converter for snowflake command

---
 bot/exts/utils/utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bot/exts/utils/utils.py b/bot/exts/utils/utils.py
index 87abbe4de..8e7e6ba36 100644
--- a/bot/exts/utils/utils.py
+++ b/bot/exts/utils/utils.py
@@ -13,6 +13,7 @@ from discord.utils import snowflake_time
 
 from bot.bot import Bot
 from bot.constants import Channels, MODERATION_ROLES, STAFF_ROLES
+from bot.converters import Snowflake
 from bot.decorators import in_whitelist
 from bot.pagination import LinePaginator
 from bot.utils import messages
@@ -170,7 +171,7 @@ class Utils(Cog):
 
     @command(aliases=("snf", "snfl", "sf"))
     @in_whitelist(channels=(Channels.bot_commands,), roles=STAFF_ROLES)
-    async def snowflake(self, ctx: Context, snowflake: int) -> None:
+    async def snowflake(self, ctx: Context, snowflake: Snowflake) -> None:
         """Get Discord snowflake creation time."""
         created_at = snowflake_time(snowflake)
         embed = Embed(
-- 
cgit v1.2.3


From def97dd4c9d43bf2a5275a860a9eeb8e91bdb5a9 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
Date: Thu, 10 Dec 2020 21:30:58 +0100
Subject: Send a custom workflow status embed to Discord

This commit introduces the same custom status embed as is already being
used for Sir Lancebot. The default embeds GitHub sends are disabled, as
they were causing slight issues with rate limits from time to time.

It works like this:

- The Lint & Test workflow stores an artifact with PR information, if we
  are linting/testing a PR.

- Whenever we reach the end of a workflow run sequence, a status embed
  is send with the conclusion status.

Signed-off-by: Sebastiaan Zeeff <sebastiaan.zeeff@gmail.com>
---
 .github/workflows/lint-test.yml     | 22 +++++++++++
 .github/workflows/status_embed.yaml | 78 +++++++++++++++++++++++++++++++++++++
 2 files changed, 100 insertions(+)
 create mode 100644 .github/workflows/status_embed.yaml

diff --git a/.github/workflows/lint-test.yml b/.github/workflows/lint-test.yml
index 5444fc3de..a38f031fa 100644
--- a/.github/workflows/lint-test.yml
+++ b/.github/workflows/lint-test.yml
@@ -113,3 +113,25 @@ jobs:
         env:
             GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: coveralls
+
+      # Prepare the Pull Request Payload artifact. If this fails, we
+      # we fail silently using the `continue-on-error` option. It's
+      # nice if this succeeds, but if it fails for any reason, it
+      # does not mean that our lint-test checks failed.
+      - name: Prepare Pull Request Payload artifact
+        id: prepare-artifact
+        if: always() && github.event_name == 'pull_request'
+        continue-on-error: true
+        run: cat $GITHUB_EVENT_PATH | jq '.pull_request' > pull_request_payload.json
+
+      # This only makes sense if the previous step succeeded. To
+      # get the original outcome of the previous step before the
+      # `continue-on-error` conclusion is applied, we use the
+      # `.outcome` value. This step also fails silently.
+      - name: Upload a Build Artifact
+        if: steps.prepare-artifact.outcome == 'success'
+        continue-on-error: true
+        uses: actions/upload-artifact@v2
+        with:
+          name: pull-request-payload
+          path: pull_request_payload.json
diff --git a/.github/workflows/status_embed.yaml b/.github/workflows/status_embed.yaml
new file mode 100644
index 000000000..b6a71b887
--- /dev/null
+++ b/.github/workflows/status_embed.yaml
@@ -0,0 +1,78 @@
+name: Status Embed
+
+on:
+  workflow_run:
+    workflows:
+      - Lint & Test
+      - Build
+      - Deploy
+    types:
+      - completed
+
+jobs:
+  status_embed:
+    # We need to send a status embed whenever the workflow
+    # sequence we're running terminates. There are a number
+    # of situations in which that happens:
+    #
+    # 1. We reach the end of the Deploy workflow, without
+    #    it being skipped.
+    #
+    # 2. A `pull_request` triggered a Lint & Test workflow,
+    #    as the sequence always terminates with one run.
+    #
+    # 3. If any workflow ends in failure or was cancelled.
+    if: >-
+      (github.event.workflow_run.name == 'Deploy' && github.event.workflow_run.conclusion != 'skipped') ||
+      github.event.workflow_run.event == 'pull_request' ||
+      github.event.workflow_run.conclusion == 'failure' ||
+      github.event.workflow_run.conclusion == 'cancelled'
+    name:  Send Status Embed to Discord
+    runs-on: ubuntu-latest
+
+    steps:
+      # A workflow_run event does not contain all the information
+      # we need for a PR embed. That's why we upload an artifact
+      # with that information in the Lint workflow.
+      - name: Get Pull Request Information
+        id: pr_info
+        if: github.event.workflow_run.event == 'pull_request'
+        run: |
+          curl -s -H "Authorization: token $GITHUB_TOKEN" ${{ github.event.workflow_run.artifacts_url }} > artifacts.json
+          DOWNLOAD_URL=$(cat artifacts.json | jq -r '.artifacts[] | select(.name == "pull-request-payload") | .archive_download_url')
+          [ -z "$DOWNLOAD_URL" ] && exit 1
+          wget --quiet --header="Authorization: token $GITHUB_TOKEN" -O pull_request_payload.zip $DOWNLOAD_URL || exit 2
+          unzip -p pull_request_payload.zip > pull_request_payload.json
+          [ -s pull_request_payload.json ] || exit 3
+          echo "::set-output name=pr_author_login::$(jq -r '.user.login // empty' pull_request_payload.json)"
+          echo "::set-output name=pr_number::$(jq -r '.number // empty' pull_request_payload.json)"
+          echo "::set-output name=pr_title::$(jq -r '.title // empty' pull_request_payload.json)"
+          echo "::set-output name=pr_source::$(jq -r '.head.label // empty' pull_request_payload.json)"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Send an informational status embed to Discord instead of the
+      # standard embeds that Discord sends. This embed will contain
+      # more information and we can fine tune when we actually want
+      # to send an embed.
+      - name: GitHub Actions Status Embed for Discord
+        uses: SebastiaanZ/github-status-embed-for-discord@v0.2.1
+        with:
+          # Our GitHub Actions webhook
+          webhook_id: '784184528997842985'
+          webhook_token: ${{ secrets.GHA_WEBHOOK_TOKEN }}
+
+          # Workflow information
+          workflow_name: ${{ github.event.workflow_run.name }}
+          run_id: ${{ github.event.workflow_run.id }}
+          run_number: ${{ github.event.workflow_run.run_number }}
+          status: ${{ github.event.workflow_run.conclusion }}
+          actor: ${{ github.actor }}
+          repository:  ${{ github.repository }}
+          ref: ${{ github.ref }}
+          sha: ${{ github.event.workflow_run.head_sha }}
+
+          pr_author_login: ${{ steps.pr_info.outputs.pr_author_login }}
+          pr_number: ${{ steps.pr_info.outputs.pr_number }}
+          pr_title: ${{ steps.pr_info.outputs.pr_title }}
+          pr_source: ${{ steps.pr_info.outputs.pr_source }}
-- 
cgit v1.2.3


From 35f7ecda15e017afd184a94404d21c3f97cd0583 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Fri, 11 Dec 2020 06:45:21 +0100
Subject: Make sure PR build artifact is always uploaded

GitHub Actions has an implicit status condition, `success()`, that
is added whenever an `if` condition lacks a status function check
of its own. In this case, while the upload step did check for the
outcome of the previous "always" step, it did not have an actual
status check and, thus, only ran on success.

Since we always want to upload the artifact, even if other steps
failed, I've added the "always" status function now.
---
 .github/workflows/lint-test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/lint-test.yml b/.github/workflows/lint-test.yml
index a38f031fa..6fa8e8333 100644
--- a/.github/workflows/lint-test.yml
+++ b/.github/workflows/lint-test.yml
@@ -129,7 +129,7 @@ jobs:
       # `continue-on-error` conclusion is applied, we use the
       # `.outcome` value. This step also fails silently.
       - name: Upload a Build Artifact
-        if: steps.prepare-artifact.outcome == 'success'
+        if: always() && steps.prepare-artifact.outcome == 'success'
         continue-on-error: true
         uses: actions/upload-artifact@v2
         with:
-- 
cgit v1.2.3