Merge branch 'main' into main

author: Matteo Bertucci <[email protected]> 2021-07-20 08:52:06 +0200
committer: GitHub <[email protected]> 2021-07-20 08:52:06 +0200
commit: 7b30ea65acae3a7915d62b478af1525dbaed70a3 (patch)
tree: 127d5a27e18175f1ff60242c1a61f9a2c05b23b7
parent: Enabled charinfo for discord_py channel. (diff)
parent: feat: add for-else tag (#1643) (diff)
47 files changed, 2001 insertions, 733 deletions
diff --git a/.coveragerc b/.coveragerc
deleted file mode 100644
index d572bd705..000000000
--- a/.coveragerc
+++ /dev/null
@@ -1,5 +0,0 @@
-[run]
-branch = true
-source =
-    bot
-    tests
diff --git a/.github/workflows/lint-test.yml b/.github/workflows/lint-test.yml
index d96f324ec..e99e6d181 100644
--- a/.github/workflows/lint-test.yml
+++ b/.github/workflows/lint-test.yml
@@ -97,12 +97,8 @@ jobs:
         --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
+        run: pytest -n auto --cov --disable-warnings -q
 
       # This step will publish the coverage reports coveralls.io and
       # print a "job" link in the output of the GitHub Action
diff --git a/bot/constants.py b/bot/constants.py
index 885b5c822..500803f33 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -400,6 +400,8 @@ class Categories(metaclass=YAMLGetter):
     modmail: int
     voice: int
 
+    # 2021 Summer Code Jam
+    summer_code_jam: int
 
 class Channels(metaclass=YAMLGetter):
     section = "guild"
@@ -433,10 +435,13 @@ class Channels(metaclass=YAMLGetter):
     off_topic_1: int
     off_topic_2: int
 
+    black_formatter: int
+
     bot_commands: int
     discord_py: int
     esoteric: int
     voice_gate: int
+    code_jam_planning: int
 
     admins: int
     admin_spam: int
@@ -454,15 +459,17 @@ class Channels(metaclass=YAMLGetter):
     staff_announcements: int
 
     admins_voice: int
+    code_help_voice_0: int
     code_help_voice_1: int
-    code_help_voice_2: int
-    general_voice: int
+    general_voice_0: int
+    general_voice_1: int
     staff_voice: int
 
+    code_help_chat_0: int
     code_help_chat_1: int
-    code_help_chat_2: int
     staff_voice_chat: int
-    voice_chat: int
+    voice_chat_0: int
+    voice_chat_1: int
 
     big_brother_logs: int
     talent_pool: int
@@ -495,8 +502,10 @@ class Roles(metaclass=YAMLGetter):
 
     admins: int
     core_developers: int
+    code_jam_event_team: int
     devops: int
     domain_leads: int
+    events_lead: int
     helpers: int
     moderators: int
     mod_team: int
@@ -504,7 +513,6 @@ class Roles(metaclass=YAMLGetter):
     project_leads: int
 
     jammers: int
-    team_leaders: int
 
 
 class Guild(metaclass=YAMLGetter):
@@ -602,7 +610,6 @@ class HelpChannels(metaclass=YAMLGetter):
     section = 'help_channels'
 
     enable: bool
-    claim_minutes: int
     cmd_whitelist: List[int]
     idle_minutes_claimant: int
     idle_minutes_others: int
diff --git a/bot/converters.py b/bot/converters.py
index 2a3943831..595809517 100644
--- a/bot/converters.py
+++ b/bot/converters.py
@@ -416,11 +416,11 @@ class HushDurationConverter(Converter):
 
     MINUTES_RE = re.compile(r"(\d+)(?:M|m|$)")
 
-    async def convert(self, ctx: Context, argument: str) -> t.Optional[int]:
+    async def convert(self, ctx: Context, argument: str) -> int:
         """
         Convert `argument` to a duration that's max 15 minutes or None.
 
-        If `"forever"` is passed, None is returned; otherwise an int of the extracted time.
+        If `"forever"` is passed, -1 is returned; otherwise an int of the extracted time.
         Accepted formats are:
         * <duration>,
         * <duration>m,
@@ -428,7 +428,7 @@ class HushDurationConverter(Converter):
         * forever.
         """
         if argument == "forever":
-            return None
+            return -1
         match = self.MINUTES_RE.match(argument)
         if not match:
             raise BadArgument(f"{argument} is not a valid minutes duration.")
diff --git a/bot/errors.py b/bot/errors.py
index 3544c6320..46efb6d4f 100644
--- a/bot/errors.py
+++ b/bot/errors.py
@@ -22,7 +22,7 @@ class LockedResourceError(RuntimeError):
         )
 
 
-class InvalidInfractedUser(Exception):
+class InvalidInfractedUserError(Exception):
     """
     Exception raised upon attempt of infracting an invalid user.
 
diff --git a/bot/exts/backend/error_handler.py b/bot/exts/backend/error_handler.py
index d8de177f5..578c372c3 100644
--- a/bot/exts/backend/error_handler.py
+++ b/bot/exts/backend/error_handler.py
@@ -3,14 +3,14 @@ import logging
 import typing as t
 
 from discord import Embed
-from discord.ext.commands import Cog, Context, errors
+from discord.ext.commands import ChannelNotFound, Cog, Context, TextChannelConverter, VoiceChannelConverter, errors
 from sentry_sdk import push_scope
 
 from bot.api import ResponseCodeError
 from bot.bot import Bot
 from bot.constants import Colours, Icons, MODERATION_ROLES
 from bot.converters import TagNameConverter
-from bot.errors import InvalidInfractedUser, LockedResourceError
+from bot.errors import InvalidInfractedUserError, LockedResourceError
 from bot.utils.checks import ContextCheckFailure
 
 log = logging.getLogger(__name__)
@@ -76,7 +76,7 @@ class ErrorHandler(Cog):
                 await self.handle_api_error(ctx, e.original)
             elif isinstance(e.original, LockedResourceError):
                 await ctx.send(f"{e.original} Please wait for it to finish and try again later.")
-            elif isinstance(e.original, InvalidInfractedUser):
+            elif isinstance(e.original, InvalidInfractedUserError):
                 await ctx.send(f"Cannot infract that user. {e.original.reason}")
             else:
                 await self.handle_unexpected_error(ctx, e.original)
@@ -115,8 +115,10 @@ class ErrorHandler(Cog):
         Return bool depending on success of command.
         """
         command = ctx.invoked_with.lower()
+        args = ctx.message.content.lower().split(" ")
         silence_command = self.bot.get_command("silence")
         ctx.invoked_from_error_handler = True
+
         try:
             if not await silence_command.can_run(ctx):
                 log.debug("Cancelling attempt to invoke silence/unsilence due to failed checks.")
@@ -124,11 +126,30 @@ class ErrorHandler(Cog):
         except errors.CommandError:
             log.debug("Cancelling attempt to invoke silence/unsilence due to failed checks.")
             return False
+
+        # Parse optional args
+        channel = None
+        duration = min(command.count("h") * 2, 15)
+        kick = False
+
+        if len(args) > 1:
+            # Parse channel
+            for converter in (TextChannelConverter(), VoiceChannelConverter()):
+                try:
+                    channel = await converter.convert(ctx, args[1])
+                    break
+                except ChannelNotFound:
+                    continue
+
+        if len(args) > 2 and channel is not None:
+            # Parse kick
+            kick = args[2].lower() == "true"
+
         if command.startswith("shh"):
-            await ctx.invoke(silence_command, duration=min(command.count("h")*2, 15))
+            await ctx.invoke(silence_command, duration_or_channel=channel, duration=duration, kick=kick)
             return True
         elif command.startswith("unshh"):
-            await ctx.invoke(self.bot.get_command("unsilence"))
+            await ctx.invoke(self.bot.get_command("unsilence"), channel=channel)
             return True
         return False
 
diff --git a/bot/exts/filters/antimalware.py b/bot/exts/filters/antimalware.py
index 26f00e91f..4c4836c88 100644
--- a/bot/exts/filters/antimalware.py
+++ b/bot/exts/filters/antimalware.py
@@ -7,6 +7,7 @@ from discord.ext.commands import Cog
 
 from bot.bot import Bot
 from bot.constants import Channels, Filter, URLs
+from bot.exts.utils.jams import CATEGORY_NAME as JAM_CATEGORY_NAME
 
 log = logging.getLogger(__name__)
 
@@ -15,9 +16,11 @@ PY_EMBED_DESCRIPTION = (
     f"please use a code-pasting service such as {URLs.site_schema}{URLs.site_paste}"
 )
 
+TXT_LIKE_FILES = {".txt", ".csv", ".json"}
 TXT_EMBED_DESCRIPTION = (
     "**Uh-oh!** It looks like your message got zapped by our spam filter. "
-    "We currently don't allow `.txt` attachments, so here are some tips to help you travel safely: \n\n"
+    "We currently don't allow `{blocked_extension}` attachments, "
+    "so here are some tips to help you travel safely: \n\n"
     "• If you attempted to send a message longer than 2000 characters, try shortening your message "
     "to fit within the character limit or use a pasting service (see below) \n\n"
     "• If you tried to show someone your code, you can use codeblocks \n(run `!code-blocks` in "
@@ -59,6 +62,10 @@ class AntiMalware(Cog):
         if message.webhook_id or message.author.bot:
             return
 
+        # Ignore code jam channels
+        if hasattr(message.channel, "category") and message.channel.category.name == JAM_CATEGORY_NAME:
+            return
+
         # Check if user is staff, if is, return
         # Since we only care that roles exist to iterate over, check for the attr rather than a User/Member instance
         if hasattr(message.author, "roles") and any(role.id in Filter.role_whitelist for role in message.author.roles):
@@ -70,10 +77,13 @@ class AntiMalware(Cog):
         if ".py" in extensions_blocked:
             # Short-circuit on *.py files to provide a pastebin link
             embed.description = PY_EMBED_DESCRIPTION
-        elif ".txt" in extensions_blocked:
+        elif extensions := TXT_LIKE_FILES.intersection(extensions_blocked):
             # Work around Discord AutoConversion of messages longer than 2000 chars to .txt
             cmd_channel = self.bot.get_channel(Channels.bot_commands)
-            embed.description = TXT_EMBED_DESCRIPTION.format(cmd_channel_mention=cmd_channel.mention)
+            embed.description = TXT_EMBED_DESCRIPTION.format(
+                blocked_extension=extensions.pop(),
+                cmd_channel_mention=cmd_channel.mention
+            )
         elif extensions_blocked:
             meta_channel = self.bot.get_channel(Channels.meta)
             embed.description = DISALLOWED_EMBED_DESCRIPTION.format(
diff --git a/bot/exts/filters/antispam.py b/bot/exts/filters/antispam.py
index 7555e25a2..48c3aa5a6 100644
--- a/bot/exts/filters/antispam.py
+++ b/bot/exts/filters/antispam.py
@@ -18,6 +18,7 @@ from bot.constants import (
 )
 from bot.converters import Duration
 from bot.exts.moderation.modlog import ModLog
+from bot.exts.utils.jams import CATEGORY_NAME as JAM_CATEGORY_NAME
 from bot.utils import lock, scheduling
 from bot.utils.messages import format_user, send_attachments
 
@@ -148,6 +149,7 @@ class AntiSpam(Cog):
             not message.guild
             or message.guild.id != GuildConfig.id
             or message.author.bot
+            or (hasattr(message.channel, "category") and message.channel.category.name == JAM_CATEGORY_NAME)
             or (message.channel.id in Filter.channel_whitelist and not DEBUG_MODE)
             or (any(role.id in Filter.role_whitelist for role in message.author.roles) and not DEBUG_MODE)
         ):
diff --git a/bot/exts/filters/filtering.py b/bot/exts/filters/filtering.py
index 464732453..16aaf11cf 100644
--- a/bot/exts/filters/filtering.py
+++ b/bot/exts/filters/filtering.py
@@ -20,6 +20,7 @@ from bot.constants import (
     Guild, Icons, URLs
 )
 from bot.exts.moderation.modlog import ModLog
+from bot.exts.utils.jams import CATEGORY_NAME as JAM_CATEGORY_NAME
 from bot.utils.messages import format_user
 from bot.utils.regex import INVITE_RE
 from bot.utils.scheduling import Scheduler
@@ -103,19 +104,6 @@ class Filtering(Cog):
                 ),
                 "schedule_deletion": False
             },
-            "filter_everyone_ping": {
-                "enabled": Filter.filter_everyone_ping,
-                "function": self._has_everyone_ping,
-                "type": "filter",
-                "content_only": True,
-                "user_notification": Filter.notify_user_everyone_ping,
-                "notification_msg": (
-                    "Please don't try to ping `@everyone` or `@here`. "
-                    f"Your message has been removed. {staff_mistake_str}"
-                ),
-                "schedule_deletion": False,
-                "ping_everyone": False
-            },
             "watch_regex": {
                 "enabled": Filter.watch_regex,
                 "function": self._has_watch_regex_match,
@@ -129,7 +117,20 @@ class Filtering(Cog):
                 "type": "watchlist",
                 "content_only": False,
                 "schedule_deletion": False
-            }
+            },
+            "filter_everyone_ping": {
+                "enabled": Filter.filter_everyone_ping,
+                "function": self._has_everyone_ping,
+                "type": "filter",
+                "content_only": True,
+                "user_notification": Filter.notify_user_everyone_ping,
+                "notification_msg": (
+                    "Please don't try to ping `@everyone` or `@here`. "
+                    f"Your message has been removed. {staff_mistake_str}"
+                ),
+                "schedule_deletion": False,
+                "ping_everyone": False
+            },
         }
 
         self.bot.loop.create_task(self.reschedule_offensive_msg_deletion())
@@ -281,6 +282,12 @@ class Filtering(Cog):
                         if delta is not None and delta < 100:
                             continue
 
+                    if filter_name in ("filter_invites", "filter_everyone_ping"):
+                        # Disable invites filter in codejam team channels
+                        category = getattr(msg.channel, "category", None)
+                        if category and category.name == JAM_CATEGORY_NAME:
+                            continue
+
                     # Does the filter only need the message content or the full message?
                     if _filter["content_only"]:
                         payload = msg.content
diff --git a/bot/exts/help_channels/_caches.py b/bot/exts/help_channels/_caches.py
index c5e4ee917..8d45c2466 100644
--- a/bot/exts/help_channels/_caches.py
+++ b/bot/exts/help_channels/_caches.py
@@ -24,3 +24,12 @@ question_messages = RedisCache(namespace="HelpChannels.question_messages")
 # This cache keeps track of the dynamic message ID for
 # the continuously updated message in the #How-to-get-help channel.
 dynamic_message = RedisCache(namespace="HelpChannels.dynamic_message")
+
+# This cache keeps track of who has help-dms on.
+# RedisCache[discord.User.id, bool]
+help_dm = RedisCache(namespace="HelpChannels.help_dm")
+
+# This cache tracks member who are participating and opted in to help channel dms.
+# serialise the set as a comma separated string to allow usage with redis
+# RedisCache[discord.TextChannel.id, str[set[discord.User.id]]]
+session_participants = RedisCache(namespace="HelpChannels.session_participants")
diff --git a/bot/exts/help_channels/_cog.py b/bot/exts/help_channels/_cog.py
index 262b18e16..35658d117 100644
--- a/bot/exts/help_channels/_cog.py
+++ b/bot/exts/help_channels/_cog.py
@@ -12,7 +12,8 @@ from discord.ext import commands
 
 from bot import constants
 from bot.bot import Bot
-from bot.exts.help_channels import _caches, _channel, _cooldown, _message, _name, _stats
+from bot.constants import Channels, RedirectOutput
+from bot.exts.help_channels import _caches, _channel, _message, _name, _stats
 from bot.utils import channel as channel_utils, lock, scheduling
 
 log = logging.getLogger(__name__)
@@ -94,6 +95,24 @@ class HelpChannels(commands.Cog):
 
         self.scheduler.cancel_all()
 
+    async def _handle_role_change(self, member: discord.Member, coro: t.Callable[..., t.Coroutine]) -> None:
+        """
+        Change `member`'s cooldown role via awaiting `coro` and handle errors.
+
+        `coro` is intended to be `discord.Member.add_roles` or `discord.Member.remove_roles`.
+        """
+        try:
+            await coro(self.bot.get_guild(constants.Guild.id).get_role(constants.Roles.help_cooldown))
+        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}")
+
     @lock.lock_arg(NAMESPACE, "message", attrgetter("channel.id"))
     @lock.lock_arg(NAMESPACE, "message", attrgetter("author.id"))
     @lock.lock_arg(f"{NAMESPACE}.unclaim", "message", attrgetter("author.id"), wait=True)
@@ -106,9 +125,10 @@ class HelpChannels(commands.Cog):
         """
         log.info(f"Channel #{message.channel} was claimed by `{message.author.id}`.")
         await self.move_to_in_use(message.channel)
-        await _cooldown.revoke_send_permissions(message.author, self.scheduler)
+        await self._handle_role_change(message.author, message.author.add_roles)
 
         await _message.pin(message)
+
         try:
             await _message.dm_on_open(message)
         except Exception as e:
@@ -276,7 +296,6 @@ class HelpChannels(commands.Cog):
 
         log.trace("Initialising the cog.")
         await self.init_categories()
-        await _cooldown.check_cooldowns(self.scheduler)
 
         self.channel_queue = self.create_channel_queue()
         self.name_queue = _name.create_name_queue(
@@ -406,17 +425,13 @@ class HelpChannels(commands.Cog):
     ) -> None:
         """Actual implementation of `unclaim_channel`. See that for full documentation."""
         await _caches.claimants.delete(channel.id)
-
-        # Ignore missing tasks because a channel may still be dormant after the cooldown expires.
-        if claimant_id in self.scheduler:
-            self.scheduler.cancel(claimant_id)
+        await _caches.session_participants.delete(channel.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")
-        elif not any(claimant.id == user_id for _, user_id in await _caches.claimants.items()):
-            # Remove the cooldown role if the claimant has no other channels left
-            await _cooldown.remove_cooldown_role(claimant)
+        else:
+            await self._handle_role_change(claimant, claimant.remove_roles)
 
         await _message.unpin(channel)
         await _stats.report_complete_session(channel.id, closed_on)
@@ -453,7 +468,9 @@ class HelpChannels(commands.Cog):
         if channel_utils.is_in_category(message.channel, constants.Categories.help_available):
             if not _channel.is_excluded_channel(message.channel):
                 await self.claim_channel(message)
-        else:
+
+        elif channel_utils.is_in_category(message.channel, constants.Categories.help_in_use):
+            await self.notify_session_participants(message)
             await _message.update_message_caches(message)
 
     @commands.Cog.listener()
@@ -522,3 +539,91 @@ class HelpChannels(commands.Cog):
         )
         self.dynamic_message = new_dynamic_message["id"]
         await _caches.dynamic_message.set("message_id", self.dynamic_message)
+
+    @staticmethod
+    def _serialise_session_participants(participants: set[int]) -> str:
+        """Convert a set to a comma separated string."""
+        return ','.join(str(p) for p in participants)
+
+    @staticmethod
+    def _deserialise_session_participants(s: str) -> set[int]:
+        """Convert a comma separated string into a set."""
+        return set(int(user_id) for user_id in s.split(",") if user_id != "")
+
+    @lock.lock_arg(NAMESPACE, "message", attrgetter("channel.id"))
+    @lock.lock_arg(NAMESPACE, "message", attrgetter("author.id"))
+    async def notify_session_participants(self, message: discord.Message) -> None:
+        """
+        Check if the message author meets the requirements to be notified.
+
+        If they meet the requirements they are notified.
+        """
+        if await _caches.claimants.get(message.channel.id) == message.author.id:
+            return  # Ignore messages sent by claimants
+
+        if not await _caches.help_dm.get(message.author.id):
+            return  # Ignore message if user is opted out of help dms
+
+        if (await self.bot.get_context(message)).command == self.close_command:
+            return  # Ignore messages that are closing the channel
+
+        session_participants = self._deserialise_session_participants(
+            await _caches.session_participants.get(message.channel.id) or ""
+        )
+
+        if message.author.id not in session_participants:
+            session_participants.add(message.author.id)
+
+            embed = discord.Embed(
+                title="Currently Helping",
+                description=f"You're currently helping in {message.channel.mention}",
+                color=constants.Colours.soft_green,
+                timestamp=message.created_at
+            )
+            embed.add_field(name="Conversation", value=f"[Jump to message]({message.jump_url})")
+
+            try:
+                await message.author.send(embed=embed)
+            except discord.Forbidden:
+                log.trace(
+                    f"Failed to send helpdm message to {message.author.id}. DMs Closed/Blocked. "
+                    "Removing user from helpdm."
+                )
+                bot_commands_channel = self.bot.get_channel(Channels.bot_commands)
+                await _caches.help_dm.delete(message.author.id)
+                await bot_commands_channel.send(
+                    f"{message.author.mention} {constants.Emojis.cross_mark} "
+                    "To receive updates on help channels you're active in, enable your DMs.",
+                    delete_after=RedirectOutput.delete_delay
+                )
+                return
+
+            await _caches.session_participants.set(
+                message.channel.id,
+                self._serialise_session_participants(session_participants)
+            )
+
+    @commands.command(name="helpdm")
+    async def helpdm_command(
+        self,
+        ctx: commands.Context,
+        state_bool: bool
+    ) -> None:
+        """
+        Allows user to toggle "Helping" dms.
+
+        If this is set to on the user will receive a dm for the channel they are participating in.
+
+        If this is set to off the user will not receive a dm for channel that they are participating in.
+        """
+        state_str = "ON" if state_bool else "OFF"
+
+        if state_bool == await _caches.help_dm.get(ctx.author.id, False):
+            await ctx.send(f"{constants.Emojis.cross_mark} {ctx.author.mention} Help DMs are already {state_str}")
+            return
+
+        if state_bool:
+            await _caches.help_dm.set(ctx.author.id, True)
+        else:
+            await _caches.help_dm.delete(ctx.author.id)
+        await ctx.send(f"{constants.Emojis.ok_hand} {ctx.author.mention} Help DMs {state_str}!")
diff --git a/bot/exts/help_channels/_cooldown.py b/bot/exts/help_channels/_cooldown.py
deleted file mode 100644
index c5c39297f..000000000
--- a/bot/exts/help_channels/_cooldown.py
+++ /dev/null
@@ -1,95 +0,0 @@
-import logging
-from typing import Callable, Coroutine
-
-import discord
-
-import bot
-from bot import constants
-from bot.exts.help_channels import _caches, _channel
-from bot.utils.scheduling import Scheduler
-
-log = logging.getLogger(__name__)
-CoroutineFunc = Callable[..., Coroutine]
-
-
-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 _caches.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}")
diff --git a/bot/exts/help_channels/_message.py b/bot/exts/help_channels/_message.py
index afd698ffe..befacd263 100644
--- a/bot/exts/help_channels/_message.py
+++ b/bot/exts/help_channels/_message.py
@@ -9,22 +9,20 @@ from arrow import Arrow
 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__)
 
 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.
+Send your question here to claim the channel.
 
-**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.
+**Remember to:**
+• **Ask** your Python question, not if you can ask or if there's an expert who can help.
+• **Show** a code sample as text (rather than a screenshot) and the error message, if you got one.
+• **Explain** what you expect to happen and what actually happens.
 
-For more tips, check out our guide on **[asking good questions]({ASKING_GUIDE_URL})**.
+For more tips, check out our guide on [asking good questions]({ASKING_GUIDE_URL}).
 """
 
 AVAILABLE_TITLE = "Available help channel"
@@ -47,23 +45,21 @@ async def update_message_caches(message: discord.Message) -> None:
     """Checks the source of new content in a help channel and updates the appropriate cache."""
     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 had a reply.")
+    log.trace(f"Checking if #{channel} ({channel.id}) has had a reply.")
 
-        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
+    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
 
-        # datetime.timestamp() would assume it's local, despite d.py giving a (naïve) UTC time.
-        timestamp = Arrow.fromdatetime(message.created_at).timestamp()
+    # datetime.timestamp() would assume it's local, despite d.py giving a (naïve) UTC time.
+    timestamp = Arrow.fromdatetime(message.created_at).timestamp()
 
-        # Overwrite the appropriate last message cache depending on the author of the message
-        if message.author.id == claimant_id:
-            await _caches.claimant_last_message_times.set(channel.id, timestamp)
-        else:
-            await _caches.non_claimant_last_message_times.set(channel.id, timestamp)
+    # Overwrite the appropriate last message cache depending on the author of the message
+    if message.author.id == claimant_id:
+        await _caches.claimant_last_message_times.set(channel.id, timestamp)
+    else:
+        await _caches.non_claimant_last_message_times.set(channel.id, timestamp)
 
 
 async def get_last_message(channel: discord.TextChannel) -> t.Optional[discord.Message]:
diff --git a/bot/exts/info/doc/_cog.py b/bot/exts/info/doc/_cog.py
index 2a8016fb8..c54a3ee1c 100644
--- a/bot/exts/info/doc/_cog.py
+++ b/bot/exts/info/doc/_cog.py
@@ -27,11 +27,12 @@ log = logging.getLogger(__name__)
 
 # symbols with a group contained here will get the group prefixed on duplicates
 FORCE_PREFIX_GROUPS = (
-    "2to3fixer",
-    "token",
+    "term",
     "label",
+    "token",
+    "doc",
     "pdbcommand",
-    "term",
+    "2to3fixer",
 )
 NOT_FOUND_DELETE_DELAY = RedirectOutput.delete_delay
 # Delay to wait before trying to reach a rescheduled inventory again, in minutes
@@ -181,22 +182,26 @@ class DocCog(commands.Cog):
             else:
                 return new_name
 
-        # Certain groups are added as prefixes to disambiguate the symbols.
-        if group_name in FORCE_PREFIX_GROUPS:
-            return rename(group_name)
-
-        # The existing symbol with which the current symbol conflicts should have a group prefix.
-        # It currently doesn't have the group prefix because it's only added once there's a conflict.
-        elif item.group in FORCE_PREFIX_GROUPS:
-            return rename(item.group, rename_extant=True)
+        # When there's a conflict, and the package names of the items differ, use the package name as a prefix.
+        if package_name != item.package:
+            if package_name in PRIORITY_PACKAGES:
+                return rename(item.package, rename_extant=True)
+            else:
+                return rename(package_name)
 
-        elif package_name in PRIORITY_PACKAGES:
-            return rename(item.package, rename_extant=True)
+        # If the symbol's group is a non-priority group from FORCE_PREFIX_GROUPS,
+        # add it as a prefix to disambiguate the symbols.
+        elif group_name in FORCE_PREFIX_GROUPS:
+            if item.group in FORCE_PREFIX_GROUPS:
+                needs_moving = FORCE_PREFIX_GROUPS.index(group_name) < FORCE_PREFIX_GROUPS.index(item.group)
+            else:
+                needs_moving = False
+            return rename(item.group if needs_moving else group_name, rename_extant=needs_moving)
 
-        # If we can't specially handle the symbol through its group or package,
-        # fall back to prepending its package name to the front.
+        # If the above conditions didn't pass, either the existing symbol has its group in FORCE_PREFIX_GROUPS,
+        # or deciding which item to rename would be arbitrary, so we rename the existing symbol.
         else:
-            return rename(package_name)
+            return rename(item.group, rename_extant=True)
 
     async def refresh_inventories(self) -> None:
         """Refresh internal documentation inventories."""
diff --git a/bot/exts/info/help.py b/bot/exts/info/help.py
index 3a05b2c8a..0235bbaf3 100644
--- a/bot/exts/info/help.py
+++ b/bot/exts/info/help.py
@@ -6,8 +6,8 @@ from typing import List, Union
 
 from discord import Colour, Embed
 from discord.ext.commands import Bot, Cog, Command, CommandError, Context, DisabledCommand, Group, HelpCommand
-from fuzzywuzzy import fuzz, process
-from fuzzywuzzy.utils import full_process
+from rapidfuzz import fuzz, process
+from rapidfuzz.utils import default_process
 
 from bot import constants
 from bot.constants import Channels, STAFF_ROLES
@@ -125,16 +125,9 @@ class CustomHelpCommand(HelpCommand):
 
         Will return an instance of the `HelpQueryNotFound` exception with the error message and possible matches.
         """
-        choices = await self.get_all_help_choices()
-
-        # Run fuzzywuzzy's processor beforehand, and avoid matching if processed string is empty
-        # This avoids fuzzywuzzy from raising a warning on inputs with only non-alphanumeric characters
-        if (processed := full_process(string)):
-            result = process.extractBests(processed, choices, scorer=fuzz.ratio, score_cutoff=60, processor=None)
-        else:
-            result = []
-
-        return HelpQueryNotFound(f'Query "{string}" not found.', dict(result))
+        choices = list(await self.get_all_help_choices())
+        result = process.extract(default_process(string), choices, scorer=fuzz.ratio, score_cutoff=60, processor=None)
+        return HelpQueryNotFound(f'Query "{string}" not found.', {choice[0]: choice[1] for choice in result})
 
     async def subcommand_not_found(self, command: Command, string: str) -> "HelpQueryNotFound":
         """
diff --git a/bot/exts/info/information.py b/bot/exts/info/information.py
index 834fee1b4..fc3c2c61e 100644
--- a/bot/exts/info/information.py
+++ b/bot/exts/info/information.py
@@ -5,7 +5,7 @@ import textwrap
 from collections import defaultdict
 from typing import Any, DefaultDict, Dict, Mapping, Optional, Tuple, Union
 
-import fuzzywuzzy
+import rapidfuzz
 from discord import AllowedMentions, Colour, Embed, Guild, Message, Role
 from discord.ext.commands import BucketType, Cog, Context, Paginator, command, group, has_any_role
 
@@ -117,9 +117,9 @@ class Information(Cog):
                 parsed_roles.add(role_name)
                 continue
 
-            match = fuzzywuzzy.process.extractOne(
+            match = rapidfuzz.process.extractOne(
                 role_name, all_roles, score_cutoff=80,
-                scorer=fuzzywuzzy.fuzz.ratio
+                scorer=rapidfuzz.fuzz.ratio
             )
 
             if not match:
@@ -241,8 +241,6 @@ class Information(Cog):
             if is_set and (emoji := getattr(constants.Emojis, f"badge_{badge}", None)):
                 badges.append(emoji)
 
-        activity = await self.user_messages(user)
-
         if on_server:
             joined = time_since(user.joined_at, max_units=3)
             roles = ", ".join(role.mention for role in user.roles[1:])
@@ -272,8 +270,7 @@ class Information(Cog):
 
         # Show more verbose output in moderation channels for infractions and nominations
         if is_mod_channel(ctx.channel):
-            fields.append(activity)
-
+            fields.append(await self.user_messages(user))
             fields.append(await self.expanded_user_infraction_counts(user))
             fields.append(await self.user_nomination_counts(user))
         else:
diff --git a/bot/exts/moderation/infraction/_scheduler.py b/bot/exts/moderation/infraction/_scheduler.py
index 988fb7220..8286d3635 100644
--- a/bot/exts/moderation/infraction/_scheduler.py
+++ b/bot/exts/moderation/infraction/_scheduler.py
@@ -47,12 +47,33 @@ class InfractionScheduler:
         log.trace(f"Rescheduling infractions for {self.__class__.__name__}.")
 
         infractions = await self.bot.api_client.get(
-            'bot/infractions',
-            params={'active': 'true'}
+            "bot/infractions",
+            params={
+                "active": "true",
+                "ordering": "expires_at",
+                "permanent": "false",
+                "types": ",".join(supported_infractions),
+            },
         )
-        for infraction in infractions:
-            if infraction["expires_at"] is not None and infraction["type"] in supported_infractions:
-                self.schedule_expiration(infraction)
+
+        to_schedule = [i for i in infractions if i["id"] not in self.scheduler]
+
+        for infraction in to_schedule:
+            log.trace("Scheduling %r", infraction)
+            self.schedule_expiration(infraction)
+
+        # Call ourselves again when the last infraction would expire. This will be the "oldest" infraction we've seen
+        # from the database so far, and new ones are scheduled as part of application.
+        # We make sure to fire this
+        if to_schedule:
+            next_reschedule_point = max(
+                dateutil.parser.isoparse(infr["expires_at"]).replace(tzinfo=None) for infr in to_schedule
+            )
+            log.trace("Will reschedule remaining infractions at %s", next_reschedule_point)
+
+            self.scheduler.schedule_at(next_reschedule_point, -1, self.reschedule_infractions(supported_infractions))
+
+        log.trace("Done rescheduling")
 
     async def reapply_infraction(
         self,
diff --git a/bot/exts/moderation/infraction/_utils.py b/bot/exts/moderation/infraction/_utils.py
index a98b4828b..adbc641fa 100644
--- a/bot/exts/moderation/infraction/_utils.py
+++ b/bot/exts/moderation/infraction/_utils.py
@@ -7,7 +7,7 @@ from discord.ext.commands import Context
 
 from bot.api import ResponseCodeError
 from bot.constants import Colours, Icons
-from bot.errors import InvalidInfractedUser
+from bot.errors import InvalidInfractedUserError
 
 log = logging.getLogger(__name__)
 
@@ -85,7 +85,7 @@ async def post_infraction(
     """Posts an infraction to the API."""
     if isinstance(user, (discord.Member, discord.User)) and user.bot:
         log.trace(f"Posting of {infr_type} infraction for {user} to the API aborted. User is a bot.")
-        raise InvalidInfractedUser(user)
+        raise InvalidInfractedUserError(user)
 
     log.trace(f"Posting {infr_type} infraction for {user} to the API.")
 
@@ -164,7 +164,7 @@ async def notify_infraction(
 
     text = INFRACTION_DESCRIPTION_TEMPLATE.format(
         type=infr_type.title(),
-        expires=expires_at or "N/A",
+        expires=f"{expires_at} UTC" if expires_at else "N/A",
         reason=reason or "No reason provided."
     )
 
diff --git a/bot/exts/moderation/silence.py b/bot/exts/moderation/silence.py
index 2a7ca932e..8025f3df6 100644
--- a/bot/exts/moderation/silence.py
+++ b/bot/exts/moderation/silence.py
@@ -1,36 +1,46 @@
 import json
 import logging
+import typing
 from contextlib import suppress
 from datetime import datetime, timedelta, timezone
-from operator import attrgetter
-from typing import Optional
+from typing import Optional, OrderedDict, Union
 
 from async_rediscache import RedisCache
-from discord import TextChannel
+from discord import Guild, PermissionOverwrite, TextChannel, VoiceChannel
 from discord.ext import commands, tasks
 from discord.ext.commands import Context
 
+from bot import constants
 from bot.bot import Bot
-from bot.constants import Channels, Emojis, Guild, MODERATION_ROLES, Roles
 from bot.converters import HushDurationConverter
-from bot.utils.lock import LockedResourceError, lock_arg
+from bot.utils.lock import LockedResourceError, lock, lock_arg
 from bot.utils.scheduling import Scheduler
 
 log = logging.getLogger(__name__)
 
 LOCK_NAMESPACE = "silence"
 
-MSG_SILENCE_FAIL = f"{Emojis.cross_mark} current channel is already silenced."
-MSG_SILENCE_PERMANENT = f"{Emojis.check_mark} silenced current channel indefinitely."
-MSG_SILENCE_SUCCESS = f"{Emojis.check_mark} silenced current channel for {{duration}} minute(s)."
+MSG_SILENCE_FAIL = f"{constants.Emojis.cross_mark} {{channel}} is already silenced."
+MSG_SILENCE_PERMANENT = f"{constants.Emojis.check_mark} silenced {{channel}} indefinitely."
+MSG_SILENCE_SUCCESS = f"{constants.Emojis.check_mark} silenced {{{{channel}}}} for {{duration}} minute(s)."
 
-MSG_UNSILENCE_FAIL = f"{Emojis.cross_mark} current channel was not silenced."
+MSG_UNSILENCE_FAIL = f"{constants.Emojis.cross_mark} {{channel}} was not silenced."
 MSG_UNSILENCE_MANUAL = (
-    f"{Emojis.cross_mark} current channel was not unsilenced because the current overwrites were "
+    f"{constants.Emojis.cross_mark} {{channel}} was not unsilenced because the current overwrites were "
     f"set manually or the cache was prematurely cleared. "
     f"Please edit the overwrites manually to unsilence."
 )
-MSG_UNSILENCE_SUCCESS = f"{Emojis.check_mark} unsilenced current channel."
+MSG_UNSILENCE_SUCCESS = f"{constants.Emojis.check_mark} unsilenced {{channel}}."
+
+TextOrVoiceChannel = Union[TextChannel, VoiceChannel]
+
+VOICE_CHANNELS = {
+    constants.Channels.code_help_voice_0: constants.Channels.code_help_chat_0,
+    constants.Channels.code_help_voice_1: constants.Channels.code_help_chat_1,
+    constants.Channels.general_voice_0: constants.Channels.voice_chat_0,
+    constants.Channels.general_voice_1: constants.Channels.voice_chat_1,
+    constants.Channels.staff_voice: constants.Channels.staff_voice_chat,
+}
 
 
 class SilenceNotifier(tasks.Loop):
@@ -41,7 +51,7 @@ class SilenceNotifier(tasks.Loop):
         self._silenced_channels = {}
         self._alert_channel = alert_channel
 
-    def add_channel(self, channel: TextChannel) -> None:
+    def add_channel(self, channel: TextOrVoiceChannel) -> None:
         """Add channel to `_silenced_channels` and start loop if not launched."""
         if not self._silenced_channels:
             self.start()
@@ -68,7 +78,15 @@ class SilenceNotifier(tasks.Loop):
                 f"{channel.mention} for {(self._current_loop-start)//60} min"
                 for channel, start in self._silenced_channels.items()
             )
-            await self._alert_channel.send(f"<@&{Roles.moderators}> currently silenced channels: {channels_text}")
+            await self._alert_channel.send(
+                f"<@&{constants.Roles.moderators}> currently silenced channels: {channels_text}"
+            )
+
+
+async def _select_lock_channel(args: OrderedDict[str, any]) -> TextOrVoiceChannel:
+    """Passes the channel to be silenced to the resource lock."""
+    channel, _ = Silence.parse_silence_args(args["ctx"], args["duration_or_channel"], args["duration"])
+    return channel
 
 
 class Silence(commands.Cog):
@@ -92,88 +110,192 @@ class Silence(commands.Cog):
         """Set instance attributes once the guild is available and reschedule unsilences."""
         await self.bot.wait_until_guild_available()
 
-        guild = self.bot.get_guild(Guild.id)
+        guild = self.bot.get_guild(constants.Guild.id)
+
         self._everyone_role = guild.default_role
-        self._mod_alerts_channel = self.bot.get_channel(Channels.mod_alerts)
-        self.notifier = SilenceNotifier(self.bot.get_channel(Channels.mod_log))
+        self._verified_voice_role = guild.get_role(constants.Roles.voice_verified)
+
+        self._mod_alerts_channel = self.bot.get_channel(constants.Channels.mod_alerts)
+
+        self.notifier = SilenceNotifier(self.bot.get_channel(constants.Channels.mod_log))
         await self._reschedule()
 
+    async def send_message(
+        self,
+        message: str,
+        source_channel: TextChannel,
+        target_channel: TextOrVoiceChannel,
+        *,
+        alert_target: bool = False
+    ) -> None:
+        """Helper function to send message confirmation to `source_channel`, and notification to `target_channel`."""
+        # Reply to invocation channel
+        source_reply = message
+        if source_channel != target_channel:
+            source_reply = source_reply.format(channel=target_channel.mention)
+        else:
+            source_reply = source_reply.format(channel="current channel")
+        await source_channel.send(source_reply)
+
+        # Reply to target channel
+        if alert_target:
+            if isinstance(target_channel, VoiceChannel):
+                voice_chat = self.bot.get_channel(VOICE_CHANNELS.get(target_channel.id))
+                if voice_chat and source_channel != voice_chat:
+                    await voice_chat.send(message.format(channel=target_channel.mention))
+
+            elif source_channel != target_channel:
+                await target_channel.send(message.format(channel="current channel"))
+
     @commands.command(aliases=("hush",))
-    @lock_arg(LOCK_NAMESPACE, "ctx", attrgetter("channel"), raise_error=True)
-    async def silence(self, ctx: Context, duration: HushDurationConverter = 10) -> None:
+    @lock(LOCK_NAMESPACE, _select_lock_channel, raise_error=True)
+    async def silence(
+        self,
+        ctx: Context,
+        duration_or_channel: typing.Union[TextOrVoiceChannel, HushDurationConverter] = None,
+        duration: HushDurationConverter = 10,
+        *,
+        kick: bool = False
+    ) -> None:
         """
         Silence the current channel for `duration` minutes or `forever`.
 
         Duration is capped at 15 minutes, passing forever makes the silence indefinite.
         Indefinitely silenced channels get added to a notifier which posts notices every 15 minutes from the start.
+
+        Passing a voice channel will attempt to move members out of the channel and back to force sync permissions.
+        If `kick` is True, members will not be added back to the voice channel, and members will be unable to rejoin.
         """
         await self._init_task
+        channel, duration = self.parse_silence_args(ctx, duration_or_channel, duration)
 
-        channel_info = f"#{ctx.channel} ({ctx.channel.id})"
+        channel_info = f"#{channel} ({channel.id})"
         log.debug(f"{ctx.author} is silencing channel {channel_info}.")
 
-        if not await self._set_silence_overwrites(ctx.channel):
+        if not await self._set_silence_overwrites(channel, kick=kick):
             log.info(f"Tried to silence channel {channel_info} but the channel was already silenced.")
-            await ctx.send(MSG_SILENCE_FAIL)
+            await self.send_message(MSG_SILENCE_FAIL, ctx.channel, channel, alert_target=False)
             return
 
-        await self._schedule_unsilence(ctx, duration)
+        if isinstance(channel, VoiceChannel):
+            if kick:
+                await self._kick_voice_members(channel)
+            else:
+                await self._force_voice_sync(channel)
+
+        await self._schedule_unsilence(ctx, channel, duration)
 
         if duration is None:
-            self.notifier.add_channel(ctx.channel)
+            self.notifier.add_channel(channel)
             log.info(f"Silenced {channel_info} indefinitely.")
-            await ctx.send(MSG_SILENCE_PERMANENT)
+            await self.send_message(MSG_SILENCE_PERMANENT, ctx.channel, channel, alert_target=True)
+
         else:
             log.info(f"Silenced {channel_info} for {duration} minute(s).")
-            await ctx.send(MSG_SILENCE_SUCCESS.format(duration=duration))
-
-    @commands.command(aliases=("unhush",))
-    async def unsilence(self, ctx: Context) -> None:
-        """
-        Unsilence the current channel.
-
-        If the channel was silenced indefinitely, notifications for the channel will stop.
-        """
-        await self._init_task
-        log.debug(f"Unsilencing channel #{ctx.channel} from {ctx.author}'s command.")
-        await self._unsilence_wrapper(ctx.channel)
-
-    @lock_arg(LOCK_NAMESPACE, "channel", raise_error=True)
-    async def _unsilence_wrapper(self, channel: TextChannel) -> None:
-        """Unsilence `channel` and send a success/failure message."""
-        if not await self._unsilence(channel):
-            overwrite = channel.overwrites_for(self._everyone_role)
-            if overwrite.send_messages is False or overwrite.add_reactions is False:
-                await channel.send(MSG_UNSILENCE_MANUAL)
+            formatted_message = MSG_SILENCE_SUCCESS.format(duration=duration)
+            await self.send_message(formatted_message, ctx.channel, channel, alert_target=True)
+
+    @staticmethod
+    def parse_silence_args(
+        ctx: Context,
+        duration_or_channel: typing.Union[TextOrVoiceChannel, int],
+        duration: HushDurationConverter
+    ) -> typing.Tuple[TextOrVoiceChannel, Optional[int]]:
+        """Helper method to parse the arguments of the silence command."""
+        duration: Optional[int]
+
+        if duration_or_channel:
+            if isinstance(duration_or_channel, (TextChannel, VoiceChannel)):
+                channel = duration_or_channel
             else:
-                await channel.send(MSG_UNSILENCE_FAIL)
+                channel = ctx.channel
+                duration = duration_or_channel
         else:
-            await channel.send(MSG_UNSILENCE_SUCCESS)
+            channel = ctx.channel
+
+        if duration == -1:
+            duration = None
 
-    async def _set_silence_overwrites(self, channel: TextChannel) -> bool:
+        return channel, duration
+
+    async def _set_silence_overwrites(self, channel: TextOrVoiceChannel, *, kick: bool = False) -> bool:
         """Set silence permission overwrites for `channel` and return True if successful."""
-        overwrite = channel.overwrites_for(self._everyone_role)
-        prev_overwrites = dict(send_messages=overwrite.send_messages, add_reactions=overwrite.add_reactions)
+        # Get the original channel overwrites
+        if isinstance(channel, TextChannel):
+            role = self._everyone_role
+            overwrite = channel.overwrites_for(role)
+            prev_overwrites = dict(send_messages=overwrite.send_messages, add_reactions=overwrite.add_reactions)
+
+        else:
+            role = self._verified_voice_role
+            overwrite = channel.overwrites_for(role)
+            prev_overwrites = dict(speak=overwrite.speak)
+            if kick:
+                prev_overwrites.update(connect=overwrite.connect)
 
+        # Stop if channel was already silenced
         if channel.id in self.scheduler or all(val is False for val in prev_overwrites.values()):
             return False
 
-        overwrite.update(send_messages=False, add_reactions=False)
-        await channel.set_permissions(self._everyone_role, overwrite=overwrite)
+        # Set new permissions, store
+        overwrite.update(**dict.fromkeys(prev_overwrites, False))
+        await channel.set_permissions(role, overwrite=overwrite)
         await self.previous_overwrites.set(channel.id, json.dumps(prev_overwrites))
 
         return True
 
-    async def _schedule_unsilence(self, ctx: Context, duration: Optional[int]) -> None:
+    async def _schedule_unsilence(self, ctx: Context, channel: TextOrVoiceChannel, duration: Optional[int]) -> None:
         """Schedule `ctx.channel` to be unsilenced if `duration` is not None."""
         if duration is None:
-            await self.unsilence_timestamps.set(ctx.channel.id, -1)
+            await self.unsilence_timestamps.set(channel.id, -1)
         else:
-            self.scheduler.schedule_later(duration * 60, ctx.channel.id, ctx.invoke(self.unsilence))
+            self.scheduler.schedule_later(duration * 60, channel.id, ctx.invoke(self.unsilence, channel=channel))
             unsilence_time = datetime.now(tz=timezone.utc) + timedelta(minutes=duration)
-            await self.unsilence_timestamps.set(ctx.channel.id, unsilence_time.timestamp())
+            await self.unsilence_timestamps.set(channel.id, unsilence_time.timestamp())
 
-    async def _unsilence(self, channel: TextChannel) -> bool:
+    @commands.command(aliases=("unhush",))
+    async def unsilence(self, ctx: Context, *, channel: TextOrVoiceChannel = None) -> None:
+        """
+        Unsilence the given channel if given, else the current one.
+
+        If the channel was silenced indefinitely, notifications for the channel will stop.
+        """
+        await self._init_task
+        if channel is None:
+            channel = ctx.channel
+        log.debug(f"Unsilencing channel #{channel} from {ctx.author}'s command.")
+        await self._unsilence_wrapper(channel, ctx)
+
+    @lock_arg(LOCK_NAMESPACE, "channel", raise_error=True)
+    async def _unsilence_wrapper(self, channel: TextOrVoiceChannel, ctx: Optional[Context] = None) -> None:
+        """
+        Unsilence `channel` and send a success/failure message to ctx.channel.
+
+        If ctx is None or not passed, `channel` is used in its place.
+        If `channel` and ctx.channel are the same, only one message is sent.
+        """
+        msg_channel = channel
+        if ctx is not None:
+            msg_channel = ctx.channel
+
+        if not await self._unsilence(channel):
+            if isinstance(channel, VoiceChannel):
+                overwrite = channel.overwrites_for(self._verified_voice_role)
+                has_channel_overwrites = overwrite.speak is False
+            else:
+                overwrite = channel.overwrites_for(self._everyone_role)
+                has_channel_overwrites = overwrite.send_messages is False or overwrite.add_reactions is False
+
+            # Send fail message to muted channel or voice chat channel, and invocation channel
+            if has_channel_overwrites:
+                await self.send_message(MSG_UNSILENCE_MANUAL, msg_channel, channel, alert_target=False)
+            else:
+                await self.send_message(MSG_UNSILENCE_FAIL, msg_channel, channel, alert_target=False)
+
+        else:
+            await self.send_message(MSG_UNSILENCE_SUCCESS, msg_channel, channel, alert_target=True)
+
+    async def _unsilence(self, channel: TextOrVoiceChannel) -> bool:
         """
         Unsilence `channel`.
 
@@ -183,19 +305,34 @@ class Silence(commands.Cog):
 
         Return `True` if channel permissions were changed, `False` otherwise.
         """
+        # Get stored overwrites, and return if channel is unsilenced
         prev_overwrites = await self.previous_overwrites.get(channel.id)
         if channel.id not in self.scheduler and prev_overwrites is None:
             log.info(f"Tried to unsilence channel #{channel} ({channel.id}) but the channel was not silenced.")
             return False
 
-        overwrite = channel.overwrites_for(self._everyone_role)
+        # Select the role based on channel type, and get current overwrites
+        if isinstance(channel, TextChannel):
+            role = self._everyone_role
+            overwrite = channel.overwrites_for(role)
+            permissions = "`Send Messages` and `Add Reactions`"
+        else:
+            role = self._verified_voice_role
+            overwrite = channel.overwrites_for(role)
+            permissions = "`Speak` and `Connect`"
+
+        # Check if old overwrites were not stored
         if prev_overwrites is None:
             log.info(f"Missing previous overwrites for #{channel} ({channel.id}); defaulting to None.")
-            overwrite.update(send_messages=None, add_reactions=None)
+            overwrite.update(send_messages=None, add_reactions=None, speak=None, connect=None)
         else:
             overwrite.update(**json.loads(prev_overwrites))
 
-        await channel.set_permissions(self._everyone_role, overwrite=overwrite)
+        # Update Permissions
+        await channel.set_permissions(role, overwrite=overwrite)
+        if isinstance(channel, VoiceChannel):
+            await self._force_voice_sync(channel)
+
         log.info(f"Unsilenced channel #{channel} ({channel.id}).")
 
         self.scheduler.cancel(channel.id)
@@ -203,15 +340,81 @@ class Silence(commands.Cog):
         await self.previous_overwrites.delete(channel.id)
         await self.unsilence_timestamps.delete(channel.id)
 
+        # Alert Admin team if old overwrites were not available
         if prev_overwrites is None:
             await self._mod_alerts_channel.send(
-                f"<@&{Roles.admins}> Restored overwrites with default values after unsilencing "
-                f"{channel.mention}. Please check that the `Send Messages` and `Add Reactions` "
-                f"overwrites for {self._everyone_role.mention} are at their desired values."
+                f"<@&{constants.Roles.admins}> Restored overwrites with default values after unsilencing "
+                f"{channel.mention}. Please check that the {permissions} "
+                f"overwrites for {role.mention} are at their desired values."
             )
 
         return True
 
+    @staticmethod
+    async def _get_afk_channel(guild: Guild) -> VoiceChannel:
+        """Get a guild's AFK channel, or create one if it does not exist."""
+        afk_channel = guild.afk_channel
+
+        if afk_channel is None:
+            overwrites = {
+                guild.default_role: PermissionOverwrite(speak=False, connect=False, view_channel=False)
+            }
+            afk_channel = await guild.create_voice_channel("mute-temp", overwrites=overwrites)
+            log.info(f"Failed to get afk-channel, created #{afk_channel} ({afk_channel.id})")
+
+        return afk_channel
+
+    @staticmethod
+    async def _kick_voice_members(channel: VoiceChannel) -> None:
+        """Remove all non-staff members from a voice channel."""
+        log.debug(f"Removing all non staff members from #{channel.name} ({channel.id}).")
+
+        for member in channel.members:
+            # Skip staff
+            if any(role.id in constants.MODERATION_ROLES for role in member.roles):
+                continue
+
+            try:
+                await member.move_to(None, reason="Kicking member from voice channel.")
+                log.trace(f"Kicked {member.name} from voice channel.")
+            except Exception as e:
+                log.debug(f"Failed to move {member.name}. Reason: {e}")
+                continue
+
+        log.debug("Removed all members.")
+
+    async def _force_voice_sync(self, channel: VoiceChannel) -> None:
+        """
+        Move all non-staff members from `channel` to a temporary channel and back to force toggle role mute.
+
+        Permission modification has to happen before this function.
+        """
+        # Obtain temporary channel
+        delete_channel = channel.guild.afk_channel is None
+        afk_channel = await self._get_afk_channel(channel.guild)
+
+        try:
+            # Move all members to temporary channel and back
+            for member in channel.members:
+                # Skip staff
+                if any(role.id in constants.MODERATION_ROLES for role in member.roles):
+                    continue
+
+                try:
+                    await member.move_to(afk_channel, reason="Muting VC member.")
+                    log.trace(f"Moved {member.name} to afk channel.")
+
+                    await member.move_to(channel, reason="Muting VC member.")
+                    log.trace(f"Moved {member.name} to original voice channel.")
+                except Exception as e:
+                    log.debug(f"Failed to move {member.name}. Reason: {e}")
+                    continue
+
+        finally:
+            # Delete VC channel if it was created.
+            if delete_channel:
+                await afk_channel.delete(reason="Deleting temporary mute channel.")
+
     async def _reschedule(self) -> None:
         """Reschedule unsilencing of active silences and add permanent ones to the notifier."""
         for channel_id, timestamp in await self.unsilence_timestamps.items():
@@ -247,7 +450,7 @@ class Silence(commands.Cog):
     # This cannot be static (must have a __func__ attribute).
     async def cog_check(self, ctx: Context) -> bool:
         """Only allow moderators to invoke the commands in this cog."""
-        return await commands.has_any_role(*MODERATION_ROLES).predicate(ctx)
+        return await commands.has_any_role(*constants.MODERATION_ROLES).predicate(ctx)
 
 
 def setup(bot: Bot) -> None:
diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index 0cbce6a51..8494a1e2e 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -8,6 +8,7 @@ from async_rediscache import RedisCache
 from discord import Colour, Member, VoiceState
 from discord.ext.commands import Cog, Context, command
 
+
 from bot.api import ResponseCodeError
 from bot.bot import Bot
 from bot.constants import Channels, Event, MODERATION_ROLES, Roles, VoiceGate as GateConf
@@ -40,6 +41,12 @@ VOICE_PING = (
     "If you don't yet qualify, you'll be told why!"
 )
 
+VOICE_PING_DM = (
+    "Wondering why you can't talk in the voice channels? "
+    "Use the `!voiceverify` command in {channel_mention} to verify. "
+    "If you don't yet qualify, you'll be told why!"
+)
+
 
 class VoiceGate(Cog):
     """Voice channels verification management."""
@@ -75,37 +82,43 @@ class VoiceGate(Cog):
             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:
+    async def _ping_newcomer(self, member: discord.Member) -> tuple:
         """
         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:
+        Returns (False, None) 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.
+        Otherwise, the notification message ID is stored in `redis_cache` and return (True, channel).
+        channel is either [discord.TextChannel, discord.DMChannel].
         """
         if await self.redis_cache.contains(member.id):
             log.trace("User already in cache. Ignore.")
-            return False
+            return False, 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, NO_MSG)
-            return False
+            return False, None
 
         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)
+        try:
+            message = await member.send(VOICE_PING_DM.format(channel_mention=voice_verification_channel.mention))
+        except discord.Forbidden:
+            log.trace("DM failed for Voice ping message. Sending in channel.")
+            message = await voice_verification_channel.send(f"Hello, {member.mention}! {VOICE_PING}")
 
-        return True
+        await self.redis_cache.set(member.id, message.id)
+        return True, message.channel
 
-    @command(aliases=('voiceverify',))
+    @command(aliases=("voiceverify", "voice-verify",))
     @has_no_roles(Roles.voice_verified)
     @in_whitelist(channels=(Channels.voice_gate,), redirect=None)
     async def voice_verify(self, ctx: Context, *_) -> None:
@@ -144,8 +157,12 @@ class VoiceGate(Cog):
                     color=Colour.red()
                 )
                 log.warning(f"Got response code {e.status} while trying to get {ctx.author.id} Metricity data.")
+            try:
+                await ctx.author.send(embed=embed)
+            except discord.Forbidden:
+                log.info("Could not send user DM. Sending in voice-verify channel and scheduling delete.")
+                await ctx.send(embed=embed)
 
-            await ctx.author.send(embed=embed)
             return
 
         checks = {
@@ -237,13 +254,17 @@ class VoiceGate(Cog):
             log.trace("User not in a voice channel. Ignore.")
             return
 
+        if isinstance(after.channel, discord.StageChannel):
+            log.trace("User joined a stage channel. Ignore.")
+            return
+
         # 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)
+        notification_sent, message_channel = await self._ping_newcomer(member)
 
-        # Schedule the notification to be deleted after the configured delay, which is
+        # Schedule the channel ping notification to be deleted after the configured delay, which is
         # again delegated to an atomic helper
-        if notification_sent:
+        if notification_sent and isinstance(message_channel, discord.TextChannel):
             await asyncio.sleep(GateConf.voice_ping_delete_delay)
             await self._delete_ping(member.id)
 
diff --git a/bot/exts/moderation/watchchannels/bigbrother.py b/bot/exts/moderation/watchchannels/bigbrother.py
index 3b44056d3..c6ee844ef 100644
--- a/bot/exts/moderation/watchchannels/bigbrother.py
+++ b/bot/exts/moderation/watchchannels/bigbrother.py
@@ -94,6 +94,11 @@ class BigBrother(WatchChannel, Cog, name="Big Brother"):
             await ctx.send(f":x: {user} is already being watched.")
             return
 
+        # FetchedUser instances don't have a roles attribute
+        if hasattr(user, "roles") and any(role.id in MODERATION_ROLES for role in user.roles):
+            await ctx.send(f":x: I'm sorry {ctx.author}, I'm afraid I can't do that. I must be kind to my masters.")
+            return
+
         response = await post_infraction(ctx, user, 'watch', reason, hidden=True, active=True)
 
         if response is not None:
diff --git a/bot/exts/recruitment/talentpool/_review.py b/bot/exts/recruitment/talentpool/_review.py
index d53c3b074..0cb786e4b 100644
--- a/bot/exts/recruitment/talentpool/_review.py
+++ b/bot/exts/recruitment/talentpool/_review.py
@@ -75,7 +75,7 @@ class Reviewer:
 
     async def post_review(self, user_id: int, update_database: bool) -> None:
         """Format the review of a user and post it to the nomination voting channel."""
-        review, seen_emoji = await self.make_review(user_id)
+        review, reviewed_emoji = await self.make_review(user_id)
         if not review:
             return
 
@@ -88,8 +88,8 @@ class Reviewer:
         await pin_no_system_message(messages[0])
 
         last_message = messages[-1]
-        if seen_emoji:
-            for reaction in (seen_emoji, "\N{THUMBS UP SIGN}", "\N{THUMBS DOWN SIGN}"):
+        if reviewed_emoji:
+            for reaction in (reviewed_emoji, "\N{THUMBS UP SIGN}", "\N{THUMBS DOWN SIGN}"):
                 await last_message.add_reaction(reaction)
 
         if update_database:
@@ -97,7 +97,7 @@ class Reviewer:
             await self.bot.api_client.patch(f"{self._pool.api_endpoint}/{nomination['id']}", json={"reviewed": True})
 
     async def make_review(self, user_id: int) -> typing.Tuple[str, Optional[Emoji]]:
-        """Format a generic review of a user and return it with the seen emoji."""
+        """Format a generic review of a user and return it with the reviewed emoji."""
         log.trace(f"Formatting the review of {user_id}")
 
         # Since `watched_users` is a defaultdict, we should take care
@@ -120,21 +120,22 @@ class Reviewer:
         opening = f"<@&{Roles.mod_team}> <@&{Roles.admins}>\n{member.mention} ({member}) for Helper!"
 
         current_nominations = "\n\n".join(
-            f"**<@{entry['actor']}>:** {entry['reason'] or '*no reason given*'}" for entry in nomination['entries']
+            f"**<@{entry['actor']}>:** {entry['reason'] or '*no reason given*'}"
+            for entry in nomination['entries'][::-1]
         )
         current_nominations = f"**Nominated by:**\n{current_nominations}"
 
         review_body = await self._construct_review_body(member)
 
-        seen_emoji = self._random_ducky(guild)
+        reviewed_emoji = self._random_ducky(guild)
         vote_request = (
             "*Refer to their nomination and infraction histories for further details*.\n"
-            f"*Please react {seen_emoji} if you've seen this post."
-            " Then react :+1: for approval, or :-1: for disapproval*."
+            f"*Please react {reviewed_emoji} once you have reviewed this user,"
+            " and react :+1: for approval, or :-1: for disapproval*."
         )
 
         review = "\n\n".join((opening, current_nominations, review_body, vote_request))
-        return review, seen_emoji
+        return review, reviewed_emoji
 
     async def archive_vote(self, message: PartialMessage, passed: bool) -> None:
         """Archive this vote to #nomination-archive."""
@@ -162,7 +163,7 @@ class Reviewer:
         user_id = int(MENTION_RE.search(content).group(1))
 
         # Get reaction counts
-        seen = await count_unique_users_reaction(
+        reviewed = await count_unique_users_reaction(
             messages[0],
             lambda r: "ducky" in str(r) or str(r) == "\N{EYES}",
             count_bots=False
@@ -187,7 +188,7 @@ class Reviewer:
 
         embed_content = (
             f"{result} on {timestamp}\n"
-            f"With {seen} {Emojis.ducky_dave} {upvotes} :+1: {downvotes} :-1:\n\n"
+            f"With {reviewed} {Emojis.ducky_dave} {upvotes} :+1: {downvotes} :-1:\n\n"
             f"{stripped_content}"
         )
 
@@ -356,7 +357,7 @@ class Reviewer:
 
     @staticmethod
     def _random_ducky(guild: Guild) -> Union[Emoji, str]:
-        """Picks a random ducky emoji to be used to mark the vote as seen. If no duckies found returns :eyes:."""
+        """Picks a random ducky emoji. If no duckies found returns :eyes:."""
         duckies = [emoji for emoji in guild.emojis if emoji.name.startswith("ducky")]
         if not duckies:
             return ":eyes:"
diff --git a/bot/exts/utils/bot.py b/bot/exts/utils/bot.py
index a4c828f95..d84709616 100644
--- a/bot/exts/utils/bot.py
+++ b/bot/exts/utils/bot.py
@@ -44,6 +44,8 @@ class BotCog(Cog, name="Bot"):
         """Repeat the given message in either a specified channel or the current channel."""
         if channel is None:
             await ctx.send(text)
+        elif not channel.permissions_for(ctx.author).send_messages:
+            await ctx.send("You don't have permission to speak in that channel.")
         else:
             await channel.send(text)
 
diff --git a/bot/exts/utils/jams.py b/bot/exts/utils/jams.py
index 98fbcb303..87ae847f6 100644
--- a/bot/exts/utils/jams.py
+++ b/bot/exts/utils/jams.py
@@ -1,17 +1,19 @@
+import csv
 import logging
 import typing as t
+from collections import defaultdict
 
-from discord import CategoryChannel, Guild, Member, PermissionOverwrite, Role
+import discord
 from discord.ext import commands
-from more_itertools import unique_everseen
 
 from bot.bot import Bot
-from bot.constants import Roles
+from bot.constants import Categories, Channels, Emojis, Roles
 
 log = logging.getLogger(__name__)
 
 MAX_CHANNELS = 50
 CATEGORY_NAME = "Code Jam"
+TEAM_LEADERS_COLOUR = 0x11806a
 
 
 class CodeJams(commands.Cog):
@@ -20,124 +22,153 @@ class CodeJams(commands.Cog):
     def __init__(self, bot: Bot):
         self.bot = bot
 
-    @commands.command()
+    @commands.group()
     @commands.has_any_role(Roles.admins)
-    async def createteam(self, ctx: commands.Context, team_name: str, members: commands.Greedy[Member]) -> None:
+    async def codejam(self, ctx: commands.Context) -> None:
+        """A Group of commands for managing Code Jams."""
+        if ctx.invoked_subcommand is None:
+            await ctx.send_help(ctx.command)
+
+    @codejam.command()
+    async def create(self, ctx: commands.Context, csv_file: t.Optional[str]) -> None:
         """
-        Create team channels (voice and text) in the Code Jams category, assign roles, and add overwrites for the team.
+        Create code-jam teams from a CSV file or a link to one, specifying the team names, leaders and members.
+
+        The CSV file must have 3 columns: 'Team Name', 'Team Member Discord ID', and 'Team Leader'.
 
-        The first user passed will always be the team leader.
+        This will create the text channels for the teams, and give the team leaders their roles.
         """
-        # Ignore duplicate members
-        members = list(unique_everseen(members))
-
-        # We had a little issue during Code Jam 4 here, the greedy converter did it's job
-        # and ignored anything which wasn't a valid argument which left us with teams of
-        # two members or at some times even 1 member. This fixes that by checking that there
-        # are always 3 members in the members list.
-        if len(members) < 3:
-            await ctx.send(
-                ":no_entry_sign: One of your arguments was invalid\n"
-                f"There must be a minimum of 3 valid members in your team. Found: {len(members)}"
-                " members"
-            )
-            return
+        async with ctx.typing():
+            if csv_file:
+                async with self.bot.http_session.get(csv_file) as response:
+                    if response.status != 200:
+                        await ctx.send(f"Got a bad response from the URL: {response.status}")
+                        return
 
-        team_channel = await self.create_channels(ctx.guild, team_name, members)
-        await self.add_roles(ctx.guild, members)
+                    csv_file = await response.text()
 
-        await ctx.send(
-            f":ok_hand: Team created: {team_channel}\n"
-            f"**Team Leader:** {members[0].mention}\n"
-            f"**Team Members:** {' '.join(member.mention for member in members[1:])}"
-        )
+            elif ctx.message.attachments:
+                csv_file = (await ctx.message.attachments[0].read()).decode("utf8")
+            else:
+                raise commands.BadArgument("You must include either a CSV file or a link to one.")
+
+            teams = defaultdict(list)
+            reader = csv.DictReader(csv_file.splitlines())
+
+            for row in reader:
+                member = ctx.guild.get_member(int(row["Team Member Discord ID"]))
+
+                if member is None:
+                    log.trace(f"Got an invalid member ID: {row['Team Member Discord ID']}")
+                    continue
+
+                teams[row["Team Name"]].append((member, row["Team Leader"].upper() == "Y"))
+
+            team_leaders = await ctx.guild.create_role(name="Code Jam Team Leaders", colour=TEAM_LEADERS_COLOUR)
+
+            for team_name, members in teams.items():
+                await self.create_team_channel(ctx.guild, team_name, members, team_leaders)
 
-    async def get_category(self, guild: Guild) -> CategoryChannel:
+            await self.create_team_leader_channel(ctx.guild, team_leaders)
+            await ctx.send(f"{Emojis.check_mark} Created Code Jam with {len(teams)} teams.")
+
+    async def get_category(self, guild: discord.Guild) -> discord.CategoryChannel:
         """
         Return a code jam category.
 
         If all categories are full or none exist, create a new category.
         """
         for category in guild.categories:
-            # Need 2 available spaces: one for the text channel and one for voice.
-            if category.name == CATEGORY_NAME and MAX_CHANNELS - len(category.channels) >= 2:
+            if category.name == CATEGORY_NAME and len(category.channels) < MAX_CHANNELS:
                 return category
 
         return await self.create_category(guild)
 
-    @staticmethod
-    async def create_category(guild: Guild) -> CategoryChannel:
+    async def create_category(self, guild: discord.Guild) -> discord.CategoryChannel:
         """Create a new code jam category and return it."""
         log.info("Creating a new code jam category.")
 
         category_overwrites = {
-            guild.default_role: PermissionOverwrite(read_messages=False),
-            guild.me: PermissionOverwrite(read_messages=True)
+            guild.default_role: discord.PermissionOverwrite(read_messages=False),
+            guild.me: discord.PermissionOverwrite(read_messages=True)
         }
 
-        return await guild.create_category_channel(
+        category = await guild.create_category_channel(
             CATEGORY_NAME,
             overwrites=category_overwrites,
             reason="It's code jam time!"
         )
 
+        await self.send_status_update(
+            guild, f"Created a new category with the ID {category.id} for this Code Jam's team channels."
+        )
+
+        return category
+
     @staticmethod
-    def get_overwrites(members: t.List[Member], guild: Guild) -> t.Dict[t.Union[Member, Role], PermissionOverwrite]:
+    def get_overwrites(
+        members: list[tuple[discord.Member, bool]],
+        guild: discord.Guild,
+    ) -> dict[t.Union[discord.Member, discord.Role], discord.PermissionOverwrite]:
         """Get code jam team channels permission overwrites."""
-        # First member is always the team leader
         team_channel_overwrites = {
-            members[0]: PermissionOverwrite(
-                manage_messages=True,
-                read_messages=True,
-                manage_webhooks=True,
-                connect=True
-            ),
-            guild.default_role: PermissionOverwrite(read_messages=False, connect=False),
+            guild.default_role: discord.PermissionOverwrite(read_messages=False),
+            guild.get_role(Roles.code_jam_event_team): discord.PermissionOverwrite(read_messages=True)
         }
 
-        # Rest of members should just have read_messages
-        for member in members[1:]:
-            team_channel_overwrites[member] = PermissionOverwrite(
-                read_messages=True,
-                connect=True
+        for member, _ in members:
+            team_channel_overwrites[member] = discord.PermissionOverwrite(
+                read_messages=True
             )
 
         return team_channel_overwrites
 
-    async def create_channels(self, guild: Guild, team_name: str, members: t.List[Member]) -> str:
-        """Create team text and voice channels. Return the mention for the text channel."""
+    async def create_team_channel(
+        self,
+        guild: discord.Guild,
+        team_name: str,
+        members: list[tuple[discord.Member, bool]],
+        team_leaders: discord.Role
+    ) -> None:
+        """Create the team's text channel."""
+        await self.add_team_leader_roles(members, team_leaders)
+
         # Get permission overwrites and category
         team_channel_overwrites = self.get_overwrites(members, guild)
         code_jam_category = await self.get_category(guild)
 
         # Create a text channel for the team
-        team_channel = await guild.create_text_channel(
+        await code_jam_category.create_text_channel(
             team_name,
             overwrites=team_channel_overwrites,
-            category=code_jam_category
         )
 
-        # Create a voice channel for the team
-        team_voice_name = " ".join(team_name.split("-")).title()
+    async def create_team_leader_channel(self, guild: discord.Guild, team_leaders: discord.Role) -> None:
+        """Create the Team Leader Chat channel for the Code Jam team leaders."""
+        category: discord.CategoryChannel = guild.get_channel(Categories.summer_code_jam)
 
-        await guild.create_voice_channel(
-            team_voice_name,
-            overwrites=team_channel_overwrites,
-            category=code_jam_category
+        team_leaders_chat = await category.create_text_channel(
+            name="team-leaders-chat",
+            overwrites={
+                guild.default_role: discord.PermissionOverwrite(read_messages=False),
+                team_leaders: discord.PermissionOverwrite(read_messages=True)
+            }
         )
 
-        return team_channel.mention
+        await self.send_status_update(guild, f"Created {team_leaders_chat.mention} in the {category} category.")
+
+    async def send_status_update(self, guild: discord.Guild, message: str) -> None:
+        """Inform the events lead with a status update when the command is ran."""
+        channel: discord.TextChannel = guild.get_channel(Channels.code_jam_planning)
+
+        await channel.send(f"<@&{Roles.events_lead}>\n\n{message}")
 
     @staticmethod
-    async def add_roles(guild: Guild, members: t.List[Member]) -> None:
-        """Assign team leader and jammer roles."""
-        # Assign team leader role
-        await members[0].add_roles(guild.get_role(Roles.team_leaders))
-
-        # Assign rest of roles
-        jammer_role = guild.get_role(Roles.jammers)
-        for member in members:
-            await member.add_roles(jammer_role)
+    async def add_team_leader_roles(members: list[tuple[discord.Member, bool]], team_leaders: discord.Role) -> None:
+        """Assign team leader role, the jammer role and their team role."""
+        for member, is_leader in members:
+            if is_leader:
+                await member.add_roles(team_leaders)
 
 
 def setup(bot: Bot) -> None:
diff --git a/bot/exts/utils/ping.py b/bot/exts/utils/ping.py
index 750ff46d2..c6d7bd900 100644
--- a/bot/exts/utils/ping.py
+++ b/bot/exts/utils/ping.py
@@ -1,18 +1,16 @@
-import socket
-import urllib.parse
 from datetime import datetime
 
-import aioping
+from aiohttp import client_exceptions
 from discord import Embed
 from discord.ext import commands
 
 from bot.bot import Bot
-from bot.constants import Channels, Emojis, STAFF_ROLES, URLs
+from bot.constants import Channels, STAFF_ROLES, URLs
 from bot.decorators import in_whitelist
 
 DESCRIPTIONS = (
     "Command processing time",
-    "Python Discord website latency",
+    "Python Discord website status",
     "Discord API latency"
 )
 ROUND_LATENCY = 3
@@ -41,23 +39,23 @@ class Latency(commands.Cog):
             bot_ping = f"{bot_ping:.{ROUND_LATENCY}f} ms"
 
         try:
-            url = urllib.parse.urlparse(URLs.site_schema + URLs.site).hostname
-            try:
-                delay = await aioping.ping(url, family=socket.AddressFamily.AF_INET) * 1000
-                site_ping = f"{delay:.{ROUND_LATENCY}f} ms"
-            except OSError:
-                # Some machines do not have permission to run ping
-                site_ping = "Permission denied, could not ping."
+            async with self.bot.http_session.get(f"{URLs.site_api_schema}{URLs.site_api}/healthcheck") as request:
+                request.raise_for_status()
+                site_status = "Healthy"
 
-        except TimeoutError:
-            site_ping = f"{Emojis.cross_mark} Connection timed out."
+        except client_exceptions.ClientResponseError as e:
+            """The site returned an unexpected response."""
+            site_status = f"The site returned an error in the response: ({e.status}) {e}"
+        except client_exceptions.ClientConnectionError:
+            """Something went wrong with the connection."""
+            site_status = "Could not establish connection with the site."
 
         # Discord Protocol latency return value is in seconds, must be multiplied by 1000 to get milliseconds.
         discord_ping = f"{self.bot.latency * 1000:.{ROUND_LATENCY}f} ms"
 
         embed = Embed(title="Pong!")
 
-        for desc, latency in zip(DESCRIPTIONS, [bot_ping, site_ping, discord_ping]):
+        for desc, latency in zip(DESCRIPTIONS, [bot_ping, site_status, discord_ping]):
             embed.add_field(name=desc, value=latency, inline=False)
 
         await ctx.send(embed=embed)
diff --git a/bot/exts/utils/utils.py b/bot/exts/utils/utils.py
index fce767d84..dc3b3f976 100644
--- a/bot/exts/utils/utils.py
+++ b/bot/exts/utils/utils.py
@@ -40,6 +40,7 @@ If the implementation is hard to explain, it's a bad idea.
 If the implementation is easy to explain, it may be a good idea.
 Namespaces are one honking great idea -- let's do more of those!
 """
+LEADS_AND_COMMUNITY = (Roles.project_leads, Roles.domain_leads, Roles.partners, Roles.python_community)
 
 
 class Utils(Cog):
@@ -185,7 +186,7 @@ class Utils(Cog):
         )
 
     @command(aliases=("poll",))
-    @has_any_role(*MODERATION_ROLES, Roles.project_leads, Roles.domain_leads)
+    @has_any_role(*MODERATION_ROLES, *LEADS_AND_COMMUNITY)
     async def vote(self, ctx: Context, title: clean_content(fix_channel_mentions=True), *options: str) -> None:
         """
         Build a quick voting poll with matching reactions with the provided options.
diff --git a/bot/pagination.py b/bot/pagination.py
index c5c84afd9..fbab74021 100644
--- a/bot/pagination.py
+++ b/bot/pagination.py
@@ -22,7 +22,7 @@ PAGINATION_EMOJI = (FIRST_EMOJI, LEFT_EMOJI, RIGHT_EMOJI, LAST_EMOJI, DELETE_EMO
 log = logging.getLogger(__name__)
 
 
-class EmptyPaginatorEmbed(Exception):
+class EmptyPaginatorEmbedError(Exception):
     """Raised when attempting to paginate with empty contents."""
 
     pass
@@ -51,22 +51,25 @@ class LinePaginator(Paginator):
         suffix: str = '```',
         max_size: int = 2000,
         scale_to_size: int = 2000,
-        max_lines: t.Optional[int] = None
+        max_lines: t.Optional[int] = None,
+        linesep: str = "\n"
     ) -> None:
         """
         This function overrides the Paginator.__init__ from inside discord.ext.commands.
 
         It overrides in order to allow us to configure the maximum number of lines per page.
         """
-        self.prefix = prefix
-        self.suffix = suffix
-
         # Embeds that exceed 2048 characters will result in an HTTPException
         # (Discord API limit), so we've set a limit of 2000
         if max_size > 2000:
             raise ValueError(f"max_size must be <= 2,000 characters. ({max_size} > 2000)")
 
-        self.max_size = max_size - len(suffix)
+        super().__init__(
+            prefix,
+            suffix,
+            max_size - len(suffix),
+            linesep
+        )
 
         if scale_to_size < max_size:
             raise ValueError(f"scale_to_size must be >= max_size. ({scale_to_size} < {max_size})")
@@ -230,7 +233,7 @@ class LinePaginator(Paginator):
         if not lines:
             if exception_on_empty_embed:
                 log.exception("Pagination asked for empty lines iterable")
-                raise EmptyPaginatorEmbed("No lines to paginate")
+                raise EmptyPaginatorEmbedError("No lines to paginate")
 
             log.debug("No lines to add to paginator, adding '(nothing to display)' message")
             lines.append("(nothing to display)")
diff --git a/bot/resources/tags/async-await.md b/bot/resources/tags/async-await.md
new file mode 100644
index 000000000..ff71ace07
--- /dev/null
+++ b/bot/resources/tags/async-await.md
@@ -0,0 +1,28 @@
+**Concurrency in Python**
+
+Python provides the ability to run multiple tasks and coroutines simultaneously with the use of the `asyncio` library, which is included in the Python standard library.
+
+This works by running these coroutines in an event loop, where the context of which coroutine is being run is switches periodically to allow all of them to run, giving the appearance of running at the same time. This is different to using threads or processes in that all code is run in the main process and thread, although it is possible to run coroutines in threads.
+
+To call an async function we can either `await` it, or run it in an event loop which we get from `asyncio`.
+
+To create a coroutine that can be used with asyncio we need to define a function using the async keyword:
+```py
+async def main():
+    await something_awaitable()
+```
+Which means we can call `await something_awaitable()` directly from within the function. If this were a non-async function this would have raised an exception like: `SyntaxError: 'await' outside async function`
+
+To run the top level async function from outside of the event loop we can get an event loop from `asyncio`, and then use that loop to run the function:
+```py
+from asyncio import get_event_loop
+
+async def main():
+    await something_awaitable()
+
+loop = get_event_loop()
+loop.run_until_complete(main())
+```
+Note that in the `run_until_complete()` where we appear to be calling `main()`, this does not execute the code in `main`, rather it returns a `coroutine` object which is then handled and run by the event loop via `run_until_complete()`.
+
+To learn more about asyncio and its use, see the [asyncio documentation](https://docs.python.org/3/library/asyncio.html).
diff --git a/bot/resources/tags/dunder-methods.md b/bot/resources/tags/dunder-methods.md
new file mode 100644
index 000000000..be2b97b7b
--- /dev/null
+++ b/bot/resources/tags/dunder-methods.md
@@ -0,0 +1,28 @@
+**Dunder methods**
+
+Double-underscore methods, or "dunder" methods, are special methods defined in a class that are invoked implicitly. Like the name suggests, they are prefixed and suffixed with dunders. You've probably already seen some, such as the `__init__` dunder method, also known as the "constructor" of a class, which is implicitly invoked when you instantiate an instance of a class.
+
+When you create a new class, there will be default dunder methods inherited from the `object` class. However, we can override them by redefining these methods within the new class. For example, the default `__init__` method from `object` doesn't take any arguments, so we almost always override that to fit our needs.
+
+Other common dunder methods to override are `__str__` and `__repr__`. `__repr__` is the developer-friendly string representation of an object - usually the syntax to recreate it - and is implicitly called on arguments passed into the `repr` function. `__str__` is the user-friendly string representation of an object, and is called by the `str` function. Note here that, if not overriden, the default `__str__` invokes `__repr__` as a fallback.
+
+```py
+class Foo:
+    def __init__(self, value):  # constructor
+        self.value = value
+    def __str__(self):
+        return f"This is a Foo object, with a value of {self.value}!"  # string representation
+    def __repr__(self):
+        return f"Foo({self.value!r})"  # way to recreate this object
+
+
+bar = Foo(5)
+
+# print also implicitly calls __str__
+print(bar)  # Output: This is a Foo object, with a value of 5!
+
+# dev-friendly representation
+print(repr(bar))  # Output: Foo(5)
+```
+
+Another example: did you know that when you use the `<left operand> + <right operand>` syntax, you're implicitly calling `<left operand>.__add__(<right operand>)`? The same applies to other operators, and you can look at the [`operator` built-in module documentation](https://docs.python.org/3/library/operator.html) for more information!
diff --git a/bot/resources/tags/for-else.md b/bot/resources/tags/for-else.md
new file mode 100644
index 000000000..e102e4e75
--- /dev/null
+++ b/bot/resources/tags/for-else.md
@@ -0,0 +1,17 @@
+**for-else**
+
+In Python it's possible to attach an `else` clause to a for loop. The code under the `else` block will be run when the iterable is exhausted (there are no more items to iterate over). Code within the else block will **not** run if the loop is broken out using `break`.
+
+Here's an example of its usage:
+```py
+numbers = [1, 3, 5, 7, 9, 11]
+
+for number in numbers:
+    if number % 2 == 0:
+        print(f"Found an even number: {number}")
+        break
+    print(f"{number} is odd.")
+else:
+    print("All numbers are odd. How odd.")
+```
+Try running this example but with an even number in the list, see how the output changes as you do so.
diff --git a/bot/resources/tags/star-imports.md b/bot/resources/tags/star-imports.md
index 2be6aab6e..3b1b6a858 100644
--- a/bot/resources/tags/star-imports.md
+++ b/bot/resources/tags/star-imports.md
@@ -16,33 +16,24 @@ Example:
 >>> from math import *
 >>> sin(pi / 2)  # uses sin from math rather than your custom sin
 ```
-
 • Potential namespace collision. Names defined from a previous import might get shadowed by a wildcard import.
-
 • Causes ambiguity. From the example, it is unclear which `sin` function is actually being used. From the Zen of Python **[3]**: `Explicit is better than implicit.`
-
 • Makes import order significant, which they shouldn't. Certain IDE's `sort import` functionality may end up breaking code due to namespace collision.
 
 **How should you import?**
 
 • Import the module under the module's namespace (Only import the name of the module, and names defined in the module can be used by prefixing the module's name)
-
 ```python
 >>> import math
 >>> math.sin(math.pi / 2)
 ```
-
 • Explicitly import certain names from the module
-
 ```python
 >>> from math import sin, pi
 >>> sin(pi / 2)
 ```
-
 Conclusion: Namespaces are one honking great idea -- let's do more of those! *[3]*
 
 **[1]** If the module defines the variable `__all__`, the names defined in `__all__` will get imported by the wildcard import, otherwise all the names in the module get imported (except for names with a leading underscore)
-
 **[2]** [Namespaces and scopes](https://www.programiz.com/python-programming/namespace)
-
 **[3]** [Zen of Python](https://www.python.org/dev/peps/pep-0020/)
diff --git a/bot/utils/messages.py b/bot/utils/messages.py
index b6f6c1f66..d4a921161 100644
--- a/bot/utils/messages.py
+++ b/bot/utils/messages.py
@@ -54,7 +54,7 @@ def reaction_check(
         log.trace(f"Removing reaction {reaction} by {user} on {reaction.message.id}: disallowed user.")
         scheduling.create_task(
             reaction.message.remove_reaction(reaction.emoji, user),
-            HTTPException,  # Suppress the HTTPException if adding the reaction fails
+            suppressed_exceptions=(HTTPException,),
             name=f"remove_reaction-{reaction}-{reaction.message.id}-{user}"
         )
         return False
diff --git a/bot/utils/regex.py b/bot/utils/regex.py
index 0d2068f90..a8efe1446 100644
--- a/bot/utils/regex.py
+++ b/bot/utils/regex.py
@@ -5,6 +5,7 @@ INVITE_RE = re.compile(
     r"discord(?:[\.,]|dot)com(?:\/|slash)invite|"     # or discord.com/invite/
     r"discordapp(?:[\.,]|dot)com(?:\/|slash)invite|"  # or discordapp.com/invite/
     r"discord(?:[\.,]|dot)me|"                        # or discord.me
+    r"discord(?:[\.,]|dot)li|"                        # or discord.li
     r"discord(?:[\.,]|dot)io"                         # or discord.io.
     r")(?:[\/]|slash)"                                # / or 'slash'
     r"([a-zA-Z0-9\-]+)",                              # the invite code itself
diff --git a/bot/utils/scheduling.py b/bot/utils/scheduling.py
index 2dc485f24..bb83b5c0d 100644
--- a/bot/utils/scheduling.py
+++ b/bot/utils/scheduling.py
@@ -161,9 +161,22 @@ class Scheduler:
                 self._log.error(f"Error in task #{task_id} {id(done_task)}!", exc_info=exception)
 
 
-def create_task(coro: t.Awaitable, *suppressed_exceptions: t.Type[Exception], **kwargs) -> asyncio.Task:
-    """Wrapper for `asyncio.create_task` which logs exceptions raised in the task."""
-    task = asyncio.create_task(coro, **kwargs)
+def create_task(
+    coro: t.Awaitable,
+    *,
+    suppressed_exceptions: tuple[t.Type[Exception]] = (),
+    event_loop: t.Optional[asyncio.AbstractEventLoop] = None,
+    **kwargs,
+) -> asyncio.Task:
+    """
+    Wrapper for creating asyncio `Task`s which logs exceptions raised in the task.
+
+    If the loop kwarg is provided, the task is created from that event loop, otherwise the running loop is used.
+    """
+    if event_loop is not None:
+        task = event_loop.create_task(coro, **kwargs)
+    else:
+        task = asyncio.create_task(coro, **kwargs)
     task.add_done_callback(partial(_log_task_exception, suppressed_exceptions=suppressed_exceptions))
     return task
 
diff --git a/config-default.yml b/config-default.yml
index 394c51c26..811640034 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -142,6 +142,7 @@ guild:
         moderators:         &MODS_CATEGORY  749736277464842262
         modmail:            &MODMAIL        714494672835444826
         voice:                              356013253765234688
+        summer_code_jam:                    861692638540857384
 
     channels:
         # Public announcement and news channels
@@ -176,6 +177,9 @@ guild:
         user_log:                           528976905546760203
         voice_log:                          640292421988646961
 
+        # Open Source Projects
+        black_formatter:    &BLACK_FORMATTER 846434317021741086
+
         # Off-topic
         off_topic_0:    291284109232308226
         off_topic_1:    463035241142026251
@@ -185,6 +189,7 @@ guild:
         bot_commands:       &BOT_CMD        267659945086812160
         esoteric:                           470884583684964352
         voice_gate:                         764802555427029012
+        code_jam_planning:                  490217981872177157
 
         # Staff
         admins:             &ADMINS         365960823622991872
@@ -195,6 +200,7 @@ guild:
         incidents:                          714214212200562749
         incidents_archive:                  720668923636351037
         mod_alerts:                         473092532147060736
+        mods:               &MODS           305126844661760000
         nominations:                        822920136150745168
         nomination_voting:                  822853512709931008
         organisation:       &ORGANISATION   551789653284356126
@@ -208,16 +214,18 @@ guild:
 
         # Voice Channels
         admins_voice:       &ADMINS_VOICE   500734494840717332
-        code_help_voice_1:                  751592231726481530
-        code_help_voice_2:                  764232549840846858
-        general_voice:                      751591688538947646
+        code_help_voice_0:                  751592231726481530
+        code_help_voice_1:                  764232549840846858
+        general_voice_0:                    751591688538947646
+        general_voice_1:                    799641437645701151
         staff_voice:        &STAFF_VOICE    412375055910043655
 
         # Voice Chat
-        code_help_chat_1:                   755154969761677312
-        code_help_chat_2:                   766330079135268884
+        code_help_chat_0:                   755154969761677312
+        code_help_chat_1:                   766330079135268884
         staff_voice_chat:                   541638762007101470
-        voice_chat:                         412357430186344448
+        voice_chat_0:                       412357430186344448
+        voice_chat_1:                       799647045886541885
 
         # Watch
         big_brother_logs:   &BB_LOGS        468507907357409333
@@ -231,6 +239,7 @@ guild:
     moderation_channels:
         - *ADMINS
         - *ADMIN_SPAM
+        - *MODS
 
     # Modlog cog ignores events which occur in these channels
     modlog_blacklist:
@@ -244,6 +253,7 @@ guild:
     reminder_whitelist:
         - *BOT_CMD
         - *DEV_CONTRIB
+        - *BLACK_FORMATTER
 
     roles:
         announcements:                          463658397560995840
@@ -258,8 +268,10 @@ guild:
         # Staff
         admins:             &ADMINS_ROLE    267628507062992896
         core_developers:                    587606783669829632
+        code_jam_event_team:                787816728474288181
         devops:                             409416496733880320
         domain_leads:                       807415650778742785
+        events_lead:                        778361735739998228
         helpers:            &HELPERS_ROLE   267630620367257601
         moderators:         &MODS_ROLE      831776746206265384
         mod_team:           &MOD_TEAM_ROLE  267629731250176001
@@ -268,7 +280,6 @@ guild:
 
         # Code Jam
         jammers:        737249140966162473
-        team_leaders:   737250302834638889
 
         # Streaming
         video:          764245844798079016
@@ -392,7 +403,7 @@ anti_spam:
 
         chars:
             interval: 5
-            max: 3_000
+            max: 4_200
 
         discord_emojis:
             interval: 10
@@ -463,9 +474,6 @@ free:
 help_channels:
     enable: true
 
-    # Minimum interval before allowing a certain user to claim a new help channel
-    claim_minutes: 15
-
     # Roles which are allowed to use the command which makes channels dormant
     cmd_whitelist:
         - *HELPERS_ROLE
@@ -511,7 +519,7 @@ redirect_output:
 
 
 duck_pond:
-    threshold: 5
+    threshold: 7
     channel_blacklist:
         - *ANNOUNCEMENTS
         - *PYNEWS_CHANNEL
diff --git a/docker-compose.yml b/docker-compose.yml
index bdfedf5c2..0f0355dac 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -12,13 +12,13 @@ x-logging: &logging
       max-size: "10m"
 
 x-restart-policy: &restart_policy
-  restart: always
+  restart: unless-stopped
 
 services:
   postgres:
     << : *logging
     << : *restart_policy
-    image: postgres:12-alpine
+    image: postgres:13-alpine
     environment:
       POSTGRES_DB: pysite
       POSTGRES_PASSWORD: pysite
diff --git a/poetry.lock b/poetry.lock
index ba8b7af4b..dac277ed8 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -44,18 +44,6 @@ yarl = ">=1.0,<2.0"
 speedups = ["aiodns", "brotlipy", "cchardet"]
 
 [[package]]
-name = "aioping"
-version = "0.3.1"
-description = "Asyncio ping implementation"
-category = "main"
-optional = false
-python-versions = "*"
-
-[package.dependencies]
-aiodns = "*"
-async-timeout = "*"
-
-[[package]]
 name = "aioredis"
 version = "1.3.1"
 description = "asyncio (PEP 3156) Redis support"
@@ -125,6 +113,14 @@ optional = false
 python-versions = ">=3.5.3"
 
 [[package]]
+name = "atomicwrites"
+version = "1.4.0"
+description = "Atomic file writes."
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
 name = "attrs"
 version = "21.2.0"
 description = "Classes Without Boilerplate"
@@ -155,7 +151,7 @@ lxml = ["lxml"]
 
 [[package]]
 name = "certifi"
-version = "2020.12.5"
+version = "2021.5.30"
 description = "Python package for providing Mozilla's CA Bundle."
 category = "main"
 optional = false
@@ -174,7 +170,7 @@ pycparser = "*"
 
 [[package]]
 name = "cfgv"
-version = "3.2.0"
+version = "3.3.0"
 description = "Validate configuration and produce human readable error messages."
 category = "dev"
 optional = false
@@ -253,7 +249,7 @@ murmur = ["mmh3"]
 
 [[package]]
 name = "discord.py"
-version = "1.6.0"
+version = "1.7.3"
 description = "A Python wrapper for the Discord API"
 category = "main"
 optional = false
@@ -268,7 +264,7 @@ voice = ["PyNaCl (>=1.3.0,<1.5)"]
 
 [[package]]
 name = "distlib"
-version = "0.3.1"
+version = "0.3.2"
 description = "Distribution utilities"
 category = "dev"
 optional = false
@@ -294,8 +290,19 @@ python-versions = "*"
 dev = ["pytest", "coverage", "coveralls"]
 
 [[package]]
+name = "execnet"
+version = "1.9.0"
+description = "execnet: rapid multi-Python deployment"
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.extras]
+testing = ["pre-commit"]
+
+[[package]]
 name = "fakeredis"
-version = "1.5.0"
+version = "1.5.2"
 description = "Fake implementation of redis API for testing purposes."
 category = "main"
 optional = false
@@ -307,12 +314,12 @@ six = ">=1.12"
 sortedcontainers = "*"
 
 [package.extras]
-aioredis = ["aioredis"]
+aioredis = ["aioredis (<2)"]
 lua = ["lupa"]
 
 [[package]]
 name = "feedparser"
-version = "6.0.2"
+version = "6.0.8"
 description = "Universal feed parser, handles RSS 0.9x, RSS 1.0, RSS 2.0, CDF, Atom 0.3, and Atom 1.0 feeds"
 category = "main"
 optional = false
@@ -436,17 +443,6 @@ python-versions = "*"
 pycodestyle = ">=2.0.0,<3.0.0"
 
 [[package]]
-name = "fuzzywuzzy"
-version = "0.18.0"
-description = "Fuzzy string matching in python"
-category = "main"
-optional = false
-python-versions = "*"
-
-[package.extras]
-speedup = ["python-levenshtein (>=0.12)"]
-
-[[package]]
 name = "hiredis"
 version = "2.0.0"
 description = "Python wrapper for hiredis"
@@ -456,7 +452,7 @@ python-versions = ">=3.6"
 
 [[package]]
 name = "humanfriendly"
-version = "9.1"
+version = "9.2"
 description = "Human friendly output for text interfaces using Python"
 category = "main"
 optional = false
@@ -467,7 +463,7 @@ pyreadline = {version = "*", markers = "sys_platform == \"win32\""}
 
 [[package]]
 name = "identify"
-version = "2.2.4"
+version = "2.2.10"
 description = "File identification library for Python"
 category = "dev"
 optional = false
@@ -478,11 +474,19 @@ license = ["editdistance-s"]
 
 [[package]]
 name = "idna"
-version = "3.1"
+version = "2.10"
 description = "Internationalized Domain Names in Applications (IDNA)"
 category = "main"
 optional = false
-python-versions = ">=3.4"
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
+name = "iniconfig"
+version = "1.1.1"
+description = "iniconfig: brain-dead simple config-ini parsing"
+category = "dev"
+optional = false
+python-versions = "*"
 
 [[package]]
 name = "lxml"
@@ -520,7 +524,7 @@ python-versions = "*"
 
 [[package]]
 name = "more-itertools"
-version = "8.7.0"
+version = "8.8.0"
 description = "More routines for operating on iterables, beyond itertools"
 category = "main"
 optional = false
@@ -559,6 +563,17 @@ optional = false
 python-versions = ">=3.5"
 
 [[package]]
+name = "packaging"
+version = "21.0"
+description = "Core utilities for Python packages"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+pyparsing = ">=2.0.2"
+
+[[package]]
 name = "pamqp"
 version = "2.3.0"
 description = "RabbitMQ Focused AMQP low-level library"
@@ -571,18 +586,30 @@ codegen = ["lxml"]
 
 [[package]]
 name = "pep8-naming"
-version = "0.11.1"
+version = "0.12.0"
 description = "Check PEP-8 naming conventions, plugin for flake8"
 category = "dev"
 optional = false
 python-versions = "*"
 
 [package.dependencies]
+flake8 = ">=3.9.1"
 flake8-polyfill = ">=1.0.2,<2"
 
 [[package]]
+name = "pluggy"
+version = "0.13.1"
+description = "plugin and hook calling mechanisms for python"
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[package.extras]
+dev = ["pre-commit", "tox"]
+
+[[package]]
 name = "pre-commit"
-version = "2.12.1"
+version = "2.13.0"
 description = "A framework for managing and maintaining multi-language pre-commit hooks."
 category = "dev"
 optional = false
@@ -608,8 +635,16 @@ python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 test = ["ipaddress", "mock", "unittest2", "enum34", "pywin32", "wmi"]
 
 [[package]]
+name = "py"
+version = "1.10.0"
+description = "library with cross-python path, ini-parsing, io, code, log facilities"
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
 name = "pycares"
-version = "3.2.3"
+version = "4.0.0"
 description = "Python interface for c-ares"
 category = "main"
 optional = false
@@ -639,7 +674,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 
 [[package]]
 name = "pydocstyle"
-version = "6.0.0"
+version = "6.1.1"
 description = "Python docstring style checker"
 category = "dev"
 optional = false
@@ -648,6 +683,9 @@ python-versions = ">=3.6"
 [package.dependencies]
 snowballstemmer = "*"
 
+[package.extras]
+toml = ["toml"]
+
 [[package]]
 name = "pyflakes"
 version = "2.3.1"
@@ -657,6 +695,14 @@ optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 
 [[package]]
+name = "pyparsing"
+version = "2.4.7"
+description = "Python parsing module"
+category = "dev"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
 name = "pyreadline"
 version = "2.1"
 description = "A python implmementation of GNU readline."
@@ -665,6 +711,73 @@ optional = false
 python-versions = "*"
 
 [[package]]
+name = "pytest"
+version = "6.2.4"
+description = "pytest: simple powerful testing with Python"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+atomicwrites = {version = ">=1.0", markers = "sys_platform == \"win32\""}
+attrs = ">=19.2.0"
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+iniconfig = "*"
+packaging = "*"
+pluggy = ">=0.12,<1.0.0a1"
+py = ">=1.8.2"
+toml = "*"
+
+[package.extras]
+testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "requests", "xmlschema"]
+
+[[package]]
+name = "pytest-cov"
+version = "2.12.1"
+description = "Pytest plugin for measuring coverage."
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.dependencies]
+coverage = ">=5.2.1"
+pytest = ">=4.6"
+toml = "*"
+
+[package.extras]
+testing = ["fields", "hunter", "process-tests", "six", "pytest-xdist", "virtualenv"]
+
+[[package]]
+name = "pytest-forked"
+version = "1.3.0"
+description = "run tests in isolated forked subprocesses"
+category = "dev"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.dependencies]
+py = "*"
+pytest = ">=3.10"
+
+[[package]]
+name = "pytest-xdist"
+version = "2.3.0"
+description = "pytest xdist plugin for distributed testing and loop-on-failing modes"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+execnet = ">=1.1"
+psutil = {version = ">=3.0", optional = true, markers = "extra == \"psutil\""}
+pytest = ">=6.0.0"
+pytest-forked = "*"
+
+[package.extras]
+psutil = ["psutil (>=3.0)"]
+testing = ["filelock"]
+
+[[package]]
 name = "python-dateutil"
 version = "2.8.1"
 description = "Extensions to the standard Python datetime module"
@@ -710,6 +823,14 @@ optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*"
 
 [[package]]
+name = "rapidfuzz"
+version = "1.4.1"
+description = "rapid fuzzy string matching"
+category = "main"
+optional = false
+python-versions = ">=3.5"
+
+[[package]]
 name = "redis"
 version = "3.5.3"
 description = "Python client for Redis key-value store"
@@ -730,14 +851,20 @@ python-versions = "*"
 
 [[package]]
 name = "requests"
-version = "2.15.1"
+version = "2.25.1"
 description = "Python HTTP for Humans."
 category = "dev"
 optional = false
-python-versions = "*"
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.dependencies]
+certifi = ">=2017.4.17"
+chardet = ">=3.0.2,<5"
+idna = ">=2.5,<3"
+urllib3 = ">=1.21.1,<1.27"
 
 [package.extras]
-security = ["cryptography (>=1.3.4)", "idna (>=2.0.0)", "pyOpenSSL (>=0.14)"]
+security = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)"]
 socks = ["PySocks (>=1.5.6,!=1.5.7)", "win-inet-pton"]
 
 [[package]]
@@ -794,7 +921,7 @@ python-versions = "*"
 
 [[package]]
 name = "sortedcontainers"
-version = "2.3.0"
+version = "2.4.0"
 description = "Sorted Containers -- Sorted List, Sorted Dict, Sorted Set"
 category = "main"
 optional = false
@@ -847,20 +974,20 @@ python-versions = "*"
 
 [[package]]
 name = "urllib3"
-version = "1.26.4"
+version = "1.26.6"
 description = "HTTP library with thread-safe connection pooling, file post, and more."
 category = "main"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"
 
 [package.extras]
+brotli = ["brotlipy (>=0.6.0)"]
 secure = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "certifi", "ipaddress"]
 socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
-brotli = ["brotlipy (>=0.6.0)"]
 
 [[package]]
 name = "virtualenv"
-version = "20.4.6"
+version = "20.4.7"
 description = "Virtual Python Environment builder"
 category = "dev"
 optional = false
@@ -891,7 +1018,7 @@ multidict = ">=4.0"
 [metadata]
 lock-version = "1.1"
 python-versions = "3.9.*"
-content-hash = "ece3b915901a62911ff7ff4a616b3972e815c0e1c7097c8994163af13cadde0e"
+content-hash = "85160036e3b07c9d5d24a32302462591e82cc3bf3d5490b87550d9c26bc5648d"
 
 [metadata.files]
 aio-pika = [
@@ -941,10 +1068,6 @@ aiohttp = [
     {file = "aiohttp-3.7.4.post0-cp39-cp39-win_amd64.whl", hash = "sha256:02f46fc0e3c5ac58b80d4d56eb0a7c7d97fcef69ace9326289fb9f1955e65cfe"},
     {file = "aiohttp-3.7.4.post0.tar.gz", hash = "sha256:493d3299ebe5f5a7c66b9819eacdcfbbaaf1a8e84911ddffcdc48888497afecf"},
 ]
-aioping = [
-    {file = "aioping-0.3.1-py3-none-any.whl", hash = "sha256:8900ef2f5a589ba0c12aaa9c2d586f5371820d468d21b374ddb47ef5fc8f297c"},
-    {file = "aioping-0.3.1.tar.gz", hash = "sha256:f983d86acab3a04c322731ce88d42c55d04d2842565fc8532fe10c838abfd275"},
-]
 aioredis = [
     {file = "aioredis-1.3.1-py3-none-any.whl", hash = "sha256:b61808d7e97b7cd5a92ed574937a079c9387fdadd22bfbfa7ad2fd319ecc26e3"},
     {file = "aioredis-1.3.1.tar.gz", hash = "sha256:15f8af30b044c771aee6787e5ec24694c048184c7b9e54c3b60c750a4b93273a"},
@@ -969,6 +1092,10 @@ async-timeout = [
     {file = "async-timeout-3.0.1.tar.gz", hash = "sha256:0c3c816a028d47f659d6ff5c745cb2acf1f966da1fe5c19c77a70282b25f4c5f"},
     {file = "async_timeout-3.0.1-py3-none-any.whl", hash = "sha256:4291ca197d287d274d0b6cb5d6f8f8f82d434ed288f962539ff18cc9012f9ea3"},
 ]
+atomicwrites = [
+    {file = "atomicwrites-1.4.0-py2.py3-none-any.whl", hash = "sha256:6d1784dea7c0c8d4a5172b6c620f40b6e4cbfdf96d783691f2e1302a7b88e197"},
+    {file = "atomicwrites-1.4.0.tar.gz", hash = "sha256:ae70396ad1a434f9c7046fd2dd196fc04b12f9e91ffb859164193be8b6168a7a"},
+]
 attrs = [
     {file = "attrs-21.2.0-py2.py3-none-any.whl", hash = "sha256:149e90d6d8ac20db7a955ad60cf0e6881a3f20d37096140088356da6c716b0b1"},
     {file = "attrs-21.2.0.tar.gz", hash = "sha256:ef6aaac3ca6cd92904cdd0d83f629a15f18053ec84e6432106f7a4d04ae4f5fb"},
@@ -979,8 +1106,8 @@ beautifulsoup4 = [
     {file = "beautifulsoup4-4.9.3.tar.gz", hash = "sha256:84729e322ad1d5b4d25f805bfa05b902dd96450f43842c4e99067d5e1369eb25"},
 ]
 certifi = [
-    {file = "certifi-2020.12.5-py2.py3-none-any.whl", hash = "sha256:719a74fb9e33b9bd44cc7f3a8d94bc35e4049deebe19ba7d8e108280cfd59830"},
-    {file = "certifi-2020.12.5.tar.gz", hash = "sha256:1a4995114262bffbc2413b159f2a1a480c969de6e6eb13ee966d470af86af59c"},
+    {file = "certifi-2021.5.30-py2.py3-none-any.whl", hash = "sha256:50b1e4f8446b06f41be7dd6338db18e0990601dce795c2b1686458aa7e8fa7d8"},
+    {file = "certifi-2021.5.30.tar.gz", hash = "sha256:2bbf76fd432960138b3ef6dda3dde0544f27cbf8546c458e60baf371917ba9ee"},
 ]
 cffi = [
     {file = "cffi-1.14.5-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:bb89f306e5da99f4d922728ddcd6f7fcebb3241fc40edebcb7284d7514741991"},
@@ -1022,8 +1149,8 @@ cffi = [
     {file = "cffi-1.14.5.tar.gz", hash = "sha256:fd78e5fee591709f32ef6edb9a015b4aa1a5022598e36227500c8f4e02328d9c"},
 ]
 cfgv = [
-    {file = "cfgv-3.2.0-py2.py3-none-any.whl", hash = "sha256:32e43d604bbe7896fe7c248a9c2276447dbef840feb28fe20494f62af110211d"},
-    {file = "cfgv-3.2.0.tar.gz", hash = "sha256:cf22deb93d4bcf92f345a5c3cd39d3d41d6340adc60c78bbbd6588c384fda6a1"},
+    {file = "cfgv-3.3.0-py2.py3-none-any.whl", hash = "sha256:b449c9c6118fe8cca7fa5e00b9ec60ba08145d281d52164230a69211c5d597a1"},
+    {file = "cfgv-3.3.0.tar.gz", hash = "sha256:9e600479b3b99e8af981ecdfc80a0296104ee610cab48a5ae4ffd0b668650eb1"},
 ]
 chardet = [
     {file = "chardet-4.0.0-py2.py3-none-any.whl", hash = "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5"},
@@ -1100,12 +1227,12 @@ deepdiff = [
     {file = "deepdiff-4.3.2.tar.gz", hash = "sha256:91360be1d9d93b1d9c13ae9c5048fa83d9cff17a88eb30afaa0d7ff2d0fee17d"},
 ]
 "discord.py" = [
-    {file = "discord.py-1.6.0-py3-none-any.whl", hash = "sha256:3df148daf6fbcc7ab5b11042368a3cd5f7b730b62f09fb5d3cbceff59bcfbb12"},
-    {file = "discord.py-1.6.0.tar.gz", hash = "sha256:ba8be99ff1b8c616f7b6dcb700460d0222b29d4c11048e74366954c465fdd05f"},
+    {file = "discord.py-1.7.3-py3-none-any.whl", hash = "sha256:c6f64db136de0e18e090f6752ea68bdd4ab0a61b82dfe7acecefa22d6477bb0c"},
+    {file = "discord.py-1.7.3.tar.gz", hash = "sha256:462cd0fe307aef8b29cbfa8dd613e548ae4b2cb581d46da9ac0d46fb6ea19408"},
 ]
 distlib = [
-    {file = "distlib-0.3.1-py2.py3-none-any.whl", hash = "sha256:8c09de2c67b3e7deef7184574fc060ab8a793e7adbb183d942c389c8b13c52fb"},
-    {file = "distlib-0.3.1.zip", hash = "sha256:edf6116872c863e1aa9d5bb7cb5e05a022c519a4594dc703843343a9ddd9bff1"},
+    {file = "distlib-0.3.2-py2.py3-none-any.whl", hash = "sha256:23e223426b28491b1ced97dc3bbe183027419dfc7982b4fa2f05d5f3ff10711c"},
+    {file = "distlib-0.3.2.zip", hash = "sha256:106fef6dc37dd8c0e2c0a60d3fca3e77460a48907f335fa28420463a6f799736"},
 ]
 docopt = [
     {file = "docopt-0.6.2.tar.gz", hash = "sha256:49b3a825280bd66b3aa83585ef59c4a8c82f2c8a522dbe754a8bc8d08c85c491"},
@@ -1113,13 +1240,17 @@ docopt = [
 emoji = [
     {file = "emoji-0.6.0.tar.gz", hash = "sha256:e42da4f8d648f8ef10691bc246f682a1ec6b18373abfd9be10ec0b398823bd11"},
 ]
+execnet = [
+    {file = "execnet-1.9.0-py2.py3-none-any.whl", hash = "sha256:a295f7cc774947aac58dde7fdc85f4aa00c42adf5d8f5468fc630c1acf30a142"},
+    {file = "execnet-1.9.0.tar.gz", hash = "sha256:8f694f3ba9cc92cab508b152dcfe322153975c29bda272e2fd7f3f00f36e47c5"},
+]
 fakeredis = [
-    {file = "fakeredis-1.5.0-py3-none-any.whl", hash = "sha256:e0416e4941cecd3089b0d901e60c8dc3c944f6384f5e29e2261c0d3c5fa99669"},
-    {file = "fakeredis-1.5.0.tar.gz", hash = "sha256:1ac0cef767c37f51718874a33afb5413e69d132988cb6a80c6e6dbeddf8c7623"},
+    {file = "fakeredis-1.5.2-py3-none-any.whl", hash = "sha256:f1ffdb134538e6d7c909ddfb4fc5edeb4a73d0ea07245bc69b8135fbc4144b04"},
+    {file = "fakeredis-1.5.2.tar.gz", hash = "sha256:18fc1808d2ce72169d3f11acdb524a00ef96bd29970c6d34cfeb2edb3fc0c020"},
 ]
 feedparser = [
-    {file = "feedparser-6.0.2-py3-none-any.whl", hash = "sha256:f596c4b34fb3e2dc7e6ac3a8191603841e8d5d267210064e94d4238737452ddd"},
-    {file = "feedparser-6.0.2.tar.gz", hash = "sha256:1b00a105425f492f3954fd346e5b524ca9cef3a4bbf95b8809470e9857aa1074"},
+    {file = "feedparser-6.0.8-py3-none-any.whl", hash = "sha256:1b7f57841d9cf85074deb316ed2c795091a238adb79846bc46dccdaf80f9c59a"},
+    {file = "feedparser-6.0.8.tar.gz", hash = "sha256:5ce0410a05ab248c8c7cfca3a0ea2203968ee9ff4486067379af4827a59f9661"},
 ]
 filelock = [
     {file = "filelock-3.0.12-py3-none-any.whl", hash = "sha256:929b7d63ec5b7d6b71b0fa5ac14e030b3f70b75747cef1b10da9b879fef15836"},
@@ -1160,10 +1291,6 @@ flake8-tidy-imports = [
 flake8-todo = [
     {file = "flake8-todo-0.7.tar.gz", hash = "sha256:6e4c5491ff838c06fe5a771b0e95ee15fc005ca57196011011280fc834a85915"},
 ]
-fuzzywuzzy = [
-    {file = "fuzzywuzzy-0.18.0-py2.py3-none-any.whl", hash = "sha256:928244b28db720d1e0ee7587acf660ea49d7e4c632569cad4f1cd7e68a5f0993"},
-    {file = "fuzzywuzzy-0.18.0.tar.gz", hash = "sha256:45016e92264780e58972dca1b3d939ac864b78437422beecebb3095f8efd00e8"},
-]
 hiredis = [
     {file = "hiredis-2.0.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:b4c8b0bc5841e578d5fb32a16e0c305359b987b850a06964bd5a62739d688048"},
     {file = "hiredis-2.0.0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:0adea425b764a08270820531ec2218d0508f8ae15a448568109ffcae050fee26"},
@@ -1208,16 +1335,20 @@ hiredis = [
     {file = "hiredis-2.0.0.tar.gz", hash = "sha256:81d6d8e39695f2c37954d1011c0480ef7cf444d4e3ae24bc5e89ee5de360139a"},
 ]
 humanfriendly = [
-    {file = "humanfriendly-9.1-py2.py3-none-any.whl", hash = "sha256:d5c731705114b9ad673754f3317d9fa4c23212f36b29bdc4272a892eafc9bc72"},
-    {file = "humanfriendly-9.1.tar.gz", hash = "sha256:066562956639ab21ff2676d1fda0b5987e985c534fc76700a19bd54bcb81121d"},
+    {file = "humanfriendly-9.2-py2.py3-none-any.whl", hash = "sha256:332da98c24cc150efcc91b5508b19115209272bfdf4b0764a56795932f854271"},
+    {file = "humanfriendly-9.2.tar.gz", hash = "sha256:f7dba53ac7935fd0b4a2fc9a29e316ddd9ea135fb3052d3d0279d10c18ff9c48"},
 ]
 identify = [
-    {file = "identify-2.2.4-py2.py3-none-any.whl", hash = "sha256:ad9f3fa0c2316618dc4d840f627d474ab6de106392a4f00221820200f490f5a8"},
-    {file = "identify-2.2.4.tar.gz", hash = "sha256:9bcc312d4e2fa96c7abebcdfb1119563b511b5e3985ac52f60d9116277865b2e"},
+    {file = "identify-2.2.10-py2.py3-none-any.whl", hash = "sha256:18d0c531ee3dbc112fa6181f34faa179de3f57ea57ae2899754f16a7e0ff6421"},
+    {file = "identify-2.2.10.tar.gz", hash = "sha256:5b41f71471bc738e7b586308c3fca172f78940195cb3bf6734c1e66fdac49306"},
 ]
 idna = [
-    {file = "idna-3.1-py3-none-any.whl", hash = "sha256:5205d03e7bcbb919cc9c19885f9920d622ca52448306f2377daede5cf3faac16"},
-    {file = "idna-3.1.tar.gz", hash = "sha256:c5b02147e01ea9920e6b0a3f1f7bb833612d507592c837a6c49552768f4054e1"},
+    {file = "idna-2.10-py2.py3-none-any.whl", hash = "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0"},
+    {file = "idna-2.10.tar.gz", hash = "sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6"},
+]
+iniconfig = [
+    {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"},
+    {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"},
 ]
 lxml = [
     {file = "lxml-4.6.3-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:df7c53783a46febb0e70f6b05df2ba104610f2fb0d27023409734a3ecbb78fb2"},
@@ -1276,8 +1407,8 @@ mccabe = [
     {file = "mccabe-0.6.1.tar.gz", hash = "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"},
 ]
 more-itertools = [
-    {file = "more-itertools-8.7.0.tar.gz", hash = "sha256:c5d6da9ca3ff65220c3bfd2a8db06d698f05d4d2b9be57e1deb2be5a45019713"},
-    {file = "more_itertools-8.7.0-py3-none-any.whl", hash = "sha256:5652a9ac72209ed7df8d9c15daf4e1aa0e3d2ccd3c87f8265a0673cd9cbc9ced"},
+    {file = "more-itertools-8.8.0.tar.gz", hash = "sha256:83f0308e05477c68f56ea3a888172c78ed5d5b3c282addb67508e7ba6c8f813a"},
+    {file = "more_itertools-8.8.0-py3-none-any.whl", hash = "sha256:2cf89ec599962f2ddc4d568a05defc40e0a587fbc10d5989713638864c36be4d"},
 ]
 mslex = [
     {file = "mslex-0.3.0-py2.py3-none-any.whl", hash = "sha256:380cb14abf8fabf40e56df5c8b21a6d533dc5cbdcfe42406bbf08dda8f42e42a"},
@@ -1329,17 +1460,25 @@ nodeenv = [
 ordered-set = [
     {file = "ordered-set-4.0.2.tar.gz", hash = "sha256:ba93b2df055bca202116ec44b9bead3df33ea63a7d5827ff8e16738b97f33a95"},
 ]
+packaging = [
+    {file = "packaging-21.0-py3-none-any.whl", hash = "sha256:c86254f9220d55e31cc94d69bade760f0847da8000def4dfe1c6b872fd14ff14"},
+    {file = "packaging-21.0.tar.gz", hash = "sha256:7dc96269f53a4ccec5c0670940a4281106dd0bb343f47b7471f779df49c2fbe7"},
+]
 pamqp = [
     {file = "pamqp-2.3.0-py2.py3-none-any.whl", hash = "sha256:2f81b5c186f668a67f165193925b6bfd83db4363a6222f599517f29ecee60b02"},
     {file = "pamqp-2.3.0.tar.gz", hash = "sha256:5cd0f5a85e89f20d5f8e19285a1507788031cfca4a9ea6f067e3cf18f5e294e8"},
 ]
 pep8-naming = [
-    {file = "pep8-naming-0.11.1.tar.gz", hash = "sha256:a1dd47dd243adfe8a83616e27cf03164960b507530f155db94e10b36a6cd6724"},
-    {file = "pep8_naming-0.11.1-py2.py3-none-any.whl", hash = "sha256:f43bfe3eea7e0d73e8b5d07d6407ab47f2476ccaeff6937c84275cd30b016738"},
+    {file = "pep8-naming-0.12.0.tar.gz", hash = "sha256:1f9a3ecb2f3fd83240fd40afdd70acc89695c49c333413e49788f93b61827e12"},
+    {file = "pep8_naming-0.12.0-py2.py3-none-any.whl", hash = "sha256:2321ac2b7bf55383dd19a6a9c8ae2ebf05679699927a3af33e60dd7d337099d3"},
+]
+pluggy = [
+    {file = "pluggy-0.13.1-py2.py3-none-any.whl", hash = "sha256:966c145cd83c96502c3c3868f50408687b38434af77734af1e9ca461a4081d2d"},
+    {file = "pluggy-0.13.1.tar.gz", hash = "sha256:15b2acde666561e1298d71b523007ed7364de07029219b604cf808bfa1c765b0"},
 ]
 pre-commit = [
-    {file = "pre_commit-2.12.1-py2.py3-none-any.whl", hash = "sha256:70c5ec1f30406250b706eda35e868b87e3e4ba099af8787e3e8b4b01e84f4712"},
-    {file = "pre_commit-2.12.1.tar.gz", hash = "sha256:900d3c7e1bf4cf0374bb2893c24c23304952181405b4d88c9c40b72bda1bb8a9"},
+    {file = "pre_commit-2.13.0-py2.py3-none-any.whl", hash = "sha256:b679d0fddd5b9d6d98783ae5f10fd0c4c59954f375b70a58cbe1ce9bcf9809a4"},
+    {file = "pre_commit-2.13.0.tar.gz", hash = "sha256:764972c60693dc668ba8e86eb29654ec3144501310f7198742a767bec385a378"},
 ]
 psutil = [
     {file = "psutil-5.8.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:0066a82f7b1b37d334e68697faba68e5ad5e858279fd6351c8ca6024e8d6ba64"},
@@ -1371,40 +1510,44 @@ psutil = [
     {file = "psutil-5.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:f4634b033faf0d968bb9220dd1c793b897ab7f1189956e1aa9eae752527127d3"},
     {file = "psutil-5.8.0.tar.gz", hash = "sha256:0c9ccb99ab76025f2f0bbecf341d4656e9c1351db8cc8a03ccd62e318ab4b5c6"},
 ]
+py = [
+    {file = "py-1.10.0-py2.py3-none-any.whl", hash = "sha256:3b80836aa6d1feeaa108e046da6423ab8f6ceda6468545ae8d02d9d58d18818a"},
+    {file = "py-1.10.0.tar.gz", hash = "sha256:21b81bda15b66ef5e1a777a21c4dcd9c20ad3efd0b3f817e7a809035269e1bd3"},
+]
 pycares = [
-    {file = "pycares-3.2.3-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:ebff743643e54aa70dce0b7098094edefd371641cf79d9c944e9f4a25e9242b0"},
-    {file = "pycares-3.2.3-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:55272411b46787936e8db475b9b6e9b81a8d8cdc253fa8779a45ef979f554fab"},
-    {file = "pycares-3.2.3-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:f33ed0e403f98e746f721aeacde917f1bdc7558cb714d713c264848bddff660f"},
-    {file = "pycares-3.2.3-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:72807e0c80b705e21c3a39347c12edf43aa4f80373bb37777facf810169372ed"},
-    {file = "pycares-3.2.3-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:a51df0a8b3eaf225e0dae3a737fd6ce6f3cb2a3bc947e884582fdda9a159d55f"},
-    {file = "pycares-3.2.3-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:663b5c7bd0f66436adac7257ee22ccfe185c3e7830b9bada3d19b79870e1d134"},
-    {file = "pycares-3.2.3-cp36-cp36m-win32.whl", hash = "sha256:c2b1e19262ce91c3288b1905b0d41f7ad0fff4b258ce37b517aa2c8d22eb82f1"},
-    {file = "pycares-3.2.3-cp36-cp36m-win_amd64.whl", hash = "sha256:e16399654a6c81cfaee2745857c119c20357b5d93de2f169f506b048b5e75d1d"},
-    {file = "pycares-3.2.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:88e5131570d7323b29866aa5ac245a9a5788d64677111daa1bde5817acdf012f"},
-    {file = "pycares-3.2.3-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:1552ffd823dc595fa8744c996926097a594f4f518d7c147657234b22cf17649d"},
-    {file = "pycares-3.2.3-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:f9e28b917373818817aca746238fcd621ec7e4ae9cbc8615f1a045e234eec298"},
-    {file = "pycares-3.2.3-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:206d5a652990f10a1f1f3f62bc23d7fe46d99c2dc4b8b8a5101e5a472986cd02"},
-    {file = "pycares-3.2.3-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:b8c9670225cdeeeb2b85ea92a807484622ca59f8f578ec73e8ec292515f35a91"},
-    {file = "pycares-3.2.3-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:6329160885fc318f80692d4d0a83a8854f9144e7a80c4f25245d0c26f11a4b84"},
-    {file = "pycares-3.2.3-cp37-cp37m-win32.whl", hash = "sha256:cd0f7fb40e1169f00b26a12793136bf5c711f155e647cd045a0ce6c98a527b57"},
-    {file = "pycares-3.2.3-cp37-cp37m-win_amd64.whl", hash = "sha256:a5d419215543d154587590d9d4485e985387ca10c7d3e1a2e5689dd6c0f20e5f"},
-    {file = "pycares-3.2.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e54f1c0642935515f27549f09486e72b6b2b1d51ad27a90ce17b760e9ce5e86d"},
-    {file = "pycares-3.2.3-cp38-cp38-manylinux1_i686.whl", hash = "sha256:6ce80eed538dd6106cd7e6136ceb3af10178d1254f07096a827c12e82e5e45c8"},
-    {file = "pycares-3.2.3-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:ed972a04067e91f552da84945d38b94c3984c898f699faa8bb066e9f3a114c32"},
-    {file = "pycares-3.2.3-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:99a62b101cfb36ab6ebf19cb1ad60db2f9b080dc52db4ca985fe90924f60c758"},
-    {file = "pycares-3.2.3-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:2246adcbc948dd31925c9bff5cc41c06fc640f7d982e6b41b6d09e4f201e5c11"},
-    {file = "pycares-3.2.3-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:7fd15d3f32be5548f38f95f4762ca73eef9fd623b101218a35d433ee0d4e3b58"},
-    {file = "pycares-3.2.3-cp38-cp38-win32.whl", hash = "sha256:4bb0c708d8713741af7c4649d2f11e47c5f4e43131831243aeb18cff512c5469"},
-    {file = "pycares-3.2.3-cp38-cp38-win_amd64.whl", hash = "sha256:a53d921956d1e985e510ca0ffa84fbd7ecc6ac7d735d8355cba4395765efcd31"},
-    {file = "pycares-3.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0312d25fa9d7c242f66115c4b3ae6ed8aedb457513ba33acef31fa265fc602b4"},
-    {file = "pycares-3.2.3-cp39-cp39-manylinux1_i686.whl", hash = "sha256:9960de8254525d9c3b485141809910c39d5eb1bb8119b1453702aacf72234934"},
-    {file = "pycares-3.2.3-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:929f708a7bb4b2548cbbfc2094b2f90c4d8712056cdc0204788b570ab69c8838"},
-    {file = "pycares-3.2.3-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:4dd1237f01037cf5b90dd599c7fa79d9d8fb2ab2f401e19213d24228b2d17838"},
-    {file = "pycares-3.2.3-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:5eea61a74097976502ce377bb75c4fed381d4986bc7fb85e70b691165133d3da"},
-    {file = "pycares-3.2.3-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:1c72c0fda4b08924fe04680475350e09b8d210365d950a6dcdde8c449b8d5b98"},
-    {file = "pycares-3.2.3-cp39-cp39-win32.whl", hash = "sha256:b1555d51ce29510ffd20f9e0339994dff8c5d1cb093c8e81d5d98f474e345aa7"},
-    {file = "pycares-3.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:43c15138f620ed28e61e51b884490eb8387e5954668f919313753f88dd8134fd"},
-    {file = "pycares-3.2.3.tar.gz", hash = "sha256:da1899fde778f9b8736712283eccbf7b654248779b349d139cd28eb30b0fa8cd"},
+    {file = "pycares-4.0.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:db5a533111a3cfd481e7e4fb2bf8bef69f4fa100339803e0504dd5aecafb96a5"},
+    {file = "pycares-4.0.0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:fdff88393c25016f417770d82678423fc7a56995abb2df3d2a1e55725db6977d"},
+    {file = "pycares-4.0.0-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:0aa97f900a7ffb259be77d640006585e2a907b0cd4edeee0e85cf16605995d5a"},
+    {file = "pycares-4.0.0-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:a34b0e3e693dceb60b8a1169668d606c75cb100ceba0a2df53c234a0eb067fbc"},
+    {file = "pycares-4.0.0-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:7661d6bbd51a337e7373cb356efa8be9b4655fda484e068f9455e939aec8d54e"},
+    {file = "pycares-4.0.0-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:57315b8eb8fdbc56b3ad4932bc4b17132bb7c7fd2bd590f7fb84b6b522098aa9"},
+    {file = "pycares-4.0.0-cp36-cp36m-win32.whl", hash = "sha256:dca9dc58845a9d083f302732a3130c68ded845ad5d463865d464e53c75a3dd45"},
+    {file = "pycares-4.0.0-cp36-cp36m-win_amd64.whl", hash = "sha256:c95c964d5dd307e104b44b193095c67bb6b10c9eda1ffe7d44ab7a9e84c476d9"},
+    {file = "pycares-4.0.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:26e67e4f81c80a5955dcf6193f3d9bee3c491fc0056299b383b84d792252fba4"},
+    {file = "pycares-4.0.0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:cd3011ffd5e1ad55880f7256791dbab9c43ebeda260474a968f19cd0319e1aef"},
+    {file = "pycares-4.0.0-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:1b959dd5921d207d759d421eece1b60416df33a7f862465739d5f2c363c2f523"},
+    {file = "pycares-4.0.0-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:6f258c1b74c048a9501a25f732f11b401564005e5e3c18f1ca6cad0c3dc0fb19"},
+    {file = "pycares-4.0.0-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:b17ef48729786e62b574c6431f675f4cb02b27691b49e7428a605a50cd59c072"},
+    {file = "pycares-4.0.0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:82b3259cb590ddd107a6d2dc52da2a2e9a986bf242e893d58c786af2f8191047"},
+    {file = "pycares-4.0.0-cp37-cp37m-win32.whl", hash = "sha256:4876fc790ae32832ae270c4a010a1a77e12ddf8d8e6ad70ad0b0a9d506c985f7"},
+    {file = "pycares-4.0.0-cp37-cp37m-win_amd64.whl", hash = "sha256:f60c04c5561b1ddf85ca4e626943cc09d7fb684e1adb22abb632095415a40fd7"},
+    {file = "pycares-4.0.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:615406013cdcd1b445e5d1a551d276c6200b3abe77e534f8a7f7e1551208d14f"},
+    {file = "pycares-4.0.0-cp38-cp38-manylinux1_i686.whl", hash = "sha256:6580aef5d1b29a88c3d72fe73c691eacfd454f86e74d3fdd18f4bad8e8def98b"},
+    {file = "pycares-4.0.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:8ebb3ba0485f66cae8eed7ce3e9ed6f2c0bfd5e7319d5d0fbbb511064f17e1d4"},
+    {file = "pycares-4.0.0-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:c5362b7690ca481440f6b98395ac6df06aa50518ccb183c560464d1e5e2ab5d4"},
+    {file = "pycares-4.0.0-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:eb60be66accc9a9ea1018b591a1f5800cba83491d07e9acc8c56bc6e6607ab54"},
+    {file = "pycares-4.0.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:44896d6e191a6b5a914dbe3aa7c748481bf6ad19a9df33c1e76f8f2dc33fc8f0"},
+    {file = "pycares-4.0.0-cp38-cp38-win32.whl", hash = "sha256:09b28fc7bc2cc05f7f69bf1636ddf46086e0a1837b62961e2092fcb40477320d"},
+    {file = "pycares-4.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:d4a5081e232c1d181883dcac4675807f3a6cf33911c4173fbea00c0523687ed4"},
+    {file = "pycares-4.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:103353577a6266a53e71bfee4cf83825f1401fefa60f0fb8bdec35f13be6a5f2"},
+    {file = "pycares-4.0.0-cp39-cp39-manylinux1_i686.whl", hash = "sha256:ad6caf580ee69806fc6534be93ddbb6e99bf94296d79ab351c37b2992b17abfd"},
+    {file = "pycares-4.0.0-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:3d5e50c95849f6905d2a9dbf02ed03f82580173e3c5604a39e2ad054185631f1"},
+    {file = "pycares-4.0.0-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:53bc4f181b19576499b02cea4b45391e8dcbe30abd4cd01492f66bfc15615a13"},
+    {file = "pycares-4.0.0-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:d52f9c725d2a826d5ffa37681eb07ffb996bfe21788590ef257664a3898fc0b5"},
+    {file = "pycares-4.0.0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:3c7fb8d34ee11971c39acfaf98d0fac66725385ccef3bfe1b174c92b210e1aa4"},
+    {file = "pycares-4.0.0-cp39-cp39-win32.whl", hash = "sha256:e9773e07684a55f54657df05237267611a77b294ec3bacb5f851c4ffca38a465"},
+    {file = "pycares-4.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:38e54037f36c149146ff15f17a4a963fbdd0f9871d4a21cd94ff9f368140f57e"},
+    {file = "pycares-4.0.0.tar.gz", hash = "sha256:d0154fc5753b088758fbec9bc137e1b24bb84fc0c6a09725c8bac25a342311cd"},
 ]
 pycodestyle = [
     {file = "pycodestyle-2.7.0-py2.py3-none-any.whl", hash = "sha256:514f76d918fcc0b55c6680472f0a37970994e07bbb80725808c17089be302068"},
@@ -1415,18 +1558,38 @@ pycparser = [
     {file = "pycparser-2.20.tar.gz", hash = "sha256:2d475327684562c3a96cc71adf7dc8c4f0565175cf86b6d7a404ff4c771f15f0"},
 ]
 pydocstyle = [
-    {file = "pydocstyle-6.0.0-py3-none-any.whl", hash = "sha256:d4449cf16d7e6709f63192146706933c7a334af7c0f083904799ccb851c50f6d"},
-    {file = "pydocstyle-6.0.0.tar.gz", hash = "sha256:164befb520d851dbcf0e029681b91f4f599c62c5cd8933fd54b1bfbd50e89e1f"},
+    {file = "pydocstyle-6.1.1-py3-none-any.whl", hash = "sha256:6987826d6775056839940041beef5c08cc7e3d71d63149b48e36727f70144dc4"},
+    {file = "pydocstyle-6.1.1.tar.gz", hash = "sha256:1d41b7c459ba0ee6c345f2eb9ae827cab14a7533a88c5c6f7e94923f72df92dc"},
 ]
 pyflakes = [
     {file = "pyflakes-2.3.1-py2.py3-none-any.whl", hash = "sha256:7893783d01b8a89811dd72d7dfd4d84ff098e5eed95cfa8905b22bbffe52efc3"},
     {file = "pyflakes-2.3.1.tar.gz", hash = "sha256:f5bc8ecabc05bb9d291eb5203d6810b49040f6ff446a756326104746cc00c1db"},
 ]
+pyparsing = [
+    {file = "pyparsing-2.4.7-py2.py3-none-any.whl", hash = "sha256:ef9d7589ef3c200abe66653d3f1ab1033c3c419ae9b9bdb1240a85b024efc88b"},
+    {file = "pyparsing-2.4.7.tar.gz", hash = "sha256:c203ec8783bf771a155b207279b9bccb8dea02d8f0c9e5f8ead507bc3246ecc1"},
+]
 pyreadline = [
     {file = "pyreadline-2.1.win-amd64.exe", hash = "sha256:9ce5fa65b8992dfa373bddc5b6e0864ead8f291c94fbfec05fbd5c836162e67b"},
     {file = "pyreadline-2.1.win32.exe", hash = "sha256:65540c21bfe14405a3a77e4c085ecfce88724743a4ead47c66b84defcf82c32e"},
     {file = "pyreadline-2.1.zip", hash = "sha256:4530592fc2e85b25b1a9f79664433da09237c1a270e4d78ea5aa3a2c7229e2d1"},
 ]
+pytest = [
+    {file = "pytest-6.2.4-py3-none-any.whl", hash = "sha256:91ef2131a9bd6be8f76f1f08eac5c5317221d6ad1e143ae03894b862e8976890"},
+    {file = "pytest-6.2.4.tar.gz", hash = "sha256:50bcad0a0b9c5a72c8e4e7c9855a3ad496ca6a881a3641b4260605450772c54b"},
+]
+pytest-cov = [
+    {file = "pytest-cov-2.12.1.tar.gz", hash = "sha256:261ceeb8c227b726249b376b8526b600f38667ee314f910353fa318caa01f4d7"},
+    {file = "pytest_cov-2.12.1-py2.py3-none-any.whl", hash = "sha256:261bb9e47e65bd099c89c3edf92972865210c36813f80ede5277dceb77a4a62a"},
+]
+pytest-forked = [
+    {file = "pytest-forked-1.3.0.tar.gz", hash = "sha256:6aa9ac7e00ad1a539c41bec6d21011332de671e938c7637378ec9710204e37ca"},
+    {file = "pytest_forked-1.3.0-py2.py3-none-any.whl", hash = "sha256:dc4147784048e70ef5d437951728825a131b81714b398d5d52f17c7c144d8815"},
+]
+pytest-xdist = [
+    {file = "pytest-xdist-2.3.0.tar.gz", hash = "sha256:e8ecde2f85d88fbcadb7d28cb33da0fa29bca5cf7d5967fa89fc0e97e5299ea5"},
+    {file = "pytest_xdist-2.3.0-py3-none-any.whl", hash = "sha256:ed3d7da961070fce2a01818b51f6888327fb88df4379edeb6b9d990e789d9c8d"},
+]
 python-dateutil = [
     {file = "python-dateutil-2.8.1.tar.gz", hash = "sha256:73ebfe9dbf22e832286dafa60473e4cd239f8592f699aa5adaf10050e6e1823c"},
     {file = "python_dateutil-2.8.1-py2.py3-none-any.whl", hash = "sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a"},
@@ -1462,6 +1625,69 @@ pyyaml = [
     {file = "PyYAML-5.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:c20cfa2d49991c8b4147af39859b167664f2ad4561704ee74c1de03318e898db"},
     {file = "PyYAML-5.4.1.tar.gz", hash = "sha256:607774cbba28732bfa802b54baa7484215f530991055bb562efbed5b2f20a45e"},
 ]
+rapidfuzz = [
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:72878878d6744883605b5453c382361716887e9e552f677922f76d93d622d8cb"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:56a67a5b3f783e9af73940f6945366408b3a2060fc6ab18466e5a2894fd85617"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:f5d396b64f8ae3a793633911a1fb5d634ac25bf8f13d440139fa729131be42d8"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:4990698233e7eda7face7c09f5874a09760c7524686045cbb10317e3a7f3225f"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:a87e212855b18a951e79ec71d71dbd856d98cd2019d0c2bd46ec30688a8aa68a"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-manylinux2014_aarch64.whl", hash = "sha256:1897d2ef03f5b51bc19bdb2d0398ae968766750fa319843733f0a8f12ddde986"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-manylinux2014_ppc64le.whl", hash = "sha256:e1fc4fd219057f5f1fa40bb9bc5e880f8ef45bf19350d4f5f15ca2ce7f61c99b"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-manylinux2014_s390x.whl", hash = "sha256:21300c4d048798985c271a8bf1ed1611902ebd4479fcacda1a3eaaebbad2f744"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-win32.whl", hash = "sha256:d2659967c6ac74211a87a1109e79253e4bc179641057c64800ef4e2dc0534fdb"},
+    {file = "rapidfuzz-1.4.1-cp35-cp35m-win_amd64.whl", hash = "sha256:26ac4bfe564c516e053fc055f1543d2b2433338806738c7582e1f75ed0485f7e"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:3b485c98ad1ce3c04556f65aaab5d6d6d72121cde656d43505169c71ae956476"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:59db06356eaf22c83f44b0dded964736cbb137291cdf2cf7b4974c0983b94932"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:fef95249af9a535854b617a68788c38cd96308d97ee14d44bc598cc73e986167"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:7d8c186e8270e103d339b26ef498581cf3178470ccf238dfd5fd0e47d80e4c7d"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:9246b9c5c8992a83a08ac7813c8bbff2e674ad0b681f9b3fb1ec7641eff6c21f"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:f58c17f7a82b1bcc2ce304942cae14287223e6b6eead7071241273da7d9b9770"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-manylinux2014_ppc64le.whl", hash = "sha256:ed708620b23a09ac52eaaec0761943c1bbc9a62d19ecd2feb4da8c3f79ef9d37"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-manylinux2014_s390x.whl", hash = "sha256:bdec9ae5fd8a8d4d8813b4aac3505c027b922b4033a32a7aab66a9b2f03a7b47"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-win32.whl", hash = "sha256:fc668fd706ad1162ce14f26ca2957b4690d47770d23609756536c918a855ced0"},
+    {file = "rapidfuzz-1.4.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f9f35df5dd9b02669ff6b1d4a386607ff56982c86a7e57d95eb08c6afbab4ddd"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8427310ea29ce2968e1c6f6779ae5a458b3a4984f9150fc4d16f92b96456f848"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:1430dc745476e3798742ad835f61f6e6bf5d3e9a22cf9cd0288b28b7440a9872"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:1d20311da611c8f4638a09e2bc5e04b327bae010cb265ef9628d9c13c6d5da7b"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:d7881965e428cf6fe248d6e702e6d5857da02278ab9b21313bee717c080e443e"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:f76c965f15861ec4d39e904bd65b84a39121334439ac17bfb8b900d1e6779a93"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:61167f989415e701ac379de247e6b0a21ea62afc86c54d8a79f485b4f0173c02"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-manylinux2014_ppc64le.whl", hash = "sha256:645cfb9456229f0bd5752b3eda69f221d825fbb8cbb8855433516bc185111506"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-manylinux2014_s390x.whl", hash = "sha256:c28be57c9bc47b3d7f484340fab1bec8ed4393dee1090892c2774a4584435eb8"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-win32.whl", hash = "sha256:3c94b6d3513c693f253ff762112cc4580d3bd377e4abacb96af31a3d606fbe14"},
+    {file = "rapidfuzz-1.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:506d50a066451502ee2f8bf016bc3ba3e3b04eede7a4059d7956248e2dd96179"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:80b375098658bb3db14215a975d354f6573d3943ac2ae0c4627c7760d57ce075"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:ba8f7cbd8fdbd3ae115f4484888f3cb94bc2ac7cbd4eb1ca95a3d4f874261ff8"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:5fa8570720b0fdfc52f24f5663d66c52ea88ba19cb8b1ff6a39a8bc0b925b33b"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:f35c8a4c690447fd335bfd77df4da42dfea37cfa06a8ecbf22543d86dc720e12"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:27f9eef48e212d73e78f0f5ceedc62180b68f6a25fa0752d2ccfaedc3a840bec"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:31e99216e2a04aec4f281d472b28a683921f1f669a429cf605d11526623eaeed"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-manylinux2014_ppc64le.whl", hash = "sha256:f22bf7ba6eddd59764457f74c637ab5c3ed976c5fcfaf827e1d320cc0478e12b"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-manylinux2014_s390x.whl", hash = "sha256:c43ddb354abd00e56f024ce80affb3023fa23206239bb81916d5877cba7f2d1e"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-win32.whl", hash = "sha256:62c1f4ac20c8019ce8d481fb27235306ef3912a8d0b9a60b17905699f43ff072"},
+    {file = "rapidfuzz-1.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:2963f356c70b710dc6337b012ec976ce2fc2b81c2a9918a686838fead6eb4e1d"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c07f301fd549b266410654850c6918318d7dcde8201350e9ac0819f0542cf147"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fa4c8b6fc7e93e3a3fb9be9566f1fe7ef920735eadcee248a0d70f3ca8941341"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c200bd813bbd3b146ba0fd284a9ad314bbad9d95ed542813273bdb9d0ee4e796"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:2cccc84e1f0c6217747c09cafe93164e57d3644e18a334845a2dfbdd2073cd2c"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:f2033e3d61d1e498f618123b54dc7436d50510b0d18fd678d867720e8d7b2f23"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:26b7f48b3ddd9d97cf8482a88f0f6cba47ac13ff16e63386ea7ce06178174770"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:bf18614f87fe3bfff783f0a3d0fad0eb59c92391e52555976e55570a651d2330"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:8cb5c2502ff06028a1468bdf61323b53cc3a37f54b5d62d62c5371795b81086a"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-manylinux2014_ppc64le.whl", hash = "sha256:f37f80c1541d6e0a30547261900086b8c0bac519ebc12c9cd6b61a9a43a7e195"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-manylinux2014_s390x.whl", hash = "sha256:c13cd1e840aa93639ac1d131fbfa740a609fd20dfc2a462d5cd7bce747a2398d"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-win32.whl", hash = "sha256:0ec346f271e96c485716c091c8b0b78ba52da33f7c6ebb52a349d64094566c2d"},
+    {file = "rapidfuzz-1.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:5208ce1b1989a10e6fc5b5ef5d0bb7d1ffe5408838f3106abde241aff4dab08c"},
+    {file = "rapidfuzz-1.4.1-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4fa195ea9ca35bacfa2a4319c6d4ab03aa6a283ad2089b70d2dfa0f6a7d9c1bc"},
+    {file = "rapidfuzz-1.4.1-pp36-pypy36_pp73-manylinux1_x86_64.whl", hash = "sha256:6e336cfd8103b0b38e107e01502e9d6bf7c7f04e49b970fb11a4bf6c7a932b94"},
+    {file = "rapidfuzz-1.4.1-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:c798c5b87efe8a7e63f408e07ff3bc03ba8b94f4498a89b48eaab3a9f439d52c"},
+    {file = "rapidfuzz-1.4.1-pp36-pypy36_pp73-win32.whl", hash = "sha256:bb16a10b40f5bd3c645f7748fbd36f49699a03f550c010a2c665905cc8937de8"},
+    {file = "rapidfuzz-1.4.1-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2278001924031d9d75f821bff2c5fef565c8376f252562e04d8eec8857475c36"},
+    {file = "rapidfuzz-1.4.1-pp37-pypy37_pp73-manylinux1_x86_64.whl", hash = "sha256:a89d11f3b5da35fdf3e839186203b9367d56e2be792e8dccb098f47634ec6eb9"},
+    {file = "rapidfuzz-1.4.1-pp37-pypy37_pp73-manylinux2010_x86_64.whl", hash = "sha256:f8c79cd11b4778d387366a59aa747f5268433f9d68be37b00d16f4fb08fdf850"},
+    {file = "rapidfuzz-1.4.1-pp37-pypy37_pp73-win32.whl", hash = "sha256:4364db793ed4b439f9dd28a335bee14e2a828283d3b93c2d2686cc645eeafdd5"},
+    {file = "rapidfuzz-1.4.1.tar.gz", hash = "sha256:de20550178376d21bfe1b34a7dc42ab107bb282ef82069cf6dfe2805a0029e26"},
+]
 redis = [
     {file = "redis-3.5.3-py2.py3-none-any.whl", hash = "sha256:432b788c4530cfe16d8d943a09d40ca6c16149727e4afe8c2c9d5580c59d9f24"},
     {file = "redis-3.5.3.tar.gz", hash = "sha256:0e7e0cfca8660dea8b7d5cd8c4f6c5e29e11f31158c0b0ae91a397f00e5a05a2"},
@@ -1510,8 +1736,8 @@ regex = [
     {file = "regex-2021.4.4.tar.gz", hash = "sha256:52ba3d3f9b942c49d7e4bc105bb28551c44065f139a65062ab7912bef10c9afb"},
 ]
 requests = [
-    {file = "requests-2.15.1-py2.py3-none-any.whl", hash = "sha256:ff753b2196cd18b1bbeddc9dcd5c864056599f7a7d9a4fb5677e723efa2b7fb9"},
-    {file = "requests-2.15.1.tar.gz", hash = "sha256:e5659b9315a0610505e050bb7190bf6fa2ccee1ac295f2b760ef9d8a03ebbb2e"},
+    {file = "requests-2.25.1-py2.py3-none-any.whl", hash = "sha256:c210084e36a42ae6b9219e00e48287def368a26d03a048ddad7bfee44f75871e"},
+    {file = "requests-2.25.1.tar.gz", hash = "sha256:27973dd4a904a4f13b263a19c866c13b92a39ed1c964655f025f3f8d3d75b804"},
 ]
 sentry-sdk = [
     {file = "sentry-sdk-0.20.3.tar.gz", hash = "sha256:4ae8d1ced6c67f1c8ea51d82a16721c166c489b76876c9f2c202b8a50334b237"},
@@ -1529,8 +1755,8 @@ snowballstemmer = [
     {file = "snowballstemmer-2.1.0.tar.gz", hash = "sha256:e997baa4f2e9139951b6f4c631bad912dfd3c792467e2f03d7239464af90e914"},
 ]
 sortedcontainers = [
-    {file = "sortedcontainers-2.3.0-py2.py3-none-any.whl", hash = "sha256:37257a32add0a3ee490bb170b599e93095eed89a55da91fa9f48753ea12fd73f"},
-    {file = "sortedcontainers-2.3.0.tar.gz", hash = "sha256:59cc937650cf60d677c16775597c89a960658a09cf7c1a668f86e1e4464b10a1"},
+    {file = "sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0"},
+    {file = "sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88"},
 ]
 soupsieve = [
     {file = "soupsieve-2.2.1-py3-none-any.whl", hash = "sha256:c2c1c2d44f158cdbddab7824a9af8c4f83c76b1e23e049479aa432feb6c4c23b"},
@@ -1554,12 +1780,12 @@ typing-extensions = [
     {file = "typing_extensions-3.10.0.0.tar.gz", hash = "sha256:50b6f157849174217d0656f99dc82fe932884fb250826c18350e159ec6cdf342"},
 ]
 urllib3 = [
-    {file = "urllib3-1.26.4-py2.py3-none-any.whl", hash = "sha256:2f4da4594db7e1e110a944bb1b551fdf4e6c136ad42e4234131391e21eb5b0df"},
-    {file = "urllib3-1.26.4.tar.gz", hash = "sha256:e7b021f7241115872f92f43c6508082facffbd1c048e3c6e2bb9c2a157e28937"},
+    {file = "urllib3-1.26.6-py2.py3-none-any.whl", hash = "sha256:39fb8672126159acb139a7718dd10806104dec1e2f0f6c88aab05d17df10c8d4"},
+    {file = "urllib3-1.26.6.tar.gz", hash = "sha256:f57b4c16c62fa2760b7e3d97c35b255512fb6b59a259730f36ba32ce9f8e342f"},
 ]
 virtualenv = [
-    {file = "virtualenv-20.4.6-py2.py3-none-any.whl", hash = "sha256:307a555cf21e1550885c82120eccaf5acedf42978fd362d32ba8410f9593f543"},
-    {file = "virtualenv-20.4.6.tar.gz", hash = "sha256:72cf267afc04bf9c86ec932329b7e94db6a0331ae9847576daaa7ca3c86b29a4"},
+    {file = "virtualenv-20.4.7-py2.py3-none-any.whl", hash = "sha256:2b0126166ea7c9c3661f5b8e06773d28f83322de7a3ff7d06f0aed18c9de6a76"},
+    {file = "virtualenv-20.4.7.tar.gz", hash = "sha256:14fdf849f80dbb29a4eb6caa9875d476ee2a5cf76a5f5415fa2f1606010ab467"},
 ]
 yarl = [
     {file = "yarl-1.6.3-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:0355a701b3998dcd832d0dc47cc5dedf3874f966ac7f870e0f3a6788d802d434"},
diff --git a/pyproject.toml b/pyproject.toml
index 320bf88cc..8eac504c5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -10,7 +10,6 @@ python = "3.9.*"
 aio-pika = "~=6.1"
 aiodns = "~=2.0"
 aiohttp = "~=3.7"
-aioping = "~=0.3.1"
 aioredis = "~=1.3.1"
 arrow = "~=1.0.3"
 async-rediscache = { version = "~=0.1.2", extras = ["fakeredis"] }
@@ -18,10 +17,10 @@ beautifulsoup4 = "~=4.9"
 colorama = { version = "~=0.4.3", markers = "sys_platform == 'win32'" }
 coloredlogs = "~=14.0"
 deepdiff = "~=4.0"
-"discord.py" = "~=1.6.0"
+"discord.py" = "~=1.7.3"
 emoji = "~=0.6"
 feedparser = "~=6.0.2"
-fuzzywuzzy = "~=0.17"
+rapidfuzz = "~=1.4"
 lxml = "~=4.4"
 markdownify = "==0.6.1"
 more_itertools = "~=8.2"
@@ -47,6 +46,9 @@ pep8-naming = "~=0.9"
 pre-commit = "~=2.1"
 taskipy = "~=1.7.0"
 python-dotenv = "~=0.17.1"
+pytest = "~=6.2.4"
+pytest-cov = "~=2.12.1"
+pytest-xdist = { version = "~=2.3.0", extras = ["psutil"] }
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
@@ -58,6 +60,12 @@ lint = "pre-commit run --all-files"
 precommit = "pre-commit install"
 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"
+test-nocov = "pytest -n auto"
+test = "pytest -n auto --cov-report= --cov"
 html = "coverage html"
 report = "coverage report"
+
+[tool.coverage.run]
+branch = true
+source_pkgs = ["bot"]
+source = ["tests"]
diff --git a/tests/README.md b/tests/README.md
index 1a17c09bd..b7fddfaa2 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -4,6 +4,14 @@ Our bot is one of the most important tools we have for running our community. As
 
 _**Note:** This is a practical guide to getting started with writing tests for our bot, not a general introduction to writing unit tests in Python. If you're looking for a more general introduction, you can take a look at the [Additional resources](#additional-resources) section at the bottom of this page._
 
+### Table of contents:
+- [Tools](#tools)
+- [Running tests](#running-tests)  
+- [Writing tests](#writing-tests)
+- [Mocking](#mocking)
+- [Some considerations](#some-considerations)
+- [Additional resources](#additional-resources)
+
 ## Tools
 
 We are using the following modules and packages for our unit tests:
@@ -11,15 +19,43 @@ We are using the following modules and packages for our unit tests:
 - [unittest](https://docs.python.org/3/library/unittest.html) (standard library)
 - [unittest.mock](https://docs.python.org/3/library/unittest.mock.html) (standard library)
 - [coverage.py](https://coverage.readthedocs.io/en/stable/)
+- [pytest-cov](https://pytest-cov.readthedocs.io/en/latest/index.html)
+
+We also use the following package as a test runner:
+- [pytest](https://docs.pytest.org/en/6.2.x/)
 
-To ensure the results you obtain on your personal machine are comparable to those generated in the CI, please make sure to run your tests with the virtual environment defined by our [Poetry Project](/pyproject.toml). To run your tests with `poetry`, we've provided two "scripts" shortcuts:
+To ensure the results you obtain on your personal machine are comparable to those generated in the CI, please make sure to run your tests with the virtual environment defined by our [Poetry Project](/pyproject.toml). To run your tests with `poetry`, we've provided the following "script" shortcuts:
 
-- `poetry run task test` will run `unittest` with `coverage.py`
+- `poetry run task test-nocov` will run `pytest`.
+- `poetry run task test` will run `pytest` with `pytest-cov`.
 - `poetry run task test path/to/test.py` will run a specific test.
 - `poetry run task report` will generate a coverage report of the tests you've run with `poetry run task test`. If you append the `-m` flag to this command, the report will include the lines and branches not covered by tests in addition to the test coverage report.
 
 If you want a coverage report, make sure to run the tests with `poetry run task test` *first*.
 
+## Running tests
+There are multiple ways to run the tests, which one you use will be determined by your goal, and stage in development.
+
+When actively developing, you'll most likely be working on one portion of the codebase, and as a result, won't need to run the entire test suite.
+To run just one file, and save time, you can use the following command:
+```shell
+poetry run task test-nocov <path/to/file.py>
+```
+
+For example:
+```shell
+poetry run task test-nocov tests/bot/exts/test_cogs.py
+```
+will run the test suite in the `test_cogs` file.
+
+If you'd like to collect coverage as well, you can append `--cov` to the command above.
+
+
+If you're done and are preparing to commit and push your code, it's a good idea to run the entire test suite as a sanity check:
+```shell
+poetry run task test
+```
+
 ## Writing tests
 
 Since consistency is an important consideration for collaborative projects, we have written some guidelines on writing tests for the bot. In addition to these guidelines, it's a good idea to look at the existing code base for examples (e.g., [`test_converters.py`](/tests/bot/test_converters.py)).
diff --git a/tests/bot/exts/backend/test_error_handler.py b/tests/bot/exts/backend/test_error_handler.py
index bd4fb5942..2b0549b98 100644
--- a/tests/bot/exts/backend/test_error_handler.py
+++ b/tests/bot/exts/backend/test_error_handler.py
@@ -4,12 +4,12 @@ from unittest.mock import AsyncMock, MagicMock, call, patch
 from discord.ext.commands import errors
 
 from bot.api import ResponseCodeError
-from bot.errors import InvalidInfractedUser, LockedResourceError
+from bot.errors import InvalidInfractedUserError, LockedResourceError
 from bot.exts.backend.error_handler import ErrorHandler, setup
 from bot.exts.info.tags import Tags
 from bot.exts.moderation.silence import Silence
 from bot.utils.checks import InWhitelistCheckFailure
-from tests.helpers import MockBot, MockContext, MockGuild, MockRole
+from tests.helpers import MockBot, MockContext, MockGuild, MockRole, MockTextChannel
 
 
 class ErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
@@ -130,7 +130,7 @@ class ErrorHandlerTests(unittest.IsolatedAsyncioTestCase):
                 "expect_mock_call": "send"
             },
             {
-                "args": (self.ctx, errors.CommandInvokeError(InvalidInfractedUser(self.ctx.author))),
+                "args": (self.ctx, errors.CommandInvokeError(InvalidInfractedUserError(self.ctx.author))),
                 "expect_mock_call": "send"
             }
         )
@@ -226,8 +226,8 @@ class TrySilenceTests(unittest.IsolatedAsyncioTestCase):
         self.bot.get_command.return_value.can_run = AsyncMock(side_effect=errors.CommandError())
         self.assertFalse(await self.cog.try_silence(self.ctx))
 
-    async def test_try_silence_silencing(self):
-        """Should run silence command with correct arguments."""
+    async def test_try_silence_silence_duration(self):
+        """Should run silence command with correct duration argument."""
         self.bot.get_command.return_value.can_run = AsyncMock(return_value=True)
         test_cases = ("shh", "shhh", "shhhhhh", "shhhhhhhhhhhhhhhhhhh")
 
@@ -238,21 +238,85 @@ class TrySilenceTests(unittest.IsolatedAsyncioTestCase):
                 self.assertTrue(await self.cog.try_silence(self.ctx))
                 self.ctx.invoke.assert_awaited_once_with(
                     self.bot.get_command.return_value,
-                    duration=min(case.count("h")*2, 15)
+                    duration_or_channel=None,
+                    duration=min(case.count("h")*2, 15),
+                    kick=False
                 )
 
+    async def test_try_silence_silence_arguments(self):
+        """Should run silence with the correct channel, duration, and kick arguments."""
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=True)
+
+        test_cases = (
+            (MockTextChannel(), None),  # None represents the case when no argument is passed
+            (MockTextChannel(), False),
+            (MockTextChannel(), True)
+        )
+
+        for channel, kick in test_cases:
+            with self.subTest(kick=kick, channel=channel):
+                self.ctx.reset_mock()
+                self.ctx.invoked_with = "shh"
+
+                self.ctx.message.content = f"!shh {channel.name} {kick if kick is not None else ''}"
+                self.ctx.guild.text_channels = [channel]
+
+                self.assertTrue(await self.cog.try_silence(self.ctx))
+                self.ctx.invoke.assert_awaited_once_with(
+                    self.bot.get_command.return_value,
+                    duration_or_channel=channel,
+                    duration=4,
+                    kick=(kick if kick is not None else False)
+                )
+
+    async def test_try_silence_silence_message(self):
+        """If the words after the command could not be converted to a channel, None should be passed as channel."""
+        self.bot.get_command.return_value.can_run = AsyncMock(return_value=True)
+        self.ctx.invoked_with = "shh"
+        self.ctx.message.content = "!shh not_a_channel true"
+
+        self.assertTrue(await self.cog.try_silence(self.ctx))
+        self.ctx.invoke.assert_awaited_once_with(
+            self.bot.get_command.return_value,
+            duration_or_channel=None,
+            duration=4,
+            kick=False
+        )
+
     async def test_try_silence_unsilence(self):
-        """Should call unsilence command."""
+        """Should call unsilence command with correct duration and channel arguments."""
         self.silence.silence.can_run = AsyncMock(return_value=True)
-        test_cases = ("unshh", "unshhhhh", "unshhhhhhhhh")
+        test_cases = (
+            ("unshh", None),
+            ("unshhhhh", None),
+            ("unshhhhhhhhh", None),
+            ("unshh", MockTextChannel())
+        )
 
-        for case in test_cases:
-            with self.subTest(message=case):
+        for invoke, channel in test_cases:
+            with self.subTest(message=invoke, channel=channel):
                 self.bot.get_command.side_effect = (self.silence.silence, self.silence.unsilence)
                 self.ctx.reset_mock()
-                self.ctx.invoked_with = case
+
+                self.ctx.invoked_with = invoke
+                self.ctx.message.content = f"!{invoke}"
+                if channel is not None:
+                    self.ctx.message.content += f" {channel.name}"
+                    self.ctx.guild.text_channels = [channel]
+
                 self.assertTrue(await self.cog.try_silence(self.ctx))
-                self.ctx.invoke.assert_awaited_once_with(self.silence.unsilence)
+                self.ctx.invoke.assert_awaited_once_with(self.silence.unsilence, channel=channel)
+
+    async def test_try_silence_unsilence_message(self):
+        """If the words after the command could not be converted to a channel, None should be passed as channel."""
+        self.silence.silence.can_run = AsyncMock(return_value=True)
+        self.bot.get_command.side_effect = (self.silence.silence, self.silence.unsilence)
+
+        self.ctx.invoked_with = "unshh"
+        self.ctx.message.content = "!unshh not_a_channel"
+
+        self.assertTrue(await self.cog.try_silence(self.ctx))
+        self.ctx.invoke.assert_awaited_once_with(self.silence.unsilence, channel=None)
 
     async def test_try_silence_no_match(self):
         """Should return `False` when message don't match."""
diff --git a/tests/bot/exts/filters/test_antimalware.py b/tests/bot/exts/filters/test_antimalware.py
index 3393c6cdc..06d78de9d 100644
--- a/tests/bot/exts/filters/test_antimalware.py
+++ b/tests/bot/exts/filters/test_antimalware.py
@@ -104,24 +104,39 @@ class AntiMalwareCogTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(embed.description, antimalware.PY_EMBED_DESCRIPTION)
 
     async def test_txt_file_redirect_embed_description(self):
-        """A message containing a .txt file should result in the correct embed."""
-        attachment = MockAttachment(filename="python.txt")
-        self.message.attachments = [attachment]
-        self.message.channel.send = AsyncMock()
-        antimalware.TXT_EMBED_DESCRIPTION = Mock()
-        antimalware.TXT_EMBED_DESCRIPTION.format.return_value = "test"
-
-        await self.cog.on_message(self.message)
-        self.message.channel.send.assert_called_once()
-        args, kwargs = self.message.channel.send.call_args
-        embed = kwargs.pop("embed")
-        cmd_channel = self.bot.get_channel(Channels.bot_commands)
+        """A message containing a .txt/.json/.csv file should result in the correct embed."""
+        test_values = (
+            ("text", ".txt"),
+            ("json", ".json"),
+            ("csv", ".csv"),
+        )
 
-        self.assertEqual(embed.description, antimalware.TXT_EMBED_DESCRIPTION.format.return_value)
-        antimalware.TXT_EMBED_DESCRIPTION.format.assert_called_with(cmd_channel_mention=cmd_channel.mention)
+        for file_name, disallowed_extension in test_values:
+            with self.subTest(file_name=file_name, disallowed_extension=disallowed_extension):
+
+                attachment = MockAttachment(filename=f"{file_name}{disallowed_extension}")
+                self.message.attachments = [attachment]
+                self.message.channel.send = AsyncMock()
+                antimalware.TXT_EMBED_DESCRIPTION = Mock()
+                antimalware.TXT_EMBED_DESCRIPTION.format.return_value = "test"
+
+                await self.cog.on_message(self.message)
+                self.message.channel.send.assert_called_once()
+                args, kwargs = self.message.channel.send.call_args
+                embed = kwargs.pop("embed")
+                cmd_channel = self.bot.get_channel(Channels.bot_commands)
+
+                self.assertEqual(
+                    embed.description,
+                    antimalware.TXT_EMBED_DESCRIPTION.format.return_value
+                )
+                antimalware.TXT_EMBED_DESCRIPTION.format.assert_called_with(
+                    blocked_extension=disallowed_extension,
+                    cmd_channel_mention=cmd_channel.mention
+                )
 
     async def test_other_disallowed_extension_embed_description(self):
-        """Test the description for a non .py/.txt disallowed extension."""
+        """Test the description for a non .py/.txt/.json/.csv disallowed extension."""
         attachment = MockAttachment(filename="python.disallowed")
         self.message.attachments = [attachment]
         self.message.channel.send = AsyncMock()
diff --git a/tests/bot/exts/info/test_help.py b/tests/bot/exts/info/test_help.py
new file mode 100644
index 000000000..604c69671
--- /dev/null
+++ b/tests/bot/exts/info/test_help.py
@@ -0,0 +1,23 @@
+import unittest
+
+import rapidfuzz
+
+from bot.exts.info import help
+from tests.helpers import MockBot, MockContext, autospec
+
+
+class HelpCogTests(unittest.IsolatedAsyncioTestCase):
+    def setUp(self) -> None:
+        """Attach an instance of the cog to the class for tests."""
+        self.bot = MockBot()
+        self.cog = help.Help(self.bot)
+        self.ctx = MockContext(bot=self.bot)
+        self.bot.help_command.context = self.ctx
+
+    @autospec(help.CustomHelpCommand, "get_all_help_choices", return_value={"help"}, pass_mocks=False)
+    async def test_help_fuzzy_matching(self):
+        """Test fuzzy matching of commands when called from help."""
+        result = await self.bot.help_command.command_not_found("holp")
+
+        match = {"help": rapidfuzz.fuzz.ratio("help", "holp")}
+        self.assertEqual(match, result.possible_matches)
diff --git a/tests/bot/exts/moderation/infraction/test_utils.py b/tests/bot/exts/moderation/infraction/test_utils.py
index ee9ff650c..50a717bb5 100644
--- a/tests/bot/exts/moderation/infraction/test_utils.py
+++ b/tests/bot/exts/moderation/infraction/test_utils.py
@@ -137,7 +137,7 @@ class ModerationUtilsTests(unittest.IsolatedAsyncioTestCase):
                     title=utils.INFRACTION_TITLE,
                     description=utils.INFRACTION_DESCRIPTION_TEMPLATE.format(
                         type="Ban",
-                        expires="2020-02-26 09:20 (23 hours and 59 minutes)",
+                        expires="2020-02-26 09:20 (23 hours and 59 minutes) UTC",
                         reason="No reason provided."
                     ),
                     colour=Colours.soft_red,
@@ -193,7 +193,7 @@ class ModerationUtilsTests(unittest.IsolatedAsyncioTestCase):
                     title=utils.INFRACTION_TITLE,
                     description=utils.INFRACTION_DESCRIPTION_TEMPLATE.format(
                         type="Mute",
-                        expires="2020-02-26 09:20 (23 hours and 59 minutes)",
+                        expires="2020-02-26 09:20 (23 hours and 59 minutes) UTC",
                         reason="Test"
                     ),
                     colour=Colours.soft_red,
diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index fa5fc9e81..59a5893ef 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -1,15 +1,26 @@
 import asyncio
+import itertools
 import unittest
 from datetime import datetime, timezone
+from typing import List, Tuple
 from unittest import mock
-from unittest.mock import Mock
+from unittest.mock import AsyncMock, Mock
 
 from async_rediscache import RedisSession
 from discord import PermissionOverwrite
 
-from bot.constants import Channels, Guild, Roles
+from bot.constants import Channels, Guild, MODERATION_ROLES, Roles
 from bot.exts.moderation import silence
-from tests.helpers import MockBot, MockContext, MockTextChannel, autospec
+from tests.helpers import (
+    MockBot,
+    MockContext,
+    MockGuild,
+    MockMember,
+    MockRole,
+    MockTextChannel,
+    MockVoiceChannel,
+    autospec
+)
 
 redis_session = None
 redis_loop = asyncio.get_event_loop()
@@ -149,7 +160,7 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.assertTrue(self.cog._init_task.cancelled())
 
     @autospec("discord.ext.commands", "has_any_role")
-    @mock.patch.object(silence, "MODERATION_ROLES", new=(1, 2, 3))
+    @mock.patch.object(silence.constants, "MODERATION_ROLES", new=(1, 2, 3))
     async def test_cog_check(self, role_check):
         """Role check was called with `MODERATION_ROLES`"""
         ctx = MockContext()
@@ -159,6 +170,170 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         role_check.assert_called_once_with(*(1, 2, 3))
         role_check.return_value.predicate.assert_awaited_once_with(ctx)
 
+    async def test_force_voice_sync(self):
+        """Tests the _force_voice_sync helper function."""
+        await self.cog._async_init()
+
+        # Create a regular member, and one member for each of the moderation roles
+        moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
+        members = [MockMember(), *moderation_members]
+
+        channel = MockVoiceChannel(members=members)
+
+        await self.cog._force_voice_sync(channel)
+        for member in members:
+            if member in moderation_members:
+                member.move_to.assert_not_called()
+            else:
+                self.assertEqual(member.move_to.call_count, 2)
+                calls = member.move_to.call_args_list
+
+                # Tests that the member was moved to the afk channel, and back.
+                self.assertEqual((channel.guild.afk_channel,), calls[0].args)
+                self.assertEqual((channel,), calls[1].args)
+
+    async def test_force_voice_sync_no_channel(self):
+        """Test to ensure _force_voice_sync can create its own voice channel if one is not available."""
+        await self.cog._async_init()
+
+        channel = MockVoiceChannel(guild=MockGuild(afk_channel=None))
+        new_channel = MockVoiceChannel(delete=AsyncMock())
+        channel.guild.create_voice_channel.return_value = new_channel
+
+        await self.cog._force_voice_sync(channel)
+
+        # Check channel creation
+        overwrites = {
+            channel.guild.default_role: PermissionOverwrite(speak=False, connect=False, view_channel=False)
+        }
+        channel.guild.create_voice_channel.assert_awaited_once_with("mute-temp", overwrites=overwrites)
+
+        # Check bot deleted channel
+        new_channel.delete.assert_awaited_once()
+
+    async def test_voice_kick(self):
+        """Test to ensure kick function can remove all members from a voice channel."""
+        await self.cog._async_init()
+
+        # Create a regular member, and one member for each of the moderation roles
+        moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
+        members = [MockMember(), *moderation_members]
+
+        channel = MockVoiceChannel(members=members)
+        await self.cog._kick_voice_members(channel)
+
+        for member in members:
+            if member in moderation_members:
+                member.move_to.assert_not_called()
+            else:
+                self.assertEqual((None,), member.move_to.call_args_list[0].args)
+
+    @staticmethod
+    def create_erroneous_members() -> Tuple[List[MockMember], List[MockMember]]:
+        """
+        Helper method to generate a list of members that error out on move_to call.
+
+        Returns the list of erroneous members,
+        as well as a list of regular and erroneous members combined, in that order.
+        """
+        erroneous_member = MockMember(move_to=AsyncMock(side_effect=Exception()))
+        members = [MockMember(), erroneous_member]
+
+        return erroneous_member, members
+
+    async def test_kick_move_to_error(self):
+        """Test to ensure move_to gets called on all members during kick, even if some fail."""
+        await self.cog._async_init()
+        _, members = self.create_erroneous_members()
+
+        await self.cog._kick_voice_members(MockVoiceChannel(members=members))
+        for member in members:
+            member.move_to.assert_awaited_once()
+
+    async def test_sync_move_to_error(self):
+        """Test to ensure move_to gets called on all members during sync, even if some fail."""
+        await self.cog._async_init()
+        failing_member, members = self.create_erroneous_members()
+
+        await self.cog._force_voice_sync(MockVoiceChannel(members=members))
+        for member in members:
+            self.assertEqual(member.move_to.call_count, 1 if member == failing_member else 2)
+
+
+class SilenceArgumentParserTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for the silence argument parser utility function."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.cog = silence.Silence(self.bot)
+        self.cog._init_task = asyncio.Future()
+        self.cog._init_task.set_result(None)
+
+    @autospec(silence.Silence, "send_message", pass_mocks=False)
+    @autospec(silence.Silence, "_set_silence_overwrites", return_value=False, pass_mocks=False)
+    @autospec(silence.Silence, "parse_silence_args")
+    async def test_command(self, parser_mock):
+        """Test that the command passes in the correct arguments for different calls."""
+        test_cases = (
+            (),
+            (15, ),
+            (MockTextChannel(),),
+            (MockTextChannel(), 15),
+        )
+
+        ctx = MockContext()
+        parser_mock.return_value = (ctx.channel, 10)
+
+        for case in test_cases:
+            with self.subTest("Test command converters", args=case):
+                await self.cog.silence.callback(self.cog, ctx, *case)
+
+                try:
+                    first_arg = case[0]
+                except IndexError:
+                    # Default value when the first argument is not passed
+                    first_arg = None
+
+                try:
+                    second_arg = case[1]
+                except IndexError:
+                    # Default value when the second argument is not passed
+                    second_arg = 10
+
+                parser_mock.assert_called_with(ctx, first_arg, second_arg)
+
+    async def test_no_arguments(self):
+        """Test the parser when no arguments are passed to the command."""
+        ctx = MockContext()
+        channel, duration = self.cog.parse_silence_args(ctx, None, 10)
+
+        self.assertEqual(ctx.channel, channel)
+        self.assertEqual(10, duration)
+
+    async def test_channel_only(self):
+        """Test the parser when just the channel argument is passed."""
+        expected_channel = MockTextChannel()
+        actual_channel, duration = self.cog.parse_silence_args(MockContext(), expected_channel, 10)
+
+        self.assertEqual(expected_channel, actual_channel)
+        self.assertEqual(10, duration)
+
+    async def test_duration_only(self):
+        """Test the parser when just the duration argument is passed."""
+        ctx = MockContext()
+        channel, duration = self.cog.parse_silence_args(ctx, 15, 10)
+
+        self.assertEqual(ctx.channel, channel)
+        self.assertEqual(15, duration)
+
+    async def test_all_args(self):
+        """Test the parser when both channel and duration are passed."""
+        expected_channel = MockTextChannel()
+        actual_channel, duration = self.cog.parse_silence_args(MockContext(), expected_channel, 15)
+
+        self.assertEqual(expected_channel, actual_channel)
+        self.assertEqual(15, duration)
+
 
 @autospec(silence.Silence, "previous_overwrites", "unsilence_timestamps", pass_mocks=False)
 class RescheduleTests(unittest.IsolatedAsyncioTestCase):
@@ -235,6 +410,16 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         self.cog.notifier.add_channel.assert_not_called()
 
 
+def voice_sync_helper(function):
+    """Helper wrapper to test the sync and kick functions for voice channels."""
+    @autospec(silence.Silence, "_force_voice_sync", "_kick_voice_members", "_set_silence_overwrites")
+    async def inner(self, sync, kick, overwrites):
+        overwrites.return_value = True
+        await function(self, MockContext(), sync, kick)
+
+    return inner
+
+
 @autospec(silence.Silence, "previous_overwrites", "unsilence_timestamps", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the silence command and its related helper methods."""
@@ -242,7 +427,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     @autospec(silence.Silence, "_reschedule", pass_mocks=False)
     @autospec(silence, "Scheduler", "SilenceNotifier", pass_mocks=False)
     def setUp(self) -> None:
-        self.bot = MockBot()
+        self.bot = MockBot(get_channel=lambda _: MockTextChannel())
         self.cog = silence.Silence(self.bot)
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
@@ -252,56 +437,127 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         asyncio.run(self.cog._async_init())  # Populate instance attributes.
 
-        self.channel = MockTextChannel()
-        self.overwrite = PermissionOverwrite(stream=True, send_messages=True, add_reactions=False)
-        self.channel.overwrites_for.return_value = self.overwrite
+        self.text_channel = MockTextChannel()
+        self.text_overwrite = PermissionOverwrite(send_messages=True, add_reactions=False)
+        self.text_channel.overwrites_for.return_value = self.text_overwrite
+
+        self.voice_channel = MockVoiceChannel()
+        self.voice_overwrite = PermissionOverwrite(connect=True, speak=True)
+        self.voice_channel.overwrites_for.return_value = self.voice_overwrite
 
     async def test_sent_correct_message(self):
-        """Appropriate failure/success message was sent by the command."""
+        """Appropriate failure/success message was sent by the command to the correct channel."""
+        # The following test tuples are made up of:
+        # duration, expected message, and the success of the _set_silence_overwrites function
         test_cases = (
             (0.0001, silence.MSG_SILENCE_SUCCESS.format(duration=0.0001), True,),
             (None, silence.MSG_SILENCE_PERMANENT, True,),
             (5, silence.MSG_SILENCE_FAIL, False,),
         )
-        for duration, message, was_silenced in test_cases:
-            ctx = MockContext()
+
+        targets = (MockTextChannel(), MockVoiceChannel(), None)
+
+        for (duration, message, was_silenced), target in itertools.product(test_cases, targets):
             with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=was_silenced):
-                with self.subTest(was_silenced=was_silenced, message=message, duration=duration):
-                    await self.cog.silence.callback(self.cog, ctx, duration)
-                    ctx.send.assert_called_once_with(message)
+                with self.subTest(was_silenced=was_silenced, target=target, message=message):
+                    with mock.patch.object(self.cog, "send_message") as send_message:
+                        ctx = MockContext()
+                        await self.cog.silence.callback(self.cog, ctx, target, duration)
+                        send_message.assert_called_once_with(
+                            message,
+                            ctx.channel,
+                            target or ctx.channel,
+                            alert_target=was_silenced
+                        )
+
+    @voice_sync_helper
+    async def test_sync_called(self, ctx, sync, kick):
+        """Tests if silence command calls sync on a voice channel."""
+        channel = MockVoiceChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=False)
+
+        sync.assert_awaited_once_with(self.cog, channel)
+        kick.assert_not_called()
+
+    @voice_sync_helper
+    async def test_kick_called(self, ctx, sync, kick):
+        """Tests if silence command calls kick on a voice channel."""
+        channel = MockVoiceChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=True)
+
+        kick.assert_awaited_once_with(channel)
+        sync.assert_not_called()
+
+    @voice_sync_helper
+    async def test_sync_not_called(self, ctx, sync, kick):
+        """Tests that silence command does not call sync on a text channel."""
+        channel = MockTextChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=False)
+
+        sync.assert_not_called()
+        kick.assert_not_called()
+
+    @voice_sync_helper
+    async def test_kick_not_called(self, ctx, sync, kick):
+        """Tests that silence command does not call kick on a text channel."""
+        channel = MockTextChannel()
+        await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=True)
+
+        sync.assert_not_called()
+        kick.assert_not_called()
 
     async def test_skipped_already_silenced(self):
         """Permissions were not set and `False` was returned for an already silenced channel."""
         subtests = (
-            (False, PermissionOverwrite(send_messages=False, add_reactions=False)),
-            (True, PermissionOverwrite(send_messages=True, add_reactions=True)),
-            (True, PermissionOverwrite(send_messages=False, add_reactions=False)),
+            (False, MockTextChannel(), PermissionOverwrite(send_messages=False, add_reactions=False)),
+            (True, MockTextChannel(), PermissionOverwrite(send_messages=True, add_reactions=True)),
+            (True, MockTextChannel(), PermissionOverwrite(send_messages=False, add_reactions=False)),
+            (False, MockVoiceChannel(), PermissionOverwrite(connect=False, speak=False)),
+            (True, MockVoiceChannel(), PermissionOverwrite(connect=True, speak=True)),
+            (True, MockVoiceChannel(), PermissionOverwrite(connect=False, speak=False)),
         )
 
-        for contains, overwrite in subtests:
-            with self.subTest(contains=contains, overwrite=overwrite):
+        for contains, channel, overwrite in subtests:
+            with self.subTest(contains=contains, is_text=isinstance(channel, MockTextChannel), overwrite=overwrite):
                 self.cog.scheduler.__contains__.return_value = contains
-                channel = MockTextChannel()
                 channel.overwrites_for.return_value = overwrite
 
                 self.assertFalse(await self.cog._set_silence_overwrites(channel))
                 channel.set_permissions.assert_not_called()
 
-    async def test_silenced_channel(self):
+    async def test_silenced_text_channel(self):
         """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
-        self.assertTrue(await self.cog._set_silence_overwrites(self.channel))
-        self.assertFalse(self.overwrite.send_messages)
-        self.assertFalse(self.overwrite.add_reactions)
-        self.channel.set_permissions.assert_awaited_once_with(
+        self.assertTrue(await self.cog._set_silence_overwrites(self.text_channel))
+        self.assertFalse(self.text_overwrite.send_messages)
+        self.assertFalse(self.text_overwrite.add_reactions)
+        self.text_channel.set_permissions.assert_awaited_once_with(
             self.cog._everyone_role,
-            overwrite=self.overwrite
+            overwrite=self.text_overwrite
         )
 
-    async def test_preserved_other_overwrites(self):
-        """Channel's other unrelated overwrites were not changed."""
-        prev_overwrite_dict = dict(self.overwrite)
-        await self.cog._set_silence_overwrites(self.channel)
-        new_overwrite_dict = dict(self.overwrite)
+    async def test_silenced_voice_channel_speak(self):
+        """Channel had `speak` permissions revoked for verified role."""
+        self.assertTrue(await self.cog._set_silence_overwrites(self.voice_channel))
+        self.assertFalse(self.voice_overwrite.speak)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite
+        )
+
+    async def test_silenced_voice_channel_full(self):
+        """Channel had `speak` and `connect` permissions revoked for verified role."""
+        self.assertTrue(await self.cog._set_silence_overwrites(self.voice_channel, kick=True))
+        self.assertFalse(self.voice_overwrite.speak or self.voice_overwrite.connect)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite
+        )
+
+    async def test_preserved_other_overwrites_text(self):
+        """Channel's other unrelated overwrites were not changed for a text channel mute."""
+        prev_overwrite_dict = dict(self.text_overwrite)
+        await self.cog._set_silence_overwrites(self.text_channel)
+        new_overwrite_dict = dict(self.text_overwrite)
 
         # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
         del prev_overwrite_dict['send_messages']
@@ -311,6 +567,20 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
+    async def test_preserved_other_overwrites_voice(self):
+        """Channel's other unrelated overwrites were not changed for a voice channel mute."""
+        prev_overwrite_dict = dict(self.voice_overwrite)
+        await self.cog._set_silence_overwrites(self.voice_channel)
+        new_overwrite_dict = dict(self.voice_overwrite)
+
+        # Remove 'connect' & 'speak' keys because they were changed by the method.
+        del prev_overwrite_dict['connect']
+        del prev_overwrite_dict['speak']
+        del new_overwrite_dict['connect']
+        del new_overwrite_dict['speak']
+
+        self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
+
     async def test_temp_not_added_to_notifier(self):
         """Channel was not added to notifier if a duration was set for the silence."""
         with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=True):
@@ -320,7 +590,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_indefinite_added_to_notifier(self):
         """Channel was added to notifier if a duration was not set for the silence."""
         with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=True):
-            await self.cog.silence.callback(self.cog, MockContext(), None)
+            await self.cog.silence.callback(self.cog, MockContext(), None, None)
             self.cog.notifier.add_channel.assert_called_once()
 
     async def test_silenced_not_added_to_notifier(self):
@@ -332,8 +602,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_cached_previous_overwrites(self):
         """Channel's previous overwrites were cached."""
         overwrite_json = '{"send_messages": true, "add_reactions": false}'
-        await self.cog._set_silence_overwrites(self.channel)
-        self.cog.previous_overwrites.set.assert_called_once_with(self.channel.id, overwrite_json)
+        await self.cog._set_silence_overwrites(self.text_channel)
+        self.cog.previous_overwrites.set.assert_awaited_once_with(self.text_channel.id, overwrite_json)
 
     @autospec(silence, "datetime")
     async def test_cached_unsilence_time(self, datetime_mock):
@@ -343,7 +613,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         timestamp = now_timestamp + duration * 60
         datetime_mock.now.return_value = datetime.fromtimestamp(now_timestamp, tz=timezone.utc)
 
-        ctx = MockContext(channel=self.channel)
+        ctx = MockContext(channel=self.text_channel)
         await self.cog.silence.callback(self.cog, ctx, duration)
 
         self.cog.unsilence_timestamps.set.assert_awaited_once_with(ctx.channel.id, timestamp)
@@ -351,26 +621,33 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_cached_indefinite_time(self):
         """A value of -1 was cached for a permanent silence."""
-        ctx = MockContext(channel=self.channel)
-        await self.cog.silence.callback(self.cog, ctx, None)
+        ctx = MockContext(channel=self.text_channel)
+        await self.cog.silence.callback(self.cog, ctx, None, None)
         self.cog.unsilence_timestamps.set.assert_awaited_once_with(ctx.channel.id, -1)
 
     async def test_scheduled_task(self):
         """An unsilence task was scheduled."""
-        ctx = MockContext(channel=self.channel, invoke=mock.MagicMock())
+        ctx = MockContext(channel=self.text_channel, invoke=mock.MagicMock())
 
         await self.cog.silence.callback(self.cog, ctx, 5)
 
         args = (300, ctx.channel.id, ctx.invoke.return_value)
         self.cog.scheduler.schedule_later.assert_called_once_with(*args)
-        ctx.invoke.assert_called_once_with(self.cog.unsilence)
+        ctx.invoke.assert_called_once_with(self.cog.unsilence, channel=ctx.channel)
 
     async def test_permanent_not_scheduled(self):
         """A task was not scheduled for a permanent silence."""
-        ctx = MockContext(channel=self.channel)
-        await self.cog.silence.callback(self.cog, ctx, None)
+        ctx = MockContext(channel=self.text_channel)
+        await self.cog.silence.callback(self.cog, ctx, None, None)
         self.cog.scheduler.schedule_later.assert_not_called()
 
+    async def test_indefinite_silence(self):
+        """Test silencing a channel forever."""
+        with mock.patch.object(self.cog, "_schedule_unsilence") as unsilence:
+            ctx = MockContext(channel=self.text_channel)
+            await self.cog.silence.callback(self.cog, ctx, -1)
+            unsilence.assert_awaited_once_with(ctx, ctx.channel, None)
+
 
 @autospec(silence.Silence, "unsilence_timestamps", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
@@ -391,9 +668,13 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
         self.cog.scheduler.__contains__.return_value = True
         overwrites_cache.get.return_value = '{"send_messages": true, "add_reactions": false}'
-        self.channel = MockTextChannel()
-        self.overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
-        self.channel.overwrites_for.return_value = self.overwrite
+        self.text_channel = MockTextChannel()
+        self.text_overwrite = PermissionOverwrite(send_messages=False, add_reactions=False)
+        self.text_channel.overwrites_for.return_value = self.text_overwrite
+
+        self.voice_channel = MockVoiceChannel()
+        self.voice_overwrite = PermissionOverwrite(connect=True, speak=True)
+        self.voice_channel.overwrites_for.return_value = self.voice_overwrite
 
     async def test_sent_correct_message(self):
         """Appropriate failure/success message was sent by the command."""
@@ -401,88 +682,128 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         test_cases = (
             (True, silence.MSG_UNSILENCE_SUCCESS, unsilenced_overwrite),
             (False, silence.MSG_UNSILENCE_FAIL, unsilenced_overwrite),
-            (False, silence.MSG_UNSILENCE_MANUAL, self.overwrite),
+            (False, silence.MSG_UNSILENCE_MANUAL, self.text_overwrite),
             (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(send_messages=False)),
             (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(add_reactions=False)),
         )
-        for was_unsilenced, message, overwrite in test_cases:
+
+        targets = (None, MockTextChannel())
+
+        for (was_unsilenced, message, overwrite), target in itertools.product(test_cases, targets):
             ctx = MockContext()
-            with self.subTest(was_unsilenced=was_unsilenced, message=message, overwrite=overwrite):
-                with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
-                    ctx.channel.overwrites_for.return_value = overwrite
-                    await self.cog.unsilence.callback(self.cog, ctx)
-                    ctx.channel.send.assert_called_once_with(message)
+            ctx.channel.overwrites_for.return_value = overwrite
+            if target:
+                target.overwrites_for.return_value = overwrite
+
+            with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
+                with mock.patch.object(self.cog, "send_message") as send_message:
+                    with self.subTest(was_unsilenced=was_unsilenced, overwrite=overwrite, target=target):
+                        await self.cog.unsilence.callback(self.cog, ctx, channel=target)
+
+                        call_args = (message, ctx.channel, target or ctx.channel)
+                        send_message.assert_awaited_once_with(*call_args, alert_target=was_unsilenced)
 
     async def test_skipped_already_unsilenced(self):
         """Permissions were not set and `False` was returned for an already unsilenced channel."""
         self.cog.scheduler.__contains__.return_value = False
         self.cog.previous_overwrites.get.return_value = None
-        channel = MockTextChannel()
 
-        self.assertFalse(await self.cog._unsilence(channel))
-        channel.set_permissions.assert_not_called()
+        for channel in (MockVoiceChannel(), MockTextChannel()):
+            with self.subTest(channel=channel):
+                self.assertFalse(await self.cog._unsilence(channel))
+                channel.set_permissions.assert_not_called()
 
-    async def test_restored_overwrites(self):
-        """Channel's `send_message` and `add_reactions` overwrites were restored."""
-        await self.cog._unsilence(self.channel)
-        self.channel.set_permissions.assert_awaited_once_with(
+    async def test_restored_overwrites_text(self):
+        """Text channel's `send_message` and `add_reactions` overwrites were restored."""
+        await self.cog._unsilence(self.text_channel)
+        self.text_channel.set_permissions.assert_awaited_once_with(
             self.cog._everyone_role,
-            overwrite=self.overwrite,
+            overwrite=self.text_overwrite,
+        )
+
+        # Recall that these values are determined by the fixture.
+        self.assertTrue(self.text_overwrite.send_messages)
+        self.assertFalse(self.text_overwrite.add_reactions)
+
+    async def test_restored_overwrites_voice(self):
+        """Voice channel's `connect` and `speak` overwrites were restored."""
+        await self.cog._unsilence(self.voice_channel)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite,
         )
 
         # Recall that these values are determined by the fixture.
-        self.assertTrue(self.overwrite.send_messages)
-        self.assertFalse(self.overwrite.add_reactions)
+        self.assertTrue(self.voice_overwrite.connect)
+        self.assertTrue(self.voice_overwrite.speak)
 
-    async def test_cache_miss_used_default_overwrites(self):
-        """Both overwrites were set to None due previous values not being found in the cache."""
+    async def test_cache_miss_used_default_overwrites_text(self):
+        """Text overwrites were set to None due previous values not being found in the cache."""
         self.cog.previous_overwrites.get.return_value = None
 
-        await self.cog._unsilence(self.channel)
-        self.channel.set_permissions.assert_awaited_once_with(
+        await self.cog._unsilence(self.text_channel)
+        self.text_channel.set_permissions.assert_awaited_once_with(
             self.cog._everyone_role,
-            overwrite=self.overwrite,
+            overwrite=self.text_overwrite,
+        )
+
+        self.assertIsNone(self.text_overwrite.send_messages)
+        self.assertIsNone(self.text_overwrite.add_reactions)
+
+    async def test_cache_miss_used_default_overwrites_voice(self):
+        """Voice overwrites were set to None due previous values not being found in the cache."""
+        self.cog.previous_overwrites.get.return_value = None
+
+        await self.cog._unsilence(self.voice_channel)
+        self.voice_channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_voice_role,
+            overwrite=self.voice_overwrite,
         )
 
-        self.assertIsNone(self.overwrite.send_messages)
-        self.assertIsNone(self.overwrite.add_reactions)
+        self.assertIsNone(self.voice_overwrite.connect)
+        self.assertIsNone(self.voice_overwrite.speak)
 
-    async def test_cache_miss_sent_mod_alert(self):
-        """A message was sent to the mod alerts channel."""
+    async def test_cache_miss_sent_mod_alert_text(self):
+        """A message was sent to the mod alerts channel upon muting a text channel."""
         self.cog.previous_overwrites.get.return_value = None
+        await self.cog._unsilence(self.text_channel)
+        self.cog._mod_alerts_channel.send.assert_awaited_once()
 
-        await self.cog._unsilence(self.channel)
+    async def test_cache_miss_sent_mod_alert_voice(self):
+        """A message was sent to the mod alerts channel upon muting a voice channel."""
+        self.cog.previous_overwrites.get.return_value = None
+        await self.cog._unsilence(MockVoiceChannel())
         self.cog._mod_alerts_channel.send.assert_awaited_once()
 
     async def test_removed_notifier(self):
         """Channel was removed from `notifier`."""
-        await self.cog._unsilence(self.channel)
-        self.cog.notifier.remove_channel.assert_called_once_with(self.channel)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.notifier.remove_channel.assert_called_once_with(self.text_channel)
 
     async def test_deleted_cached_overwrite(self):
         """Channel was deleted from the overwrites cache."""
-        await self.cog._unsilence(self.channel)
-        self.cog.previous_overwrites.delete.assert_awaited_once_with(self.channel.id)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.previous_overwrites.delete.assert_awaited_once_with(self.text_channel.id)
 
     async def test_deleted_cached_time(self):
         """Channel was deleted from the timestamp cache."""
-        await self.cog._unsilence(self.channel)
-        self.cog.unsilence_timestamps.delete.assert_awaited_once_with(self.channel.id)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.unsilence_timestamps.delete.assert_awaited_once_with(self.text_channel.id)
 
     async def test_cancelled_task(self):
         """The scheduled unsilence task should be cancelled."""
-        await self.cog._unsilence(self.channel)
-        self.cog.scheduler.cancel.assert_called_once_with(self.channel.id)
+        await self.cog._unsilence(self.text_channel)
+        self.cog.scheduler.cancel.assert_called_once_with(self.text_channel.id)
 
-    async def test_preserved_other_overwrites(self):
-        """Channel's other unrelated overwrites were not changed, including cache misses."""
+    async def test_preserved_other_overwrites_text(self):
+        """Text channel's other unrelated overwrites were not changed, including cache misses."""
         for overwrite_json in ('{"send_messages": true, "add_reactions": null}', None):
             with self.subTest(overwrite_json=overwrite_json):
                 self.cog.previous_overwrites.get.return_value = overwrite_json
 
-                prev_overwrite_dict = dict(self.overwrite)
-                await self.cog._unsilence(self.channel)
-                new_overwrite_dict = dict(self.overwrite)
+                prev_overwrite_dict = dict(self.text_overwrite)
+                await self.cog._unsilence(self.text_channel)
+                new_overwrite_dict = dict(self.text_overwrite)
 
                 # Remove these keys because they were modified by the unsilence.
                 del prev_overwrite_dict['send_messages']
@@ -491,3 +812,114 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
                 del new_overwrite_dict['add_reactions']
 
                 self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
+
+    async def test_preserved_other_overwrites_voice(self):
+        """Voice channel's other unrelated overwrites were not changed, including cache misses."""
+        for overwrite_json in ('{"connect": true, "speak": true}', None):
+            with self.subTest(overwrite_json=overwrite_json):
+                self.cog.previous_overwrites.get.return_value = overwrite_json
+
+                prev_overwrite_dict = dict(self.voice_overwrite)
+                await self.cog._unsilence(self.voice_channel)
+                new_overwrite_dict = dict(self.voice_overwrite)
+
+                # Remove these keys because they were modified by the unsilence.
+                del prev_overwrite_dict['connect']
+                del prev_overwrite_dict['speak']
+                del new_overwrite_dict['connect']
+                del new_overwrite_dict['speak']
+
+                self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
+
+    async def test_unsilence_role(self):
+        """Tests unsilence_wrapper applies permission to the correct role."""
+        test_cases = (
+            (MockTextChannel(), self.cog.bot.get_guild(Guild.id).default_role),
+            (MockVoiceChannel(), self.cog.bot.get_guild(Guild.id).get_role(Roles.voice_verified))
+        )
+
+        for channel, role in test_cases:
+            with self.subTest(channel=channel, role=role):
+                await self.cog._unsilence_wrapper(channel, MockContext())
+                channel.overwrites_for.assert_called_with(role)
+
+
+class SendMessageTests(unittest.IsolatedAsyncioTestCase):
+    """Unittests for the send message helper function."""
+
+    def setUp(self) -> None:
+        self.bot = MockBot()
+        self.cog = silence.Silence(self.bot)
+
+        self.text_channels = [MockTextChannel() for _ in range(2)]
+        self.bot.get_channel.return_value = self.text_channels[1]
+
+        self.voice_channel = MockVoiceChannel()
+
+    async def test_send_to_channel(self):
+        """Tests a basic case for the send function."""
+        message = "Test basic message."
+        await self.cog.send_message(message, *self.text_channels, alert_target=False)
+
+        self.text_channels[0].send.assert_awaited_once_with(message)
+        self.text_channels[1].send.assert_not_called()
+
+    async def test_send_to_multiple_channels(self):
+        """Tests sending messages to two channels."""
+        message = "Test basic message."
+        await self.cog.send_message(message, *self.text_channels, alert_target=True)
+
+        self.text_channels[0].send.assert_awaited_once_with(message)
+        self.text_channels[1].send.assert_awaited_once_with(message)
+
+    async def test_duration_replacement(self):
+        """Tests that the channel name was set correctly for one target channel."""
+        message = "Current. The following should be replaced: {channel}."
+        await self.cog.send_message(message, *self.text_channels, alert_target=False)
+
+        updated_message = message.format(channel=self.text_channels[0].mention)
+        self.text_channels[0].send.assert_awaited_once_with(updated_message)
+        self.text_channels[1].send.assert_not_called()
+
+    async def test_name_replacement_multiple_channels(self):
+        """Tests that the channel name was set correctly for two channels."""
+        message = "Current. The following should be replaced: {channel}."
+        await self.cog.send_message(message, *self.text_channels, alert_target=True)
+
+        self.text_channels[0].send.assert_awaited_once_with(message.format(channel=self.text_channels[0].mention))
+        self.text_channels[1].send.assert_awaited_once_with(message.format(channel="current channel"))
+
+    async def test_silence_voice(self):
+        """Tests that the correct message was sent when a voice channel is muted without alerting."""
+        message = "This should show up just here."
+        await self.cog.send_message(message, self.text_channels[0], self.voice_channel, alert_target=False)
+        self.text_channels[0].send.assert_awaited_once_with(message)
+        self.text_channels[1].send.assert_not_called()
+
+    async def test_silence_voice_alert(self):
+        """Tests that the correct message was sent when a voice channel is muted with alerts."""
+        with unittest.mock.patch.object(silence, "VOICE_CHANNELS") as mock_voice_channels:
+            mock_voice_channels.get.return_value = self.text_channels[1].id
+
+            message = "This should show up as {channel}."
+            await self.cog.send_message(message, self.text_channels[0], self.voice_channel, alert_target=True)
+
+        updated_message = message.format(channel=self.voice_channel.mention)
+        self.text_channels[0].send.assert_awaited_once_with(updated_message)
+        self.text_channels[1].send.assert_awaited_once_with(updated_message)
+
+        mock_voice_channels.get.assert_called_once_with(self.voice_channel.id)
+
+    async def test_silence_voice_sibling_channel(self):
+        """Tests silencing a voice channel from the related text channel."""
+        with unittest.mock.patch.object(silence, "VOICE_CHANNELS") as mock_voice_channels:
+            mock_voice_channels.get.return_value = self.text_channels[1].id
+
+            message = "This should show up as {channel}."
+            await self.cog.send_message(message, self.text_channels[1], self.voice_channel, alert_target=True)
+
+            updated_message = message.format(channel=self.voice_channel.mention)
+            self.text_channels[1].send.assert_awaited_once_with(updated_message)
+
+            mock_voice_channels.get.assert_called_once_with(self.voice_channel.id)
+            self.bot.get_channel.assert_called_once_with(self.text_channels[1].id)
diff --git a/tests/bot/exts/utils/test_jams.py b/tests/bot/exts/utils/test_jams.py
index 85d6a1173..368a15476 100644
--- a/tests/bot/exts/utils/test_jams.py
+++ b/tests/bot/exts/utils/test_jams.py
@@ -2,10 +2,24 @@ import unittest
 from unittest.mock import AsyncMock, MagicMock, create_autospec
 
 from discord import CategoryChannel
+from discord.ext.commands import BadArgument
 
 from bot.constants import Roles
 from bot.exts.utils import jams
-from tests.helpers import MockBot, MockContext, MockGuild, MockMember, MockRole, MockTextChannel
+from tests.helpers import (
+    MockAttachment, MockBot, MockCategoryChannel, MockContext,
+    MockGuild, MockMember, MockRole, MockTextChannel
+)
+
+TEST_CSV = b"""\
+Team Name,Team Member Discord ID,Team Leader
+Annoyed Alligators,12345,Y
+Annoyed Alligators,54321,N
+Oscillating Otters,12358,Y
+Oscillating Otters,74832,N
+Oscillating Otters,19903,N
+Annoyed Alligators,11111,N
+"""
 
 
 def get_mock_category(channel_count: int, name: str) -> CategoryChannel:
@@ -17,8 +31,8 @@ def get_mock_category(channel_count: int, name: str) -> CategoryChannel:
     return category
 
 
-class JamCreateTeamTests(unittest.IsolatedAsyncioTestCase):
-    """Tests for `createteam` command."""
+class JamCodejamCreateTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for `codejam create` command."""
 
     def setUp(self):
         self.bot = MockBot()
@@ -28,60 +42,64 @@ class JamCreateTeamTests(unittest.IsolatedAsyncioTestCase):
         self.ctx = MockContext(bot=self.bot, author=self.command_user, guild=self.guild)
         self.cog = jams.CodeJams(self.bot)
 
-    async def test_too_small_amount_of_team_members_passed(self):
-        """Should `ctx.send` and exit early when too small amount of members."""
-        for case in (1, 2):
-            with self.subTest(amount_of_members=case):
-                self.cog.create_channels = AsyncMock()
-                self.cog.add_roles = AsyncMock()
+    async def test_message_without_attachments(self):
+        """If no link or attachments are provided, commands.BadArgument should be raised."""
+        self.ctx.message.attachments = []
 
-                self.ctx.reset_mock()
-                members = (MockMember() for _ in range(case))
-                await self.cog.createteam(self.cog, self.ctx, "foo", members)
+        with self.assertRaises(BadArgument):
+            await self.cog.create(self.cog, self.ctx, None)
 
-                self.ctx.send.assert_awaited_once()
-                self.cog.create_channels.assert_not_awaited()
-                self.cog.add_roles.assert_not_awaited()
+    async def test_result_sending(self):
+        """Should call `ctx.send` when everything goes right."""
+        self.ctx.message.attachments = [MockAttachment()]
+        self.ctx.message.attachments[0].read = AsyncMock()
+        self.ctx.message.attachments[0].read.return_value = TEST_CSV
+
+        team_leaders = MockRole()
+
+        self.guild.get_member.return_value = MockMember()
 
-    async def test_duplicate_members_provided(self):
-        """Should `ctx.send` and exit early because duplicate members provided and total there is only 1 member."""
-        self.cog.create_channels = AsyncMock()
+        self.ctx.guild.create_role = AsyncMock()
+        self.ctx.guild.create_role.return_value = team_leaders
+        self.cog.create_team_channel = AsyncMock()
+        self.cog.create_team_leader_channel = AsyncMock()
         self.cog.add_roles = AsyncMock()
 
-        member = MockMember()
-        await self.cog.createteam(self.cog, self.ctx, "foo", (member for _ in range(5)))
+        await self.cog.create(self.cog, self.ctx, None)
 
+        self.cog.create_team_channel.assert_awaited()
+        self.cog.create_team_leader_channel.assert_awaited_once_with(
+            self.ctx.guild, team_leaders
+        )
         self.ctx.send.assert_awaited_once()
-        self.cog.create_channels.assert_not_awaited()
-        self.cog.add_roles.assert_not_awaited()
-
-    async def test_result_sending(self):
-        """Should call `ctx.send` when everything goes right."""
-        self.cog.create_channels = AsyncMock()
-        self.cog.add_roles = AsyncMock()
 
-        members = [MockMember() for _ in range(5)]
-        await self.cog.createteam(self.cog, self.ctx, "foo", members)
+    async def test_link_returning_non_200_status(self):
+        """When the URL passed returns a non 200 status, it should send a message informing them."""
+        self.bot.http_session.get.return_value = mock = MagicMock()
+        mock.status = 404
+        await self.cog.create(self.cog, self.ctx, "https://not-a-real-link.com")
 
-        self.cog.create_channels.assert_awaited_once()
-        self.cog.add_roles.assert_awaited_once()
         self.ctx.send.assert_awaited_once()
 
     async def test_category_doesnt_exist(self):
         """Should create a new code jam category."""
         subtests = (
             [],
-            [get_mock_category(jams.MAX_CHANNELS - 1, jams.CATEGORY_NAME)],
+            [get_mock_category(jams.MAX_CHANNELS, jams.CATEGORY_NAME)],
             [get_mock_category(jams.MAX_CHANNELS - 2, "other")],
         )
 
+        self.cog.send_status_update = AsyncMock()
+
         for categories in subtests:
+            self.cog.send_status_update.reset_mock()
             self.guild.reset_mock()
             self.guild.categories = categories
 
             with self.subTest(categories=categories):
                 actual_category = await self.cog.get_category(self.guild)
 
+                self.cog.send_status_update.assert_called_once()
                 self.guild.create_category_channel.assert_awaited_once()
                 category_overwrites = self.guild.create_category_channel.call_args[1]["overwrites"]
 
@@ -103,62 +121,47 @@ class JamCreateTeamTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_channel_overwrites(self):
         """Should have correct permission overwrites for users and roles."""
-        leader = MockMember()
-        members = [leader] + [MockMember() for _ in range(4)]
+        leader = (MockMember(), True)
+        members = [leader] + [(MockMember(), False) for _ in range(4)]
         overwrites = self.cog.get_overwrites(members, self.guild)
 
-        # Leader permission overwrites
-        self.assertTrue(overwrites[leader].manage_messages)
-        self.assertTrue(overwrites[leader].read_messages)
-        self.assertTrue(overwrites[leader].manage_webhooks)
-        self.assertTrue(overwrites[leader].connect)
-
-        # Other members permission overwrites
-        for member in members[1:]:
+        for member, _ in members:
             self.assertTrue(overwrites[member].read_messages)
-            self.assertTrue(overwrites[member].connect)
-
-        # Everyone role overwrite
-        self.assertFalse(overwrites[self.guild.default_role].read_messages)
-        self.assertFalse(overwrites[self.guild.default_role].connect)
 
     async def test_team_channels_creation(self):
-        """Should create new voice and text channel for team."""
-        members = [MockMember() for _ in range(5)]
+        """Should create a text channel for a team."""
+        team_leaders = MockRole()
+        members = [(MockMember(), True)] + [(MockMember(), False) for _ in range(5)]
+        category = MockCategoryChannel()
+        category.create_text_channel = AsyncMock()
 
         self.cog.get_overwrites = MagicMock()
         self.cog.get_category = AsyncMock()
-        self.ctx.guild.create_text_channel.return_value = MockTextChannel(mention="foobar-channel")
-        actual = await self.cog.create_channels(self.guild, "my-team", members)
+        self.cog.get_category.return_value = category
+        self.cog.add_team_leader_roles = AsyncMock()
 
-        self.assertEqual("foobar-channel", actual)
+        await self.cog.create_team_channel(self.guild, "my-team", members, team_leaders)
+        self.cog.add_team_leader_roles.assert_awaited_once_with(members, team_leaders)
         self.cog.get_overwrites.assert_called_once_with(members, self.guild)
         self.cog.get_category.assert_awaited_once_with(self.guild)
 
-        self.guild.create_text_channel.assert_awaited_once_with(
+        category.create_text_channel.assert_awaited_once_with(
             "my-team",
-            overwrites=self.cog.get_overwrites.return_value,
-            category=self.cog.get_category.return_value
-        )
-        self.guild.create_voice_channel.assert_awaited_once_with(
-            "My Team",
-            overwrites=self.cog.get_overwrites.return_value,
-            category=self.cog.get_category.return_value
+            overwrites=self.cog.get_overwrites.return_value
         )
 
     async def test_jam_roles_adding(self):
         """Should add team leader role to leader and jam role to every team member."""
         leader_role = MockRole(name="Team Leader")
-        jam_role = MockRole(name="Jammer")
-        self.guild.get_role.side_effect = [leader_role, jam_role]
 
         leader = MockMember()
-        members = [leader] + [MockMember() for _ in range(4)]
-        await self.cog.add_roles(self.guild, members)
+        members = [(leader, True)] + [(MockMember(), False) for _ in range(4)]
+        await self.cog.add_team_leader_roles(members, leader_role)
 
-        leader.add_roles.assert_any_await(leader_role)
-        for member in members:
-            member.add_roles.assert_any_await(jam_role)
+        leader.add_roles.assert_awaited_once_with(leader_role)
+        for member, is_leader in members:
+            if not is_leader:
+                member.add_roles.assert_not_awaited()
 
 
 class CodeJamSetup(unittest.TestCase):
diff --git a/tests/bot/test_converters.py b/tests/bot/test_converters.py
index 4af84dde5..2a1c4e543 100644
--- a/tests/bot/test_converters.py
+++ b/tests/bot/test_converters.py
@@ -291,7 +291,7 @@ class ConverterTests(unittest.IsolatedAsyncioTestCase):
             ("10", 10),
             ("5m", 5),
             ("5M", 5),
-            ("forever", None),
+            ("forever", -1),
         )
         converter = HushDurationConverter()
         for minutes_string, expected_minutes in test_values:
diff --git a/tests/helpers.py b/tests/helpers.py
index e3dc5fe5b..3978076ed 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -16,7 +16,6 @@ from bot.async_stats import AsyncStatsClient
 from bot.bot import Bot
 from tests._autospec import autospec  # noqa: F401 other modules import it via this module
 
-
 for logger in logging.Logger.manager.loggerDict.values():
     # Set all loggers to CRITICAL by default to prevent screen clutter during testing
 
@@ -320,7 +319,10 @@ channel_data = {
 }
 state = unittest.mock.MagicMock()
 guild = unittest.mock.MagicMock()
-channel_instance = discord.TextChannel(state=state, guild=guild, data=channel_data)
+text_channel_instance = discord.TextChannel(state=state, guild=guild, data=channel_data)
+
+channel_data["type"] = "VoiceChannel"
+voice_channel_instance = discord.VoiceChannel(state=state, guild=guild, data=channel_data)
 
 
 class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
@@ -330,7 +332,24 @@ class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
     Instances of this class will follow the specifications of `discord.TextChannel` instances. For
     more information, see the `MockGuild` docstring.
     """
-    spec_set = channel_instance
+    spec_set = text_channel_instance
+
+    def __init__(self, **kwargs) -> None:
+        default_kwargs = {'id': next(self.discord_id), 'name': 'channel', 'guild': MockGuild()}
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
+
+        if 'mention' not in kwargs:
+            self.mention = f"#{self.name}"
+
+
+class MockVoiceChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
+    """
+    A MagicMock subclass to mock VoiceChannel objects.
+
+    Instances of this class will follow the specifications of `discord.VoiceChannel` instances. For
+    more information, see the `MockGuild` docstring.
+    """
+    spec_set = voice_channel_instance
 
     def __init__(self, **kwargs) -> None:
         default_kwargs = {'id': next(self.discord_id), 'name': 'channel', 'guild': MockGuild()}
@@ -361,6 +380,27 @@ class MockDMChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
         super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
 
+# Create CategoryChannel instance to get a realistic MagicMock of `discord.CategoryChannel`
+category_channel_data = {
+    'id': 1,
+    'type': discord.ChannelType.category,
+    'name': 'category',
+    'position': 1,
+}
+
+state = unittest.mock.MagicMock()
+guild = unittest.mock.MagicMock()
+category_channel_instance = discord.CategoryChannel(
+    state=state, guild=guild, data=category_channel_data
+)
+
+
+class MockCategoryChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
+    def __init__(self, **kwargs) -> None:
+        default_kwargs = {'id': next(self.discord_id)}
+        super().__init__(**collections.ChainMap(default_kwargs, kwargs))
+
+
 # Create a Message instance to get a realistic MagicMock of `discord.Message`
 message_data = {
     'id': 1,
@@ -403,6 +443,7 @@ class MockContext(CustomMockMixin, unittest.mock.MagicMock):
         self.guild = kwargs.get('guild', MockGuild())
         self.author = kwargs.get('author', MockMember())
         self.channel = kwargs.get('channel', MockTextChannel())
+        self.message = kwargs.get('message', MockMessage())
         self.invoked_from_error_handler = kwargs.get('invoked_from_error_handler', False)
author	Matteo Bertucci <[email protected]>	2021-07-20 08:52:06 +0200
committer	GitHub <[email protected]>	2021-07-20 08:52:06 +0200
commit	7b30ea65acae3a7915d62b478af1525dbaed70a3 (patch)
tree	127d5a27e18175f1ff60242c1a61f9a2c05b23b7
parent	Enabled charinfo for discord_py channel. (diff)
parent	feat: add for-else tag (#1643) (diff)