Merge branch 'main' into fix-whitelist-inheritance

48 files changed, 2094 insertions, 1441 deletions

diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml
index 756b3c16..8bfe25fa 100644
--- a/.github/workflows/lint.yaml
+++ b/.github/workflows/lint.yaml
@@ -12,7 +12,7 @@ concurrency:
 
 jobs:
   lint:
-    name: Run pre-commit & flake8
+    name: Run linting & tests
     runs-on: ubuntu-latest
     env:
       # List of licenses that are compatible with the MIT License and
@@ -27,52 +27,15 @@ jobs:
         Public Domain;
         Python Software Foundation License
 
-# Configure pip to cache dependencies and do a user install
-      PIP_NO_CACHE_DIR: false
-      PIP_USER: 1
-
-      # Disable Poetry virtualenv creation
-      POETRY_VIRTUALENVS_CREATE: false
-
-      # Specify explicit paths for python dependencies and the pre-commit
-      # environment so we know which directories to cache
-      PYTHONUSERBASE: ${{ github.workspace }}/.cache/py-user-base
-      PRE_COMMIT_HOME: ${{ github.workspace }}/.cache/pre-commit-cache
-
     steps:
-      - name: Add custom PYTHONUSERBASE to PATH
-        run: echo '${{ env.PYTHONUSERBASE }}/bin/' >> $GITHUB_PATH
-
       - name: Checkout repository
         uses: actions/checkout@v2
 
-      - name: Setup python
-        id: python
-        uses: actions/setup-python@v2
+      - name: Install Python Dependencies
+        uses: HassanAbouelela/actions/setup-python@setup-python_v1.3.1
         with:
-          python-version: '3.9'
-
-      # This step caches our Python dependencies. To make sure we
-      # only restore a cache when the dependencies, the python version,
-      # the runner operating system, and the dependency location haven't
-      # changed, we create a cache key that is a composite of those states.
-      #
-      # Only when the context is exactly the same, we will restore the cache.
-      - name: Python Dependency Caching
-        uses: actions/cache@v2
-        id: python_cache
-        with:
-          path: ${{ env.PYTHONUSERBASE }}
-          key: "python-0-${{ runner.os }}-${{ env.PYTHONUSERBASE }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./pyproject.toml', './poetry.lock') }}"
-
-      # Install our dependencies if we did not restore a dependency cache
-      - name: Install dependencies using poetry
-        if: steps.python_cache.outputs.cache-hit != 'true'
-        run: |
-          pip install poetry
-          poetry install --no-interaction --no-ansi
+          dev: true
+          python_version: "3.9"
 
       # Check all of our dev dependencies are compatible with the MIT license.
       # If you added a new dependencies that is being rejected,
@@ -83,22 +46,19 @@ jobs:
           pip-licenses --allow-only="$ALLOWED_LICENSE" \
             --package $(poetry export -f requirements.txt --without-hashes | sed "s/==.*//g" | tr "\n" " ")
 
-      # This step caches our pre-commit environment. To make sure we
-      # do create a new environment when our pre-commit setup changes,
-      # we create a cache key based on relevant factors.
-      - name: Pre-commit Environment Caching
-        uses: actions/cache@v2
-        with:
-          path: ${{ env.PRE_COMMIT_HOME }}
-          key: "precommit-0-${{ runner.os }}-${{ env.PRE_COMMIT_HOME }}-\
-          ${{ steps.python.outputs.python-version }}-\
-          ${{ hashFiles('./.pre-commit-config.yaml') }}"
+      # Attempt to run the bot. Setting `IN_CI` to true, so bot.run() is never called.
+      # This is to catch import and cog setup errors that may appear in PRs, to avoid crash loops if merged.
+      - name: Attempt bot setup
+        run: "python -m bot"
+        env:
+          USE_FAKEREDIS: true
+          IN_CI: true
+
 
       # We will not run `flake8` here, as we will use a separate flake8
-      # action. As pre-commit does not support user installs, we set
-      # PIP_USER=0 to not do a user install.
+      # action.
       - name: Run pre-commit hooks
-        run: export PIP_USER=0; SKIP=flake8 pre-commit run --all-files
+        run: SKIP=flake8 pre-commit run --all-files
 
       # Run flake8 and have it format the linting errors in the format of
       # the GitHub Workflow command to register error annotations. This
diff --git a/.gitignore b/.gitignore
index ce122d29..665df8cc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,7 @@
 # bot (project-specific)
 log/*
 data/*
-_latex_cache/*
+bot/exts/fun/_latex_cache/*
 
 
 
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index a2e9a398..2131db72 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -13,7 +13,7 @@ repos:
     hooks:
       - id: python-check-blanket-noqa
   - repo: https://github.com/pycqa/isort
-    rev: 5.8.0
+    rev: 5.10.1
     hooks:
       - id: isort
         name: isort (python)
diff --git a/Dockerfile b/Dockerfile
index 44ef0574..10e8bbd4 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,20 +1,9 @@
-FROM --platform=linux/amd64 python:3.9-slim
-
-# Set pip to have cleaner logs and no saved cache
-ENV PIP_NO_CACHE_DIR=false \
-    POETRY_VIRTUALENVS_CREATE=false
-
-# Install Poetry
-RUN pip install --upgrade poetry
+FROM --platform=linux/amd64 ghcr.io/chrislovering/python-poetry-base:3.9-slim
 
+# Install dependencies
 WORKDIR /bot
-
-# Copy dependencies and lockfile
-COPY pyproject.toml poetry.lock /bot/
-
-# Install dependencies and lockfile, excluding development
-# dependencies,
-RUN poetry install --no-dev --no-interaction --no-ansi
+COPY pyproject.toml poetry.lock ./
+RUN poetry install --without dev
 
 # Set SHA build argument
 ARG git_sha="development"
@@ -24,4 +13,5 @@ ENV GIT_SHA=$git_sha
 COPY . .
 
 # Start the bot
+ENTRYPOINT ["poetry", "run"]
 CMD ["python", "-m", "bot"]
diff --git a/bot/__main__.py b/bot/__main__.py
index 6889fe2b..bd6c70ee 100644
--- a/bot/__main__.py
+++ b/bot/__main__.py
@@ -12,4 +12,8 @@ bot.add_check(whitelist_check(channels=WHITELISTED_CHANNELS, roles=STAFF_ROLES))
 for ext in walk_extensions():
     bot.load_extension(ext)
 
-bot.run(Client.token)
+if not Client.in_ci:
+    # Manually enable the message content intent. This is required until the below PR is merged
+    # https://github.com/python-discord/sir-lancebot/pull/1092
+    bot._connection._intents.value += 1 << 15
+    bot.run(Client.token)
diff --git a/bot/constants.py b/bot/constants.py
index 3b426c47..eb9ee4b3 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -12,6 +12,7 @@ __all__ = (
     "Channels",
     "Categories",
     "Client",
+    "Logging",
     "Colours",
     "Emojis",
     "Icons",
@@ -23,7 +24,7 @@ __all__ = (
     "Reddit",
     "RedisConfig",
     "RedirectOutput",
-    "PYTHON_PREFIX"
+    "PYTHON_PREFIX",
     "MODERATION_ROLES",
     "STAFF_ROLES",
     "WHITELISTED_CHANNELS",
@@ -37,6 +38,7 @@ log = logging.getLogger(__name__)
 
 PYTHON_PREFIX = "!"
 
+
 @dataclasses.dataclass
 class AdventOfCodeLeaderboard:
     id: str
@@ -53,7 +55,7 @@ class AdventOfCodeLeaderboard:
     def session(self) -> str:
         """Return either the actual `session` cookie or the fallback cookie."""
         if self.use_fallback_session:
-            log.info(f"Returning fallback cookie for board `{self.id}`.")
+            log.trace(f"Returning fallback cookie for board `{self.id}`.")
             return AdventOfCode.fallback_session
 
         return self._session
@@ -107,8 +109,11 @@ class Cats:
 class Channels(NamedTuple):
     advent_of_code = int(environ.get("AOC_CHANNEL_ID", 897932085766004786))
     advent_of_code_commands = int(environ.get("AOC_COMMANDS_CHANNEL_ID", 897932607545823342))
-    bot = 267659945086812160
+    algos_and_data_structs = 650401909852864553
+    bot_commands = 267659945086812160
+    community_meta = 267659945086812160
     organisation = 551789653284356126
+    data_science_and_ai = 366673247892275221
     devlog = int(environ.get("CHANNEL_DEVLOG", 622895325144940554))
     dev_contrib = 635950537262759947
     mod_meta = 775412552795947058
@@ -116,7 +121,7 @@ class Channels(NamedTuple):
     off_topic_0 = 291284109232308226
     off_topic_1 = 463035241142026251
     off_topic_2 = 463035268514185226
-    community_bot_commands = int(environ.get("CHANNEL_COMMUNITY_BOT_COMMANDS", 607247579608121354))
+    sir_lancebot_playground = int(environ.get("CHANNEL_COMMUNITY_BOT_COMMANDS", 607247579608121354))
     voice_chat_0 = 412357430186344448
     voice_chat_1 = 799647045886541885
     staff_voice = 541638762007101470
@@ -130,23 +135,31 @@ class Categories(NamedTuple):
     media = 799054581991997460
     staff = 364918151625965579
 
+
 codejam_categories_name = "Code Jam"  # Name of the codejam team categories
 
+
 class Client(NamedTuple):
     name = "Sir Lancebot"
     guild = int(environ.get("BOT_GUILD", 267624335836053506))
     prefix = environ.get("PREFIX", ".")
     token = environ.get("BOT_TOKEN")
     debug = environ.get("BOT_DEBUG", "true").lower() == "true"
-    file_logs = environ.get("FILE_LOGS", "false").lower() == "true"
+    in_ci = environ.get("IN_CI", "false").lower() == "true"
     github_bot_repo = "https://github.com/python-discord/sir-lancebot"
     # Override seasonal locks: 1 (January) to 12 (December)
     month_override = int(environ["MONTH_OVERRIDE"]) if "MONTH_OVERRIDE" in environ else None
+
+
+class Logging(NamedTuple):
+    debug = Client.debug
+    file_logs = environ.get("FILE_LOGS", "false").lower() == "true"
     trace_loggers = environ.get("BOT_TRACE_LOGGERS")
 
 
 class Colours:
     blue = 0x0279FD
+    twitter_blue = 0x1DA1F2
     bright_green = 0x01D277
     dark_green = 0x1F8B4C
     orange = 0xE67E22
@@ -231,7 +244,6 @@ class Emojis:
     status_dnd = "<:status_dnd:470326272082313216>"
     status_offline = "<:status_offline:470326266537705472>"
 
-
     stackoverflow_tag = "<:stack_tag:870926975307501570>"
     stackoverflow_views = "<:stack_eye:870926992692879371>"
 
@@ -343,8 +355,8 @@ STAFF_ROLES = {Roles.helpers, Roles.moderation_team, Roles.admins, Roles.owners}
 
 # Whitelisted channels
 WHITELISTED_CHANNELS = (
-    Channels.bot,
-    Channels.community_bot_commands,
+    Channels.bot_commands,
+    Channels.sir_lancebot_playground,
     Channels.off_topic_0,
     Channels.off_topic_1,
     Channels.off_topic_2,
diff --git a/bot/exts/core/error_handler.py b/bot/exts/core/error_handler.py
index 676a1e70..4578f734 100644
--- a/bot/exts/core/error_handler.py
+++ b/bot/exts/core/error_handler.py
@@ -1,4 +1,3 @@
-import difflib
 import logging
 import math
 import random
@@ -11,6 +10,7 @@ from sentry_sdk import push_scope
 
 from bot.bot import Bot
 from bot.constants import Channels, Colours, ERROR_REPLIES, NEGATIVE_REPLIES, RedirectOutput
+from bot.utils.commands import get_command_suggestions
 from bot.utils.decorators import InChannelCheckFailure, InMonthCheckFailure
 from bot.utils.exceptions import APIError, MovedCommandError, UserNotPlayingError
 
@@ -98,7 +98,8 @@ class CommandErrorHandler(commands.Cog):
         if isinstance(error, commands.NoPrivateMessage):
             await ctx.send(
                 embed=self.error_embed(
-                    f"This command can only be used in the server. Go to <#{Channels.community_bot_commands}> instead!",
+                    "This command can only be used in the server. "
+                    f"Go to <#{Channels.sir_lancebot_playground}> instead!",
                     NEGATIVE_REPLIES
                 )
             )
@@ -157,31 +158,32 @@ class CommandErrorHandler(commands.Cog):
 
     async def send_command_suggestion(self, ctx: commands.Context, command_name: str) -> None:
         """Sends user similar commands if any can be found."""
-        raw_commands = []
-        for cmd in self.bot.walk_commands():
-            if not cmd.hidden:
-                raw_commands += (cmd.name, *cmd.aliases)
-        if similar_command_data := difflib.get_close_matches(command_name, raw_commands, 1):
-            similar_command_name = similar_command_data[0]
-            similar_command = self.bot.get_command(similar_command_name)
-
-            if not similar_command:
-                return
-
-            log_msg = "Cancelling attempt to suggest a command due to failed checks."
-            try:
-                if not await similar_command.can_run(ctx):
+        command_suggestions = []
+        if similar_command_names := get_command_suggestions(list(self.bot.all_commands.keys()), command_name):
+            for similar_command_name in similar_command_names:
+                similar_command = self.bot.get_command(similar_command_name)
+
+                if not similar_command:
+                    continue
+
+                log_msg = "Cancelling attempt to suggest a command due to failed checks."
+                try:
+                    if not await similar_command.can_run(ctx):
+                        log.debug(log_msg)
+                        continue
+                except commands.errors.CommandError as cmd_error:
                     log.debug(log_msg)
-                    return
-            except commands.errors.CommandError as cmd_error:
-                log.debug(log_msg)
-                await self.on_command_error(ctx, cmd_error)
-                return
+                    await self.on_command_error(ctx, cmd_error)
+                    continue
+
+                command_suggestions.append(similar_command_name)
 
             misspelled_content = ctx.message.content
             e = Embed()
             e.set_author(name="Did you mean:", icon_url=QUESTION_MARK_ICON)
-            e.description = misspelled_content.replace(command_name, similar_command_name, 1)
+            e.description = "\n".join(
+                misspelled_content.replace(command_name, cmd, 1) for cmd in command_suggestions
+            )
             await ctx.send(embed=e, delete_after=RedirectOutput.delete_delay)
 
 
diff --git a/bot/exts/core/help.py b/bot/exts/core/help.py
index db3c2aa6..eb7a9762 100644
--- a/bot/exts/core/help.py
+++ b/bot/exts/core/help.py
@@ -3,16 +3,17 @@ import asyncio
 import itertools
 import logging
 from contextlib import suppress
-from typing import NamedTuple, Union
+from typing import NamedTuple, Optional, Union
 
 from discord import Colour, Embed, HTTPException, Message, Reaction, User
 from discord.ext import commands
 from discord.ext.commands import CheckFailure, Cog as DiscordCog, Command, Context
-from rapidfuzz import process
 
 from bot import constants
 from bot.bot import Bot
 from bot.constants import Emojis
+from bot.utils.commands import get_command_suggestions
+from bot.utils.decorators import whitelist_override
 from bot.utils.pagination import FIRST_EMOJI, LAST_EMOJI, LEFT_EMOJI, LinePaginator, RIGHT_EMOJI
 
 DELETE_EMOJI = Emojis.trashcan
@@ -41,14 +42,18 @@ class HelpQueryNotFound(ValueError):
     """
     Raised when a HelpSession Query doesn't match a command or cog.
 
-    Contains the custom attribute of ``possible_matches``.
-    Instances of this object contain a dictionary of any command(s) that were close to matching the
-    query, where keys are the possible matched command names and values are the likeness match scores.
+    Params:
+    possible_matches: list of similar command names.
+    parent_command: parent command of an invalid subcommand. Only available when an invalid subcommand
+                    has been passed.
     """
 
-    def __init__(self, arg: str, possible_matches: dict = None):
+    def __init__(
+            self, arg: str, possible_matches: Optional[list[str]] = None, *, parent_command: Optional[Command] = None
+    ) -> None:
         super().__init__(arg)
         self.possible_matches = possible_matches
+        self.parent_command = parent_command
 
 
 class HelpSession:
@@ -153,12 +158,17 @@ class HelpSession:
 
         Will pass on possible close matches along with the `HelpQueryNotFound` exception.
         """
-        # Combine command and cog names
-        choices = list(self._bot.all_commands) + list(self._bot.cogs)
+        # Check if parent command is valid in case subcommand is invalid.
+        if " " in query:
+            parent, *_ = query.split()
+            parent_command = self._bot.get_command(parent)
+
+            if parent_command:
+                raise HelpQueryNotFound('Invalid Subcommand.', parent_command=parent_command)
 
-        result = process.extract(query, choices, score_cutoff=90)
+        similar_commands = get_command_suggestions(list(self._bot.all_commands.keys()), query)
 
-        raise HelpQueryNotFound(f'Query "{query}" not found.', dict(result))
+        raise HelpQueryNotFound(f'Query "{query}" not found.', similar_commands)
 
     async def timeout(self, seconds: int = 30) -> None:
         """Waits for a set number of seconds, then stops the help session."""
@@ -277,7 +287,7 @@ class HelpSession:
             else:
                 results.append(f"<{name}>")
 
-        return f"{cmd.name} {' '.join(results)}"
+        return f"{cmd.qualified_name} {' '.join(results)}"
 
     async def build_pages(self) -> None:
         """Builds the list of content pages to be paginated through in the help message, as a list of str."""
@@ -304,9 +314,10 @@ class HelpSession:
         prefix = constants.Client.prefix
 
         signature = self._get_command_params(self.query)
+        paginator.add_line(f"**```\n{prefix}{signature}\n```**")
+
         parent = self.query.full_parent_name + " " if self.query.parent else ""
-        paginator.add_line(f"**```\n{prefix}{parent}{signature}\n```**")
-        aliases = [f"`{alias}`" if not parent else f"`{parent} {alias}`" for alias in self.query.aliases]
+        aliases = [f"`{alias}`" if not parent else f"`{parent}{alias}`" for alias in self.query.aliases]
         aliases += [f"`{alias}`" for alias in getattr(self.query, "root_aliases", ())]
         aliases = ", ".join(sorted(aliases))
         if aliases:
@@ -502,18 +513,26 @@ class Help(DiscordCog):
     """Custom Embed Pagination Help feature."""
 
     @commands.command("help")
+    @whitelist_override(allow_dm=True)
     async def new_help(self, ctx: Context, *commands) -> None:
         """Shows Command Help."""
         try:
             await HelpSession.start(ctx, *commands)
         except HelpQueryNotFound as error:
+
+            # Send help message of parent command if subcommand is invalid.
+            if cmd := error.parent_command:
+                await ctx.send(str(error))
+                await self.new_help(ctx, cmd.qualified_name)
+                return
+
             embed = Embed()
             embed.colour = Colour.red()
             embed.title = str(error)
 
             if error.possible_matches:
-                matches = "\n".join(error.possible_matches.keys())
-                embed.description = f"**Did you mean:**\n`{matches}`"
+                matches = "\n".join(error.possible_matches)
+                embed.description = f"**Did you mean:**\n{matches}"
 
             await ctx.send(embed=embed)
 
diff --git a/bot/exts/core/internal_eval/_internal_eval.py b/bot/exts/core/internal_eval/_internal_eval.py
index 5b5461f0..190a15ec 100644
--- a/bot/exts/core/internal_eval/_internal_eval.py
+++ b/bot/exts/core/internal_eval/_internal_eval.py
@@ -34,6 +34,8 @@ RAW_CODE_REGEX = re.compile(
     re.DOTALL                               # "." also matches newlines
 )
 
+MAX_LENGTH = 99980
+
 
 class InternalEval(commands.Cog):
     """Top secret code evaluation for admins and owners."""
@@ -85,9 +87,10 @@ class InternalEval(commands.Cog):
 
     async def _upload_output(self, output: str) -> Optional[str]:
         """Upload `internal eval` output to our pastebin and return the url."""
+        data = self.shorten_output(output, max_length=MAX_LENGTH)
         try:
             async with self.bot.http_session.post(
-                "https://paste.pythondiscord.com/documents", data=output, raise_for_status=True
+                "https://paste.pythondiscord.com/documents", data=data, raise_for_status=True
             ) as resp:
                 data = await resp.json()
 
diff --git a/bot/exts/core/source.py b/bot/exts/core/source.py
index 7572ce51..2801be0f 100644
--- a/bot/exts/core/source.py
+++ b/bot/exts/core/source.py
@@ -6,14 +6,16 @@ from discord import Embed
 from discord.ext import commands
 
 from bot.bot import Bot
-from bot.constants import Source
+from bot.constants import Channels, Source, WHITELISTED_CHANNELS
 from bot.utils.converters import SourceConverter, SourceType
+from bot.utils.decorators import whitelist_override
 
 
 class BotSource(commands.Cog):
     """Displays information about the bot's source code."""
 
     @commands.command(name="source", aliases=("src",))
+    @whitelist_override(channels=WHITELISTED_CHANNELS+(Channels.community_meta, Channels.dev_contrib))
     async def source_command(self, ctx: commands.Context, *, source_item: SourceConverter = None) -> None:
         """Display information and a GitHub link to the source code of a command, tag, or cog."""
         if not source_item:
diff --git a/bot/exts/events/advent_of_code/_cog.py b/bot/exts/events/advent_of_code/_cog.py
index 01161f26..518841d4 100644
--- a/bot/exts/events/advent_of_code/_cog.py
+++ b/bot/exts/events/advent_of_code/_cog.py
@@ -61,7 +61,8 @@ class AdventOfCode(commands.Cog):
         self.status_task.set_name("AoC Status Countdown")
         self.status_task.add_done_callback(_helpers.background_task_callback)
 
-        self.completionist_task.start()
+        # Don't start task while event isn't running
+        # self.completionist_task.start()
 
     @tasks.loop(minutes=10.0)
     async def completionist_task(self) -> None:
@@ -96,7 +97,9 @@ class AdventOfCode(commands.Cog):
                 # Only give the role to people who have completed all 50 stars
                 continue
 
-            member_id = aoc_name_to_member_id.get(member_aoc_info["name"], None)
+            aoc_name = member_aoc_info["name"] or f"Anonymous #{member_aoc_info['id']}"
+
+            member_id = aoc_name_to_member_id.get(aoc_name)
             if not member_id:
                 log.debug(f"Could not find member_id for {member_aoc_info['name']}, not giving role.")
                 continue
diff --git a/bot/exts/events/advent_of_code/_helpers.py b/bot/exts/events/advent_of_code/_helpers.py
index 807cc275..6c004901 100644
--- a/bot/exts/events/advent_of_code/_helpers.py
+++ b/bot/exts/events/advent_of_code/_helpers.py
@@ -255,7 +255,7 @@ async def _fetch_leaderboard_data() -> dict[str, Any]:
 
         # Two attempts, one with the original session cookie and one with the fallback session
         for attempt in range(1, 3):
-            log.info(f"Attempting to fetch leaderboard `{leaderboard.id}` ({attempt}/2)")
+            log.debug(f"Attempting to fetch leaderboard `{leaderboard.id}` ({attempt}/2)")
             cookies = {"session": leaderboard.session}
             try:
                 raw_data = await _leaderboard_request(leaderboard_url, leaderboard.id, cookies)
@@ -332,7 +332,7 @@ async def fetch_leaderboard(invalidate_cache: bool = False, self_placement_name:
         number_of_participants = len(leaderboard)
         formatted_leaderboard = _format_leaderboard(leaderboard)
         full_leaderboard_url = await _upload_leaderboard(formatted_leaderboard)
-        leaderboard_fetched_at = datetime.datetime.utcnow().isoformat()
+        leaderboard_fetched_at = datetime.datetime.now(datetime.timezone.utc).isoformat()
 
         cached_leaderboard = {
             "placement_leaderboard": json.dumps(raw_leaderboard_data),
@@ -368,11 +368,13 @@ def get_summary_embed(leaderboard: dict) -> discord.Embed:
     """Get an embed with the current summary stats of the leaderboard."""
     leaderboard_url = leaderboard["full_leaderboard_url"]
     refresh_minutes = AdventOfCode.leaderboard_cache_expiry_seconds // 60
+    refreshed_unix = int(datetime.datetime.fromisoformat(leaderboard["leaderboard_fetched_at"]).timestamp())
 
-    aoc_embed = discord.Embed(
-        colour=Colours.soft_green,
-        timestamp=datetime.datetime.fromisoformat(leaderboard["leaderboard_fetched_at"]),
-        description=f"*The leaderboard is refreshed every {refresh_minutes} minutes.*"
+    aoc_embed = discord.Embed(colour=Colours.soft_green)
+
+    aoc_embed.description = (
+        f"The leaderboard is refreshed every {refresh_minutes} minutes.\n"
+        f"Last Updated: <t:{refreshed_unix}:t>"
     )
     aoc_embed.add_field(
         name="Number of Participants",
@@ -386,7 +388,6 @@ def get_summary_embed(leaderboard: dict) -> discord.Embed:
             inline=True,
         )
     aoc_embed.set_author(name="Advent of Code", url=leaderboard_url)
-    aoc_embed.set_footer(text="Last Updated")
     aoc_embed.set_thumbnail(url=AOC_EMBED_THUMBNAIL)
 
     return aoc_embed
diff --git a/bot/exts/events/advent_of_code/views/dayandstarview.py b/bot/exts/events/advent_of_code/views/dayandstarview.py
index a0bfa316..5529c12b 100644
--- a/bot/exts/events/advent_of_code/views/dayandstarview.py
+++ b/bot/exts/events/advent_of_code/views/dayandstarview.py
@@ -42,7 +42,13 @@ class AoCDropdownView(discord.ui.View):
 
     async def interaction_check(self, interaction: discord.Interaction) -> bool:
         """Global check to ensure that the interacting user is the user who invoked the command originally."""
-        return interaction.user == self.original_author
+        if interaction.user != self.original_author:
+            await interaction.response.send_message(
+                ":x: You can't interact with someone else's response. Please run the command yourself!",
+                ephemeral=True
+            )
+            return False
+        return True
 
     @discord.ui.select(
         placeholder="Day",
diff --git a/bot/exts/events/trivianight/__init__.py b/bot/exts/events/trivianight/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/bot/exts/events/trivianight/__init__.py
diff --git a/bot/exts/events/trivianight/_game.py b/bot/exts/events/trivianight/_game.py
new file mode 100644
index 00000000..8b012a17
--- /dev/null
+++ b/bot/exts/events/trivianight/_game.py
@@ -0,0 +1,192 @@
+import time
+from random import randrange
+from string import ascii_uppercase
+from typing import Iterable, NamedTuple, Optional, TypedDict
+
+DEFAULT_QUESTION_POINTS = 10
+DEFAULT_QUESTION_TIME = 20
+
+
+class QuestionData(TypedDict):
+    """Representing the different 'keys' of the question taken from the JSON."""
+
+    number: str
+    description: str
+    answers: list[str]
+    correct: str
+    points: Optional[int]
+    time: Optional[int]
+
+
+class UserGuess(NamedTuple):
+    """Represents the user's guess for a question."""
+
+    answer: str
+    editable: bool
+    elapsed: float
+
+
+class QuestionClosed(RuntimeError):
+    """Exception raised when the question is not open for guesses anymore."""
+
+
+class AlreadyUpdated(RuntimeError):
+    """Exception raised when the user has already updated their guess once."""
+
+
+class AllQuestionsVisited(RuntimeError):
+    """Exception raised when all of the questions have been visited."""
+
+
+class Question:
+    """Interface for one question in a trivia night game."""
+
+    def __init__(self, data: QuestionData):
+        self._data = data
+        self._guesses: dict[int, UserGuess] = {}
+        self._started = None
+
+    # These properties are mostly proxies to the underlying data:
+
+    @property
+    def number(self) -> str:
+        """The number of the question."""
+        return self._data["number"]
+
+    @property
+    def description(self) -> str:
+        """The description of the question."""
+        return self._data["description"]
+
+    @property
+    def answers(self) -> list[tuple[str, str]]:
+        """
+        The possible answers for this answer.
+
+        This is a property that returns a list of letter, answer pairs.
+        """
+        return [(ascii_uppercase[i], q) for (i, q) in enumerate(self._data["answers"])]
+
+    @property
+    def correct(self) -> str:
+        """The correct answer for this question."""
+        return self._data["correct"]
+
+    @property
+    def max_points(self) -> int:
+        """The maximum points that can be awarded for this question."""
+        return self._data.get("points") or DEFAULT_QUESTION_POINTS
+
+    @property
+    def time(self) -> float:
+        """The time allowed to answer the question."""
+        return self._data.get("time") or DEFAULT_QUESTION_TIME
+
+    def start(self) -> float:
+        """Start the question and return the time it started."""
+        self._started = time.perf_counter()
+        return self._started
+
+    def _update_guess(self, user: int, answer: str) -> UserGuess:
+        """Update an already existing guess."""
+        if self._started is None:
+            raise QuestionClosed("Question is not open for answers.")
+
+        if self._guesses[user][1] is False:
+            raise AlreadyUpdated(f"User({user}) has already updated their guess once.")
+
+        self._guesses[user] = (answer, False, time.perf_counter() - self._started)
+        return self._guesses[user]
+
+    def guess(self, user: int, answer: str) -> UserGuess:
+        """Add a guess made by a user to the current question."""
+        if user in self._guesses:
+            return self._update_guess(user, answer)
+
+        if self._started is None:
+            raise QuestionClosed("Question is not open for answers.")
+
+        self._guesses[user] = (answer, True, time.perf_counter() - self._started)
+        return self._guesses[user]
+
+    def stop(self) -> dict[int, UserGuess]:
+        """Stop the question and return the guesses that were made."""
+        guesses = self._guesses
+
+        self._started = None
+        self._guesses = {}
+
+        return guesses
+
+
+class TriviaNightGame:
+    """Interface for managing a game of trivia night."""
+
+    def __init__(self, data: list[QuestionData]) -> None:
+        self._questions = [Question(q) for q in data]
+        # A copy of the questions to keep for `.trivianight list`
+        self._all_questions = list(self._questions)
+        self.current_question: Optional[Question] = None
+        self._points = {}
+        self._speed = {}
+
+    def __iter__(self) -> Iterable[Question]:
+        return iter(self._questions)
+
+    def next_question(self, number: str = None) -> Question:
+        """
+        Consume one random question from the trivia night game.
+
+        One question is randomly picked from the list of questions which is then removed and returned.
+        """
+        if self.current_question is not None:
+            raise RuntimeError("Cannot call next_question() when there is a current question.")
+
+        if number is not None:
+            try:
+                question = [q for q in self._all_questions if q.number == int(number)][0]
+            except IndexError:
+                raise ValueError(f"Question number {number} does not exist.")
+        elif len(self._questions) == 0:
+            raise AllQuestionsVisited("All of the questions have been visited.")
+        else:
+            question = self._questions.pop(randrange(len(self._questions)))
+
+        self.current_question = question
+        return question
+
+    def end_question(self) -> None:
+        """
+        End the current question.
+
+        This method should be called when the question has been answered, it must be called before
+        attempting to call `next_question()` again.
+        """
+        if self.current_question is None:
+            raise RuntimeError("Cannot call end_question() when there is no current question.")
+
+        self.current_question.stop()
+        self.current_question = None
+
+    def list_questions(self) -> str:
+        """
+        List all the questions.
+
+        This method should be called when `.trivianight list` is called to display the following information:
+            - Question number
+            - Question description
+            - Visited/not visited
+        """
+        question_list = []
+
+        visited = ":white_check_mark:"
+        not_visited = ":x:"
+
+        for question in self._all_questions:
+            formatted_string = (
+                f"**Q{question.number}** {not_visited if question in self._questions else visited}"
+                f"\n{question.description}\n\n"
+            )
+            question_list.append(formatted_string.rstrip())
+
+        return question_list
diff --git a/bot/exts/events/trivianight/_questions.py b/bot/exts/events/trivianight/_questions.py
new file mode 100644
index 00000000..d6beced9
--- /dev/null
+++ b/bot/exts/events/trivianight/_questions.py
@@ -0,0 +1,179 @@
+from random import choice
+from string import ascii_uppercase
+
+import discord
+from discord import Embed, Interaction
+from discord.ui import Button, View
+
+from bot.constants import Colours, NEGATIVE_REPLIES
+
+from ._game import AlreadyUpdated, Question, QuestionClosed
+from ._scoreboard import Scoreboard
+
+
+class AnswerButton(Button):
+    """Button subclass that's used to guess on a particular answer."""
+
+    def __init__(self, label: str, question: Question):
+        super().__init__(label=label, style=discord.ButtonStyle.green)
+
+        self.question = question
+
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        When a user interacts with the button, this will be called.
+
+        Parameters:
+            - interaction: an instance of discord.Interaction representing the interaction between the user and the
+            button.
+        """
+        try:
+            guess = self.question.guess(interaction.user.id, self.label)
+        except AlreadyUpdated:
+            await interaction.response.send_message(
+                embed=Embed(
+                    title=choice(NEGATIVE_REPLIES),
+                    description="You've already changed your answer more than once!",
+                    color=Colours.soft_red
+                ),
+                ephemeral=True
+            )
+            return
+        except QuestionClosed:
+            await interaction.response.send_message(
+                embed=Embed(
+                    title=choice(NEGATIVE_REPLIES),
+                    description="The question is no longer accepting guesses!",
+                    color=Colours.soft_red
+                ),
+                ephemeral=True
+            )
+            return
+
+        if guess[1]:
+            await interaction.response.send_message(
+                embed=Embed(
+                    title="Confirming that...",
+                    description=f"You chose answer {self.label}.",
+                    color=Colours.soft_green
+                ),
+                ephemeral=True
+            )
+        else:
+            # guess[1] is False and they cannot change their answer again. Which
+            # indicates that they changed it this time around.
+            await interaction.response.send_message(
+                embed=Embed(
+                    title="Confirming that...",
+                    description=f"You changed your answer to answer {self.label}.",
+                    color=Colours.soft_green
+                ),
+                ephemeral=True
+            )
+
+
+class QuestionView(View):
+    """View for one trivia night question."""
+
+    def __init__(self, question: Question) -> None:
+        super().__init__()
+        self.question = question
+
+        for letter, _ in self.question.answers:
+            self.add_item(AnswerButton(letter, self.question))
+
+    @staticmethod
+    def unicodeify(text: str) -> str:
+        """
+        Takes `text` and adds zero-width spaces to prevent copy and pasting the question.
+
+        Parameters:
+            - text: A string that represents the question description to 'unicodeify'
+        """
+        return "".join(
+            f"{letter}\u200b" if letter not in ('\n', '\t', '`', 'p', 'y') else letter
+            for idx, letter in enumerate(text)
+        )
+
+    def create_embed(self) -> Embed:
+        """Helper function to create the embed for the current question."""
+        question_embed = Embed(
+            title=f"Question {self.question.number}",
+            description=self.unicodeify(self.question.description),
+            color=Colours.python_yellow
+        )
+
+        for label, answer in self.question.answers:
+            question_embed.add_field(name=f"Answer {label}", value=answer, inline=False)
+
+        return question_embed
+
+    def end_question(self, scoreboard: Scoreboard) -> Embed:
+        """
+        Ends the question and displays the statistics on who got the question correct, awards points, etc.
+
+        Returns:
+            An embed displaying the correct answers and the % of people that chose each answer.
+        """
+        guesses = self.question.stop()
+
+        labels = ascii_uppercase[:len(self.question.answers)]
+
+        answer_embed = Embed(
+            title=f"The correct answer for Question {self.question.number} was...",
+            description=self.question.correct
+        )
+
+        if len(guesses) != 0:
+            answers_chosen = {
+                answer_choice: len(
+                    tuple(filter(lambda x: x[0] == answer_choice, guesses.values()))
+                )
+                for answer_choice in labels
+            }
+
+            answers_chosen = dict(
+                sorted(list(answers_chosen.items()), key=lambda item: item[1], reverse=True)
+            )
+
+            for answer, people_answered in answers_chosen.items():
+                is_correct_answer = dict(self.question.answers)[answer[0]] == self.question.correct
+
+                # Setting the color of answer_embed to the % of people that got it correct via the mapping
+                if is_correct_answer:
+                    # Maps the % of people who got it right to a color, from a range of red to green
+                    percentage_to_color = [0xFC94A1, 0xFFCCCB, 0xCDFFCC, 0xB0F5AB, 0xB0F5AB]
+                    answer_embed.color = percentage_to_color[round(people_answered / len(guesses) * 100) // 25]
+
+                field_title = (
+                    (":white_check_mark: " if is_correct_answer else "")
+                    + f"{people_answered} players ({people_answered / len(guesses) * 100:.1f}%) chose"
+                )
+
+                # The `ord` function is used here to change the letter to its corresponding position
+                answer_embed.add_field(
+                    name=field_title,
+                    value=self.question.answers[ord(answer) - 65][1],
+                    inline=False
+                )
+
+            # Assign points to users
+            for user_id, answer in guesses.items():
+                if dict(self.question.answers)[answer[0]] == self.question.correct:
+                    scoreboard.assign_points(
+                        int(user_id),
+                        points=(1 - (answer[-1] / self.question.time) / 2) * self.question.max_points,
+                        speed=answer[-1]
+                    )
+                elif answer[-1] <= 2:
+                    scoreboard.assign_points(
+                        int(user_id),
+                        points=-(1 - (answer[-1] / self.question.time) / 2) * self.question.max_points
+                    )
+                else:
+                    scoreboard.assign_points(
+                        int(user_id),
+                        points=0
+                    )
+
+        return answer_embed
diff --git a/bot/exts/events/trivianight/_scoreboard.py b/bot/exts/events/trivianight/_scoreboard.py
new file mode 100644
index 00000000..a5a5fcac
--- /dev/null
+++ b/bot/exts/events/trivianight/_scoreboard.py
@@ -0,0 +1,186 @@
+from random import choice
+
+import discord.ui
+from discord import ButtonStyle, Embed, Interaction, Member
+from discord.ui import Button, View
+
+from bot.bot import Bot
+from bot.constants import Colours, NEGATIVE_REPLIES
+
+
+class ScoreboardView(View):
+    """View for the scoreboard."""
+
+    def __init__(self, bot: Bot):
+        super().__init__()
+        self.bot = bot
+
+    @staticmethod
+    def _int_to_ordinal(number: int) -> str:
+        """
+        Converts an integer into an ordinal number, i.e. 1 to 1st.
+
+        Parameters:
+            - number: an integer representing the number to convert to an ordinal number.
+        """
+        suffix = ["th", "st", "nd", "rd", "th"][min(number % 10, 4)]
+        if (number % 100) in {11, 12, 13}:
+            suffix = "th"
+
+        return str(number) + suffix
+
+    async def create_main_leaderboard(self) -> Embed:
+        """
+        Helper function that iterates through `self.points` to generate the main leaderboard embed.
+
+        The main leaderboard would be formatted like the following:
+        **1**. @mention of the user (# of points)
+        along with the 29 other users who made it onto the leaderboard.
+        """
+        formatted_string = ""
+
+        for current_placement, (user, points) in enumerate(self.points.items()):
+            if current_placement + 1 > 30:
+                break
+
+            user = await self.bot.fetch_user(int(user))
+            formatted_string += f"**{current_placement + 1}.** {user.mention} "
+            formatted_string += f"({points:.1f} pts)\n"
+            if (current_placement + 1) % 10 == 0:
+                formatted_string += "⎯⎯⎯⎯⎯⎯⎯⎯\n"
+
+        main_embed = Embed(
+            title="Winners of the Trivia Night",
+            description=formatted_string,
+            color=Colours.python_blue,
+        )
+
+        return main_embed
+
+    async def _create_speed_embed(self) -> Embed:
+        """
+        Helper function that iterates through `self.speed` to generate a leaderboard embed.
+
+        The speed leaderboard would be formatted like the following:
+        **1**. @mention of the user ([average speed as a float with the precision of one decimal point]s)
+        along with the 29 other users who made it onto the leaderboard.
+        """
+        formatted_string = ""
+
+        for current_placement, (user, time_taken) in enumerate(self.speed.items()):
+            if current_placement + 1 > 30:
+                break
+
+            user = await self.bot.fetch_user(int(user))
+            formatted_string += f"**{current_placement + 1}.** {user.mention} "
+            formatted_string += f"({(time_taken[-1] / time_taken[0]):.1f}s)\n"
+            if (current_placement + 1) % 10 == 0:
+                formatted_string += "⎯⎯⎯⎯⎯⎯⎯⎯\n"
+
+        speed_embed = Embed(
+            title="Average time taken to answer a question",
+            description=formatted_string,
+            color=Colours.python_blue
+        )
+        return speed_embed
+
+    def _get_rank(self, member: Member) -> Embed:
+        """
+        Gets the member's rank for the points leaderboard and speed leaderboard.
+
+        Parameters:
+            - member: An instance of discord.Member representing the person who is trying to get their rank.
+        """
+        rank_embed = Embed(title=f"Ranks for {member.display_name}", color=Colours.python_blue)
+        # These are stored as strings so that the last digit can be determined to choose the suffix
+        try:
+            points_rank = str(list(self.points).index(member.id) + 1)
+            speed_rank = str(list(self.speed).index(member.id) + 1)
+        except ValueError:
+            return Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="It looks like you didn't participate in the Trivia Night event!",
+                color=Colours.soft_red
+            )
+
+        rank_embed.add_field(
+            name="Total Points",
+            value=(
+                f"You got {self._int_to_ordinal(int(points_rank))} place"
+                f" with {self.points[member.id]:.1f} points."
+            ),
+            inline=False
+        )
+
+        rank_embed.add_field(
+            name="Average Speed",
+            value=(
+                f"You got {self._int_to_ordinal(int(speed_rank))} place"
+                f" with a time of {(self.speed[member.id][1] / self.speed[member.id][0]):.1f} seconds."
+            ),
+            inline=False
+        )
+        return rank_embed
+
+    @discord.ui.button(label="Scoreboard for Speed", style=ButtonStyle.green)
+    async def speed_leaderboard(self, button: Button, interaction: Interaction) -> None:
+        """
+        Send an ephemeral message with the speed leaderboard embed.
+
+        Parameters:
+            - button: The discord.ui.Button instance representing the `Speed Leaderboard` button.
+            - interaction: The discord.Interaction instance containing information on the interaction between the user
+            and the button.
+        """
+        await interaction.response.send_message(embed=await self._create_speed_embed(), ephemeral=True)
+
+    @discord.ui.button(label="What's my rank?", style=ButtonStyle.blurple)
+    async def rank_button(self, button: Button, interaction: Interaction) -> None:
+        """
+        Send an ephemeral message with the user's rank for the overall points/average speed.
+
+        Parameters:
+            - button: The discord.ui.Button instance representing the `What's my rank?` button.
+            - interaction: The discord.Interaction instance containing information on the interaction between the user
+            and the button.
+        """
+        await interaction.response.send_message(embed=self._get_rank(interaction.user), ephemeral=True)
+
+
+class Scoreboard:
+    """Class for the scoreboard for the Trivia Night event."""
+
+    def __init__(self, bot: Bot):
+        self._bot = bot
+        self._points = {}
+        self._speed = {}
+
+    def assign_points(self, user_id: int, *, points: int = None, speed: float = None) -> None:
+        """
+        Assign points or deduct points to/from a certain user.
+
+        This method should be called once the question has finished and all answers have been registered.
+        """
+        if points is not None and user_id not in self._points.keys():
+            self._points[user_id] = points
+        elif points is not None:
+            self._points[user_id] += points
+
+        if speed is not None and user_id not in self._speed.keys():
+            self._speed[user_id] = [1, speed]
+        elif speed is not None:
+            self._speed[user_id] = [
+                self._speed[user_id][0] + 1, self._speed[user_id][1] + speed
+            ]
+
+    async def display(self, speed_leaderboard: bool = False) -> tuple[Embed, View]:
+        """Returns the embed of the main leaderboard along with the ScoreboardView."""
+        view = ScoreboardView(self._bot)
+
+        view.points = dict(sorted(self._points.items(), key=lambda item: item[-1], reverse=True))
+        view.speed = dict(sorted(self._speed.items(), key=lambda item: item[-1][1] / item[-1][0]))
+
+        return (
+            await view.create_main_leaderboard(),
+            view if not speed_leaderboard else await view._create_speed_embed()
+        )
diff --git a/bot/exts/events/trivianight/trivianight.py b/bot/exts/events/trivianight/trivianight.py
new file mode 100644
index 00000000..18d8327a
--- /dev/null
+++ b/bot/exts/events/trivianight/trivianight.py
@@ -0,0 +1,328 @@
+import asyncio
+from json import JSONDecodeError, loads
+from random import choice
+from typing import Optional
+
+from discord import Embed
+from discord.ext import commands
+
+from bot.bot import Bot
+from bot.constants import Colours, NEGATIVE_REPLIES, POSITIVE_REPLIES, Roles
+from bot.utils.pagination import LinePaginator
+
+from ._game import AllQuestionsVisited, TriviaNightGame
+from ._questions import QuestionView
+from ._scoreboard import Scoreboard
+
+# The ID you see below are the Events Lead role ID and the Event Runner Role ID
+TRIVIA_NIGHT_ROLES = (Roles.admins, 778361735739998228, 940911658799333408)
+
+
+class TriviaNightCog(commands.Cog):
+    """Cog for the Python Trivia Night event."""
+
+    def __init__(self, bot: Bot):
+        self.bot = bot
+        self.game: Optional[TriviaNightGame] = None
+        self.scoreboard: Optional[Scoreboard] = None
+        self.question_closed: asyncio.Event = None
+
+    @commands.group(aliases=["tn"], invoke_without_command=True)
+    async def trivianight(self, ctx: commands.Context) -> None:
+        """
+        The command group for the Python Discord Trivia Night.
+
+        If invoked without a subcommand (i.e. simply .trivianight), it will explain what the Trivia Night event is.
+        """
+        cog_description = Embed(
+            title="What is .trivianight?",
+            description=(
+                "This 'cog' is for the Python Discord's TriviaNight (date tentative)! Compete against other"
+                " players in a trivia about Python!"
+            ),
+            color=Colours.soft_green
+        )
+        await ctx.send(embed=cog_description)
+
+    @trivianight.command()
+    @commands.has_any_role(*TRIVIA_NIGHT_ROLES)
+    async def load(self, ctx: commands.Context, *, to_load: Optional[str]) -> None:
+        """
+        Loads a JSON file from the provided attachment or argument.
+
+        The JSON provided is formatted where it is a list of dictionaries, each dictionary containing the keys below:
+        - number: int (represents the current question #)
+        - description: str (represents the question itself)
+        - answers: list[str] (represents the different answers possible, must be a length of 4)
+        - correct: str (represents the correct answer in terms of what the correct answer is in `answers`
+        - time: Optional[int] (represents the timer for the question and how long it should run, default is 10)
+        - points: Optional[int] (represents how many points are awarded for each question, default is 10)
+
+        The load command accepts three different ways of loading in a JSON:
+        - an attachment of the JSON file
+        - a message link to the attachment/JSON
+        - reading the JSON itself via a codeblock or plain text
+        """
+        if self.game is not None:
+            await ctx.send(embed=Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is already a trivia night running!",
+                color=Colours.soft_red
+            ))
+            return
+
+        if ctx.message.attachments:
+            json_text = (await ctx.message.attachments[0].read()).decode("utf8")
+        elif not to_load:
+            raise commands.BadArgument("You didn't attach an attachment nor link a message!")
+        elif (
+            to_load.startswith("https://discord.com/channels")
+            or to_load.startswith("https://discordapp.com/channels")
+        ):
+            channel_id, message_id = to_load.split("/")[-2:]
+            channel = await ctx.guild.fetch_channel(int(channel_id))
+            message = await channel.fetch_message(int(message_id))
+            if message.attachments:
+                json_text = (await message.attachments[0].read()).decode("utf8")
+            else:
+                json_text = message.content.replace("```", "").replace("json", "").replace("\n", "")
+        else:
+            json_text = to_load.replace("```", "").replace("json", "").replace("\n", "")
+
+        try:
+            serialized_json = loads(json_text)
+        except JSONDecodeError as error:
+            raise commands.BadArgument(f"Looks like something went wrong:\n{str(error)}")
+
+        self.game = TriviaNightGame(serialized_json)
+        self.question_closed = asyncio.Event()
+
+        success_embed = Embed(
+            title=choice(POSITIVE_REPLIES),
+            description="The JSON was loaded successfully!",
+            color=Colours.soft_green
+        )
+
+        self.scoreboard = Scoreboard(self.bot)
+
+        await ctx.send(embed=success_embed)
+
+    @trivianight.command(aliases=('next',))
+    @commands.has_any_role(*TRIVIA_NIGHT_ROLES)
+    async def question(self, ctx: commands.Context, question_number: str = None) -> None:
+        """
+        Gets a random question from the unanswered question list and lets the user(s) choose the answer.
+
+        This command will continuously count down until the time limit of the question is exhausted.
+        However, if `.trivianight stop` is invoked, the counting down is interrupted to show the final results.
+        """
+        if self.game is None:
+            await ctx.send(embed=Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is no trivia night running!",
+                color=Colours.soft_red
+            ))
+            return
+
+        if self.game.current_question is not None:
+            error_embed = Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is already an ongoing question!",
+                color=Colours.soft_red
+            )
+            await ctx.send(embed=error_embed)
+            return
+
+        try:
+            next_question = self.game.next_question(question_number)
+        except AllQuestionsVisited:
+            error_embed = Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="All of the questions have been used.",
+                color=Colours.soft_red
+            )
+            await ctx.send(embed=error_embed)
+            return
+
+        await ctx.send("Next question in 3 seconds! Get ready...")
+        await asyncio.sleep(3)
+
+        question_view = QuestionView(next_question)
+        question_embed = question_view.create_embed()
+
+        next_question.start()
+        message = await ctx.send(embed=question_embed, view=question_view)
+
+        # Exponentially sleep less and less until the time limit is reached
+        percentage = 1
+        while True:
+            percentage *= 0.5
+            duration = next_question.time * percentage
+
+            await asyncio.wait([self.question_closed.wait()], timeout=duration)
+
+            if self.question_closed.is_set():
+                await ctx.send(embed=question_view.end_question(self.scoreboard))
+                await message.edit(embed=question_embed, view=None)
+
+                self.game.end_question()
+                self.question_closed.clear()
+                return
+
+            if int(duration) > 1:
+                # It is quite ugly to display decimals, the delay for requests to reach Discord
+                # cause sub-second accuracy to be quite pointless.
+                await ctx.send(f"{int(duration)}s remaining...")
+            else:
+                # Since each time we divide the percentage by 2 and sleep one half of the halves (then sleep a
+                # half, of that half) we must sleep both halves at the end.
+                await asyncio.wait([self.question_closed.wait()], timeout=duration)
+                if self.question_closed.is_set():
+                    await ctx.send(embed=question_view.end_question(self.scoreboard))
+                    await message.edit(embed=question_embed, view=None)
+
+                    self.game.end_question()
+                    self.question_closed.clear()
+                    return
+                break
+
+        await ctx.send(embed=question_view.end_question(self.scoreboard))
+        await message.edit(embed=question_embed, view=None)
+
+        self.game.end_question()
+
+    @trivianight.command()
+    @commands.has_any_role(*TRIVIA_NIGHT_ROLES)
+    async def list(self, ctx: commands.Context) -> None:
+        """
+        Display all the questions left in the question bank.
+
+        Questions are displayed in the following format:
+        Q(number): Question description | :white_check_mark: if the question was used otherwise :x:.
+        """
+        if self.game is None:
+            await ctx.send(embed=Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is no trivia night running!",
+                color=Colours.soft_red
+            ))
+            return
+
+        question_list = self.game.list_questions()
+
+        list_embed = Embed(title="All Trivia Night Questions")
+
+        if len(question_list) == 1:
+            list_embed.description = question_list[0]
+            await ctx.send(embed=list_embed)
+        else:
+            await LinePaginator.paginate(
+                question_list,
+                ctx,
+                list_embed
+            )
+
+    @trivianight.command()
+    @commands.has_any_role(*TRIVIA_NIGHT_ROLES)
+    async def stop(self, ctx: commands.Context) -> None:
+        """
+        End the ongoing question to show the correct question.
+
+        This command should be used if the question should be ended early or if the time limit fails
+        """
+        if self.game is None:
+            await ctx.send(embed=Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is no trivia night running!",
+                color=Colours.soft_red
+            ))
+            return
+
+        if self.game.current_question is None:
+            error_embed = Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is no ongoing question!",
+                color=Colours.soft_red
+            )
+            await ctx.send(embed=error_embed)
+            return
+
+        self.question_closed.set()
+
+    @trivianight.command()
+    @commands.has_any_role(*TRIVIA_NIGHT_ROLES)
+    async def end(self, ctx: commands.Context) -> None:
+        """
+        Displays the scoreboard view.
+
+        The scoreboard view consists of the two scoreboards with the 30 players who got the highest points and the
+        30 players who had the fastest average response time to a question where they got the question right.
+
+        The scoreboard view also has a button where the user can see their own rank, points and average speed if they
+        didn't make it onto the leaderboard.
+        """
+        if self.game is None:
+            await ctx.send(embed=Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is no trivia night running!",
+                color=Colours.soft_red
+            ))
+            return
+
+        if self.game.current_question is not None:
+            error_embed = Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="You can't end the event while a question is ongoing!",
+                color=Colours.soft_red
+            )
+            await ctx.send(embed=error_embed)
+            return
+
+        scoreboard_embed, scoreboard_view = await self.scoreboard.display()
+        await ctx.send(embed=scoreboard_embed, view=scoreboard_view)
+
+    @trivianight.command()
+    @commands.has_any_role(*TRIVIA_NIGHT_ROLES)
+    async def scoreboard(self, ctx: commands.Context) -> None:
+        """
+        Displays the scoreboard.
+
+        The scoreboard consists of the two scoreboards with the 30 players who got the highest points and the
+        30 players who had the fastest average response time to a question where they got the question right.
+        """
+        if self.game is None:
+            await ctx.send(embed=Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="There is no trivia night running!",
+                color=Colours.soft_red
+            ))
+            return
+
+        if self.game.current_question is not None:
+            error_embed = Embed(
+                title=choice(NEGATIVE_REPLIES),
+                description="You can't end the event while a question is ongoing!",
+                color=Colours.soft_red
+            )
+            await ctx.send(embed=error_embed)
+            return
+
+        scoreboard_embed, speed_scoreboard = await self.scoreboard.display(speed_leaderboard=True)
+        await ctx.send(embeds=(scoreboard_embed, speed_scoreboard))
+
+    @trivianight.command()
+    @commands.has_any_role(*TRIVIA_NIGHT_ROLES)
+    async def end_game(self, ctx: commands.Context) -> None:
+        """Ends the ongoing game."""
+        self.game = None
+
+        await ctx.send(embed=Embed(
+            title=choice(POSITIVE_REPLIES),
+            description="The game has been stopped.",
+            color=Colours.soft_green
+        ))
+
+
+def setup(bot: Bot) -> None:
+    """Load the TriviaNight cog."""
+    bot.add_cog(TriviaNightCog(bot))
diff --git a/bot/exts/fun/battleship.py b/bot/exts/fun/battleship.py
index beff196f..77e38427 100644
--- a/bot/exts/fun/battleship.py
+++ b/bot/exts/fun/battleship.py
@@ -110,8 +110,8 @@ class Game:
 
         self.gameover: bool = False
 
-        self.turn: Optional[discord.Member] = None
-        self.next: Optional[discord.Member] = None
+        self.turn: Optional[Player] = None
+        self.next: Optional[Player] = None
 
         self.match: Optional[re.Match] = None
         self.surrender: bool = False
diff --git a/bot/exts/fun/connect_four.py b/bot/exts/fun/connect_four.py
index f53695d5..1b88d065 100644
--- a/bot/exts/fun/connect_four.py
+++ b/bot/exts/fun/connect_four.py
@@ -5,6 +5,7 @@ from typing import Optional, Union
 
 import discord
 import emojis
+from discord import ClientUser, Member
 from discord.ext import commands
 
 from bot.bot import Bot
@@ -71,7 +72,9 @@ class Game:
             await self.message.add_reaction(CROSS_EMOJI)
             await self.message.edit(content=None, embed=embed)
 
-    async def game_over(self, action: str, player1: discord.user, player2: discord.user) -> None:
+    async def game_over(
+        self, action: str, player1: Union[ClientUser, Member], player2: Union[ClientUser, Member]
+    ) -> None:
         """Announces to public chat."""
         if action == "win":
             await self.channel.send(f"Game Over! {player1.mention} won against {player2.mention}")
diff --git a/bot/exts/fun/fun.py b/bot/exts/fun/fun.py
index b148f1f3..e7337cb6 100644
--- a/bot/exts/fun/fun.py
+++ b/bot/exts/fun/fun.py
@@ -1,35 +1,21 @@
-import functools
 import json
 import logging
 import random
 from collections.abc import Iterable
 from pathlib import Path
-from typing import Callable, Optional, Union
+from typing import Literal
 
-from discord import Embed, Message
+import pyjokes
+from discord import Embed
 from discord.ext import commands
-from discord.ext.commands import BadArgument, Cog, Context, MessageConverter, clean_content
+from discord.ext.commands import BadArgument, Cog, Context, clean_content
 
-from bot import utils
 from bot.bot import Bot
 from bot.constants import Client, Colours, Emojis
-from bot.utils import helpers
+from bot.utils import helpers, messages
 
 log = logging.getLogger(__name__)
 
-UWU_WORDS = {
-    "fi": "fwi",
-    "l": "w",
-    "r": "w",
-    "some": "sum",
-    "th": "d",
-    "thing": "fing",
-    "tho": "fo",
-    "you're": "yuw'we",
-    "your": "yur",
-    "you": "yuw",
-}
-
 
 def caesar_cipher(text: str, offset: int) -> Iterable[str]:
     """
@@ -56,7 +42,6 @@ class Fun(Cog):
 
     def __init__(self, bot: Bot):
         self.bot = bot
-
         self._caesar_cipher_embed = json.loads(Path("bot/resources/fun/caesar_info.json").read_text("UTF-8"))
 
     @staticmethod
@@ -74,23 +59,6 @@ class Fun(Cog):
         else:
             raise BadArgument(f"`{Client.prefix}roll` only supports between 1 and 6 rolls.")
 
-    @commands.command(name="uwu", aliases=("uwuwize", "uwuify",))
-    async def uwu_command(self, ctx: Context, *, text: clean_content(fix_channel_mentions=True)) -> None:
-        """Converts a given `text` into it's uwu equivalent."""
-        conversion_func = functools.partial(
-            utils.replace_many, replacements=UWU_WORDS, ignore_case=True, match_case=True
-        )
-        text, embed = await Fun._get_text_and_embed(ctx, text)
-        # Convert embed if it exists
-        if embed is not None:
-            embed = Fun._convert_embed(conversion_func, embed)
-        converted_text = conversion_func(text)
-        converted_text = helpers.suppress_links(converted_text)
-        # Don't put >>> if only embed present
-        if converted_text:
-            converted_text = f">>> {converted_text.lstrip('> ')}"
-        await ctx.send(content=converted_text, embed=embed)
-
     @commands.command(name="randomcase", aliases=("rcase", "randomcaps", "rcaps",))
     async def randomcase_command(self, ctx: Context, *, text: clean_content(fix_channel_mentions=True)) -> None:
         """Randomly converts the casing of a given `text`."""
@@ -99,10 +67,10 @@ class Fun(Cog):
             return "".join(
                 char.upper() if round(random.random()) else char.lower() for char in text
             )
-        text, embed = await Fun._get_text_and_embed(ctx, text)
+        text, embed = await messages.get_text_and_embed(ctx, text)
         # Convert embed if it exists
         if embed is not None:
-            embed = Fun._convert_embed(conversion_func, embed)
+            embed = messages.convert_embed(conversion_func, embed)
         converted_text = conversion_func(text)
         converted_text = helpers.suppress_links(converted_text)
         # Don't put >>> if only embed present
@@ -148,10 +116,10 @@ class Fun(Cog):
             """Encrypts the given string using the Caesar Cipher."""
             return "".join(caesar_cipher(text, offset))
 
-        text, embed = await Fun._get_text_and_embed(ctx, msg)
+        text, embed = await messages.get_text_and_embed(ctx, msg)
 
         if embed is not None:
-            embed = Fun._convert_embed(conversion_func, embed)
+            embed = messages.convert_embed(conversion_func, embed)
 
         converted_text = conversion_func(text)
 
@@ -182,67 +150,11 @@ class Fun(Cog):
         """
         await self._caesar_cipher(ctx, offset, msg, left_shift=True)
 
-    @staticmethod
-    async def _get_text_and_embed(ctx: Context, text: str) -> tuple[str, Optional[Embed]]:
-        """
-        Attempts to extract the text and embed from a possible link to a discord Message.
-
-        Does not retrieve the text and embed from the Message if it is in a channel the user does
-        not have read permissions in.
-
-        Returns a tuple of:
-            str: If `text` is a valid discord Message, the contents of the message, else `text`.
-            Optional[Embed]: The embed if found in the valid Message, else None
-        """
-        embed = None
-
-        msg = await Fun._get_discord_message(ctx, text)
-        # Ensure the user has read permissions for the channel the message is in
-        if isinstance(msg, Message):
-            permissions = msg.channel.permissions_for(ctx.author)
-            if permissions.read_messages:
-                text = msg.clean_content
-                # Take first embed because we can't send multiple embeds
-                if msg.embeds:
-                    embed = msg.embeds[0]
-
-        return (text, embed)
-
-    @staticmethod
-    async def _get_discord_message(ctx: Context, text: str) -> Union[Message, str]:
-        """
-        Attempts to convert a given `text` to a discord Message object and return it.
-
-        Conversion will succeed if given a discord Message ID or link.
-        Returns `text` if the conversion fails.
-        """
-        try:
-            text = await MessageConverter().convert(ctx, text)
-        except commands.BadArgument:
-            log.debug(f"Input '{text:.20}...' is not a valid Discord Message")
-        return text
-
-    @staticmethod
-    def _convert_embed(func: Callable[[str, ], str], embed: Embed) -> Embed:
-        """
-        Converts the text in an embed using a given conversion function, then return the embed.
-
-        Only modifies the following fields: title, description, footer, fields
-        """
-        embed_dict = embed.to_dict()
-
-        embed_dict["title"] = func(embed_dict.get("title", ""))
-        embed_dict["description"] = func(embed_dict.get("description", ""))
-
-        if "footer" in embed_dict:
-            embed_dict["footer"]["text"] = func(embed_dict["footer"].get("text", ""))
-
-        if "fields" in embed_dict:
-            for field in embed_dict["fields"]:
-                field["name"] = func(field.get("name", ""))
-                field["value"] = func(field.get("value", ""))
-
-        return Embed.from_dict(embed_dict)
+    @commands.command()
+    async def joke(self, ctx: commands.Context, category: Literal["neutral", "chuck", "all"] = "all") -> None:
+        """Retrieves a joke of the specified `category` from the pyjokes api."""
+        joke = pyjokes.get_joke(category=category)
+        await ctx.send(joke)
 
 
 def setup(bot: Bot) -> None:
diff --git a/bot/exts/fun/latex.py b/bot/exts/fun/latex.py
new file mode 100644
index 00000000..aeabcd20
--- /dev/null
+++ b/bot/exts/fun/latex.py
@@ -0,0 +1,138 @@
+import hashlib
+import re
+import string
+from io import BytesIO
+from pathlib import Path
+from typing import BinaryIO, Optional
+
+import discord
+from PIL import Image
+from discord.ext import commands
+
+from bot.bot import Bot
+from bot.constants import Channels, WHITELISTED_CHANNELS
+from bot.utils.decorators import whitelist_override
+
+FORMATTED_CODE_REGEX = re.compile(
+    r"(?P<delim>(?P<block>```)|``?)"        # code delimiter: 1-3 backticks; (?P=block) only matches if it's a block
+    r"(?(block)(?:(?P<lang>[a-z]+)\n)?)"    # if we're in a block, match optional language (only letters plus newline)
+    r"(?:[ \t]*\n)*"                        # any blank (empty or tabs/spaces only) lines before the code
+    r"(?P<code>.*?)"                        # extract all code inside the markup
+    r"\s*"                                  # any more whitespace before the end of the code markup
+    r"(?P=delim)",                          # match the exact same delimiter from the start again
+    re.DOTALL | re.IGNORECASE,              # "." also matches newlines, case insensitive
+)
+
+LATEX_API_URL = "https://rtex.probablyaweb.site/api/v2"
+PASTEBIN_URL = "https://paste.pythondiscord.com"
+
+THIS_DIR = Path(__file__).parent
+CACHE_DIRECTORY = THIS_DIR / "_latex_cache"
+CACHE_DIRECTORY.mkdir(exist_ok=True)
+TEMPLATE = string.Template(Path("bot/resources/fun/latex_template.txt").read_text())
+
+PAD = 10
+
+LATEX_ALLOWED_CHANNNELS = WHITELISTED_CHANNELS + (
+    Channels.data_science_and_ai,
+    Channels.algos_and_data_structs,
+)
+
+
+def _prepare_input(text: str) -> str:
+    """Extract latex from a codeblock, if it is in one."""
+    if match := FORMATTED_CODE_REGEX.match(text):
+        return match.group("code")
+    else:
+        return text
+
+
+def _process_image(data: bytes, out_file: BinaryIO) -> None:
+    """Read `data` as an image file, and paste it on a white background."""
+    image = Image.open(BytesIO(data)).convert("RGBA")
+    width, height = image.size
+    background = Image.new("RGBA", (width + 2 * PAD, height + 2 * PAD), "WHITE")
+
+    # paste the image on the background, using the same image as the mask
+    # when an RGBA image is passed as the mask, its alpha band is used.
+    # this has the effect of skipping pasting the pixels where the image is transparent.
+    background.paste(image, (PAD, PAD), image)
+    background.save(out_file)
+
+
+class InvalidLatexError(Exception):
+    """Represents an error caused by invalid latex."""
+
+    def __init__(self, logs: Optional[str]):
+        super().__init__(logs)
+        self.logs = logs
+
+
+class Latex(commands.Cog):
+    """Renders latex."""
+
+    def __init__(self, bot: Bot):
+        self.bot = bot
+
+    async def _generate_image(self, query: str, out_file: BinaryIO) -> None:
+        """Make an API request and save the generated image to cache."""
+        payload = {"code": query, "format": "png"}
+        async with self.bot.http_session.post(LATEX_API_URL, data=payload, raise_for_status=True) as response:
+            response_json = await response.json()
+        if response_json["status"] != "success":
+            raise InvalidLatexError(logs=response_json.get("log"))
+        async with self.bot.http_session.get(
+            f"{LATEX_API_URL}/{response_json['filename']}",
+            raise_for_status=True
+        ) as response:
+            _process_image(await response.read(), out_file)
+
+    async def _upload_to_pastebin(self, text: str) -> Optional[str]:
+        """Uploads `text` to the paste service, returning the url if successful."""
+        try:
+            async with self.bot.http_session.post(
+                PASTEBIN_URL + "/documents",
+                data=text,
+                raise_for_status=True
+            ) as response:
+                response_json = await response.json()
+            if "key" in response_json:
+                return f"{PASTEBIN_URL}/{response_json['key']}.txt?noredirect"
+        except Exception:
+            # 400 (Bad Request) means there are too many characters
+            pass
+
+    @commands.command()
+    @commands.max_concurrency(1, commands.BucketType.guild, wait=True)
+    @whitelist_override(channels=LATEX_ALLOWED_CHANNNELS)
+    async def latex(self, ctx: commands.Context, *, query: str) -> None:
+        """Renders the text in latex and sends the image."""
+        query = _prepare_input(query)
+
+        # the hash of the query is used as the filename in the cache.
+        query_hash = hashlib.md5(query.encode()).hexdigest()
+        image_path = CACHE_DIRECTORY / f"{query_hash}.png"
+        async with ctx.typing():
+            if not image_path.exists():
+                try:
+                    with open(image_path, "wb") as out_file:
+                        await self._generate_image(TEMPLATE.substitute(text=query), out_file)
+                except InvalidLatexError as err:
+                    embed = discord.Embed(title="Failed to render input.")
+                    if err.logs is None:
+                        embed.description = "No logs available."
+                    else:
+                        logs_paste_url = await self._upload_to_pastebin(err.logs)
+                        if logs_paste_url:
+                            embed.description = f"[View Logs]({logs_paste_url})"
+                        else:
+                            embed.description = "Couldn't upload logs."
+                    await ctx.send(embed=embed)
+                    image_path.unlink()
+                    return
+            await ctx.send(file=discord.File(image_path, "latex.png"))
+
+
+def setup(bot: Bot) -> None:
+    """Load the Latex Cog."""
+    bot.add_cog(Latex(bot))
diff --git a/bot/exts/fun/uwu.py b/bot/exts/fun/uwu.py
new file mode 100644
index 00000000..83497893
--- /dev/null
+++ b/bot/exts/fun/uwu.py
@@ -0,0 +1,204 @@
+import random
+import re
+import typing as t
+from dataclasses import dataclass
+from functools import partial
+
+import discord
+from discord.ext import commands
+from discord.ext.commands import Cog, Context, clean_content
+
+from bot.bot import Bot
+from bot.utils import helpers, messages
+
+WORD_REPLACE = {
+    "small": "smol",
+    "cute": "kawaii~",
+    "fluff": "floof",
+    "love": "luv",
+    "stupid": "baka",
+    "idiot": "baka",
+    "what": "nani",
+    "meow": "nya~",
+    "roar": "rawrr~",
+}
+
+EMOJIS = [
+    "rawr x3",
+    "OwO",
+    "UwU",
+    "o.O",
+    "-.-",
+    ">w<",
+    "σωσ",
+    "òωó",
+    "ʘwʘ",
+    ":3",
+    "XD",
+    "nyaa~~",
+    "mya",
+    ">_<",
+    "rawr",
+    "uwu",
+    "^^",
+    "^^;;",
+]
+
+REGEX_WORD_REPLACE = re.compile(r"(?<!w)[lr](?!w)")
+
+REGEX_PUNCTUATION = re.compile(r"[.!?\r\n\t]")
+
+REGEX_STUTTER = re.compile(r"(\s)([a-zA-Z])")
+SUBSTITUTE_STUTTER = r"\g<1>\g<2>-\g<2>"
+
+REGEX_NYA = re.compile(r"n([aeou][^aeiou])")
+SUBSTITUTE_NYA = r"ny\1"
+
+REGEX_EMOJI = re.compile(r"<(a)?:(\w+?):(\d{15,21}?)>", re.ASCII)
+
+
+@dataclass(frozen=True, eq=True)
+class Emoji:
+    """Data class for an Emoji."""
+
+    name: str
+    uid: int
+    animated: bool = False
+
+    def __str__(self):
+        anim_bit = "a" if self.animated else ""
+        return f"<{anim_bit}:{self.name}:{self.uid}>"
+
+    def can_display(self, bot: Bot) -> bool:
+        """Determines if a bot is in a server with the emoji."""
+        return bot.get_emoji(self.uid) is not None
+
+    @classmethod
+    def from_match(cls, match: tuple[str, str, str]) -> t.Optional['Emoji']:
+        """Creates an Emoji from a regex match tuple."""
+        if not match or len(match) != 3 or not match[2].isdecimal():
+            return None
+        return cls(match[1], int(match[2]), match[0] == "a")
+
+
+class Uwu(Cog):
+    """Cog for the uwu command."""
+
+    def __init__(self, bot: Bot):
+        self.bot = bot
+
+    def _word_replace(self, input_string: str) -> str:
+        """Replaces words that are keys in the word replacement hash to the values specified."""
+        for word, replacement in WORD_REPLACE.items():
+            input_string = input_string.replace(word, replacement)
+        return input_string
+
+    def _char_replace(self, input_string: str) -> str:
+        """Replace certain characters with 'w'."""
+        return REGEX_WORD_REPLACE.sub("w", input_string)
+
+    def _stutter(self, strength: float, input_string: str) -> str:
+        """Adds stuttering to a string."""
+        return REGEX_STUTTER.sub(partial(self._stutter_replace, strength=strength), input_string, 0)
+
+    def _stutter_replace(self, match: re.Match, strength: float = 0.0) -> str:
+        """Replaces a single character with a stuttered character."""
+        match_string = match.group()
+        if random.random() < strength:
+            return f"{match_string}-{match_string[-1]}"  # Stutter the last character
+        return match_string
+
+    def _nyaify(self, input_string: str) -> str:
+        """Nyaifies a string by adding a 'y' between an 'n' and a vowel."""
+        return REGEX_NYA.sub(SUBSTITUTE_NYA, input_string, 0)
+
+    def _emoji(self, strength: float, input_string: str) -> str:
+        """Replaces some punctuation with emoticons."""
+        return REGEX_PUNCTUATION.sub(partial(self._emoji_replace, strength=strength), input_string, 0)
+
+    def _emoji_replace(self, match: re.Match, strength: float = 0.0) -> str:
+        """Replaces a punctuation character with an emoticon."""
+        match_string = match.group()
+        if random.random() < strength:
+            return f" {random.choice(EMOJIS)} "
+        return match_string
+
+    def _ext_emoji_replace(self, input_string: str) -> str:
+        """Replaces any emoji the bot cannot send in input_text with a random emoticons."""
+        groups = REGEX_EMOJI.findall(input_string)
+        emojis = {Emoji.from_match(match) for match in groups}
+        # Replace with random emoticon if unable to display
+        emojis_map = {
+            re.escape(str(e)): random.choice(EMOJIS)
+            for e in emojis if e and not e.can_display(self.bot)
+        }
+        if emojis_map:
+            # Pattern for all emoji markdowns to be replaced
+            emojis_re = re.compile("|".join(emojis_map.keys()))
+            # Replace matches with random emoticon
+            return emojis_re.sub(
+                lambda m: emojis_map[re.escape(m.group())],
+                input_string
+            )
+        # Return original if no replacement
+        return input_string
+
+    def _uwuify(self, input_string: str, *, stutter_strength: float = 0.2, emoji_strength: float = 0.1) -> str:
+        """Takes a string and returns an uwuified version of it."""
+        input_string = input_string.lower()
+        input_string = self._word_replace(input_string)
+        input_string = self._nyaify(input_string)
+        input_string = self._char_replace(input_string)
+        input_string = self._stutter(stutter_strength, input_string)
+        input_string = self._emoji(emoji_strength, input_string)
+        input_string = self._ext_emoji_replace(input_string)
+        return input_string
+
+    @commands.command(name="uwu", aliases=("uwuwize", "uwuify",))
+    async def uwu_command(self, ctx: Context, *, text: t.Optional[str] = None) -> None:
+        """
+        Echo an uwuified version the passed text.
+
+        Example:
+        '.uwu Hello, my name is John' returns something like
+        'hewwo, m-my name is j-john nyaa~'.
+        """
+        # If `text` isn't provided then we try to get message content of a replied message
+        text = text or getattr(ctx.message.reference, "resolved", None)
+        if isinstance(text, discord.Message):
+            embeds = text.embeds
+            text = text.content
+        else:
+            embeds = None
+
+        if text is None:
+            # If we weren't able to get the content of a replied message
+            raise commands.UserInputError("Your message must have content or you must reply to a message.")
+
+        await clean_content(fix_channel_mentions=True).convert(ctx, text)
+
+        # Grabs the text from the embed for uwuification
+        if embeds:
+            embed = messages.convert_embed(self._uwuify, embeds[0])
+        else:
+            # Parse potential message links in text
+            text, embed = await messages.get_text_and_embed(ctx, text)
+
+            # If an embed is found, grab and uwuify its text
+            if embed:
+                embed = messages.convert_embed(self._uwuify, embed)
+
+        # Adds the text harvested from an embed to be put into another quote block.
+        if text:
+            converted_text = self._uwuify(text)
+            converted_text = helpers.suppress_links(converted_text)
+            converted_text = f">>> {converted_text.lstrip('> ')}"
+        else:
+            converted_text = None
+
+        await ctx.send(content=converted_text, embed=embed)
+
+
+def setup(bot: Bot) -> None:
+    """Load the uwu cog."""
+    bot.add_cog(Uwu(bot))
diff --git a/bot/exts/holidays/easter/egg_facts.py b/bot/exts/holidays/easter/egg_facts.py
index 5f216e0d..152af6a4 100644
--- a/bot/exts/holidays/easter/egg_facts.py
+++ b/bot/exts/holidays/easter/egg_facts.py
@@ -31,7 +31,7 @@ class EasterFacts(commands.Cog):
         """A background task that sends an easter egg fact in the event channel everyday."""
         await self.bot.wait_until_guild_available()
 
-        channel = self.bot.get_channel(Channels.community_bot_commands)
+        channel = self.bot.get_channel(Channels.sir_lancebot_playground)
         await channel.send(embed=self.make_embed())
 
     @commands.command(name="eggfact", aliases=("fact",))
diff --git a/bot/exts/holidays/halloween/candy_collection.py b/bot/exts/holidays/halloween/candy_collection.py
index 729bbc97..220ba8e5 100644
--- a/bot/exts/holidays/halloween/candy_collection.py
+++ b/bot/exts/holidays/halloween/candy_collection.py
@@ -55,7 +55,7 @@ class CandyCollection(commands.Cog):
         if message.author.bot:
             return
         # ensure it's hacktober channel
-        if message.channel.id != Channels.community_bot_commands:
+        if message.channel.id != Channels.sir_lancebot_playground:
             return
 
         # do random check for skull first as it has the lower chance
@@ -77,7 +77,7 @@ class CandyCollection(commands.Cog):
             return
 
         # check to ensure it is in correct channel
-        if message.channel.id != Channels.community_bot_commands:
+        if message.channel.id != Channels.sir_lancebot_playground:
             return
 
         # if its not a candy or skull, and it is one of 10 most recent messages,
@@ -139,7 +139,7 @@ class CandyCollection(commands.Cog):
     @property
     def hacktober_channel(self) -> discord.TextChannel:
         """Get #hacktoberbot channel from its ID."""
-        return self.bot.get_channel(Channels.community_bot_commands)
+        return self.bot.get_channel(Channels.sir_lancebot_playground)
 
     @staticmethod
     async def send_spook_msg(
diff --git a/bot/exts/holidays/halloween/spookynamerate.py b/bot/exts/holidays/halloween/spookynamerate.py
index a3aa4f13..02fb71c3 100644
--- a/bot/exts/holidays/halloween/spookynamerate.py
+++ b/bot/exts/holidays/halloween/spookynamerate.py
@@ -223,7 +223,7 @@ class SpookyNameRate(Cog):
         if self.first_time:
             await channel.send(
                 "Okkey... Welcome to the **Spooky Name Rate Game**! It's a relatively simple game.\n"
-                f"Everyday, a random name will be sent in <#{Channels.community_bot_commands}> "
+                f"Everyday, a random name will be sent in <#{Channels.sir_lancebot_playground}> "
                 "and you need to try and spookify it!\nRegister your name using "
                 f"`{Client.prefix}spookynamerate add spookified name`"
             )
@@ -359,10 +359,10 @@ class SpookyNameRate(Cog):
         """Gets the sir-lancebot-channel after waiting until ready."""
         await self.bot.wait_until_ready()
         channel = self.bot.get_channel(
-            Channels.community_bot_commands
-        ) or await self.bot.fetch_channel(Channels.community_bot_commands)
+            Channels.sir_lancebot_playground
+        ) or await self.bot.fetch_channel(Channels.sir_lancebot_playground)
         if not channel:
-            logger.warning("Bot is unable to get the #seasonalbot-commands channel. Please check the channel ID.")
+            logger.warning("Bot is unable to get the #sir-lancebot-playground channel. Please check the channel ID.")
         return channel
 
     @staticmethod
diff --git a/bot/exts/holidays/pride/pride_facts.py b/bot/exts/holidays/pride/pride_facts.py
index e6ef7108..340f0b43 100644
--- a/bot/exts/holidays/pride/pride_facts.py
+++ b/bot/exts/holidays/pride/pride_facts.py
@@ -30,7 +30,7 @@ class PrideFacts(commands.Cog):
         """Background task to post the daily pride fact every day."""
         await self.bot.wait_until_guild_available()
 
-        channel = self.bot.get_channel(Channels.community_bot_commands)
+        channel = self.bot.get_channel(Channels.sir_lancebot_playground)
         await self.send_select_fact(channel, datetime.utcnow())
 
     async def send_random_fact(self, ctx: commands.Context) -> None:
diff --git a/bot/exts/holidays/pride/pride_leader.py b/bot/exts/holidays/pride/pride_leader.py
index 298c9328..adf01134 100644
--- a/bot/exts/holidays/pride/pride_leader.py
+++ b/bot/exts/holidays/pride/pride_leader.py
@@ -83,7 +83,7 @@ class PrideLeader(commands.Cog):
         embed.add_field(
             name="For More Information",
             value=f"Do `{constants.Client.prefix}wiki {name}`"
-                  f" in <#{constants.Channels.community_bot_commands}>",
+                  f" in <#{constants.Channels.sir_lancebot_playground}>",
             inline=False
         )
         embed.set_thumbnail(url=pride_leader["url"])
diff --git a/bot/exts/holidays/valentines/be_my_valentine.py b/bot/exts/holidays/valentines/be_my_valentine.py
index 1572d474..cbb95157 100644
--- a/bot/exts/holidays/valentines/be_my_valentine.py
+++ b/bot/exts/holidays/valentines/be_my_valentine.py
@@ -70,7 +70,7 @@ class BeMyValentine(commands.Cog):
             raise commands.UserInputError("Come on, you can't send a valentine to yourself :expressionless:")
 
         emoji_1, emoji_2 = self.random_emoji()
-        channel = self.bot.get_channel(Channels.community_bot_commands)
+        channel = self.bot.get_channel(Channels.sir_lancebot_playground)
         valentine, title = self.valentine_check(valentine_type)
 
         embed = discord.Embed(
diff --git a/bot/exts/holidays/valentines/lovecalculator.py b/bot/exts/holidays/valentines/lovecalculator.py
index a53014e5..10dea9df 100644
--- a/bot/exts/holidays/valentines/lovecalculator.py
+++ b/bot/exts/holidays/valentines/lovecalculator.py
@@ -12,7 +12,7 @@ from discord.ext import commands
 from discord.ext.commands import BadArgument, Cog, clean_content
 
 from bot.bot import Bot
-from bot.constants import Channels, Client, Lovefest, Month
+from bot.constants import Channels, Lovefest, Month, PYTHON_PREFIX
 from bot.utils.decorators import in_month
 
 log = logging.getLogger(__name__)
@@ -32,7 +32,7 @@ class LoveCalculator(Cog):
         Tells you how much the two love each other.
 
         This command requires at least one member as input, if two are given love will be calculated between
-        those two users, if only one is given, the second member is asusmed to be the invoker.
+        those two users, if only one is given, the second member is assumed to be the invoker.
         Members are converted from:
           - User ID
           - Mention
@@ -51,7 +51,7 @@ class LoveCalculator(Cog):
             raise BadArgument(
                 "This command can only be ran against members with the lovefest role! "
                 "This role be can assigned by running "
-                f"`{Client.prefix}lovefest sub` in <#{Channels.community_bot_commands}>."
+                f"`{PYTHON_PREFIX}subscribe` in <#{Channels.bot_commands}>."
             )
 
         if whom is None:
@@ -90,7 +90,7 @@ class LoveCalculator(Cog):
             name="A letter from Dr. Love:",
             value=data["text"]
         )
-        embed.set_footer(text=f"You can unsubscribe from lovefest by using {Client.prefix}lovefest unsub")
+        embed.set_footer(text=f"You can unsubscribe from lovefest by using {PYTHON_PREFIX}subscribe.")
 
         await ctx.send(embed=embed)
 
diff --git a/bot/exts/utilities/bookmark.py b/bot/exts/utilities/bookmark.py
index b50205a0..2e3458d8 100644
--- a/bot/exts/utilities/bookmark.py
+++ b/bot/exts/utilities/bookmark.py
@@ -16,6 +16,13 @@ log = logging.getLogger(__name__)
 # Number of seconds to wait for other users to bookmark the same message
 TIMEOUT = 120
 BOOKMARK_EMOJI = "📌"
+MESSAGE_NOT_FOUND_ERROR = (
+    "You must either provide a reference to a valid message, or reply to one."
+    "\n\nThe lookup strategy for a message is as follows (in order):"
+    "\n1. Lookup by '{channel ID}-{message ID}' (retrieved by shift-clicking on 'Copy ID')"
+    "\n2. Lookup by message ID (the message **must** be in the current channel)"
+    "\n3. Lookup by message URL"
+)
 
 
 class Bookmark(commands.Cog):
@@ -42,51 +49,37 @@ class Bookmark(commands.Cog):
         return embed
 
     @staticmethod
-    def build_error_embed(user: discord.Member) -> discord.Embed:
-        """Builds an error embed for when a bookmark requester has DMs disabled."""
+    def build_error_embed(message: str) -> discord.Embed:
+        """Builds an error embed for a given message."""
         return discord.Embed(
             title=random.choice(ERROR_REPLIES),
-            description=f"{user.mention}, please enable your DMs to receive the bookmark.",
+            description=message,
             colour=Colours.soft_red
         )
 
     async def action_bookmark(
         self,
         channel: discord.TextChannel,
-        user: discord.Member,
+        member: discord.Member,
         target_message: discord.Message,
         title: str
     ) -> None:
-        """Sends the bookmark DM, or sends an error embed when a user bookmarks a message."""
+        """
+        Sends the given target_message as a bookmark to the member in DMs to the user.
+
+        Send an error embed instead if the member has DMs disabled.
+        """
+        embed = self.build_bookmark_dm(target_message, title)
         try:
-            embed = self.build_bookmark_dm(target_message, title)
-            await user.send(embed=embed)
+            await member.send(embed=embed)
         except discord.Forbidden:
-            error_embed = self.build_error_embed(user)
+            error_embed = self.build_error_embed(f"{member.mention}, please enable your DMs to receive the bookmark.")
             await channel.send(embed=error_embed)
         else:
-            log.info(f"{user} bookmarked {target_message.jump_url} with title '{title}'")
-
-    @staticmethod
-    async def send_reaction_embed(
-        channel: discord.TextChannel,
-        target_message: discord.Message
-    ) -> discord.Message:
-        """Sends an embed, with a reaction, so users can react to bookmark the message too."""
-        message = await channel.send(
-            embed=discord.Embed(
-                description=(
-                    f"React with {BOOKMARK_EMOJI} to be sent your very own bookmark to "
-                    f"[this message]({target_message.jump_url})."
-                ),
-                colour=Colours.soft_green
-            )
-        )
-
-        await message.add_reaction(BOOKMARK_EMOJI)
-        return message
+            log.info(f"{member} bookmarked {target_message.jump_url} with title '{title}'")
 
-    @commands.command(name="bookmark", aliases=("bm", "pin"))
+    @commands.group(name="bookmark", aliases=("bm", "pin"), invoke_without_command=True)
+    @commands.guild_only()
     @whitelist_override(roles=(Roles.everyone,))
     async def bookmark(
         self,
@@ -95,30 +88,40 @@ class Bookmark(commands.Cog):
         *,
         title: str = "Bookmark"
     ) -> None:
-        """Send the author a link to `target_message` via DMs."""
-        if not target_message:
-            if not ctx.message.reference:
-                raise commands.UserInputError(
-                    "You must either provide a valid message to bookmark, or reply to one."
-                    "\n\nThe lookup strategy for a message is as follows (in order):"
-                    "\n1. Lookup by '{channel ID}-{message ID}' (retrieved by shift-clicking on 'Copy ID')"
-                    "\n2. Lookup by message ID (the message **must** be in the context channel)"
-                    "\n3. Lookup by message URL"
-                )
-            target_message = ctx.message.reference.resolved
+        """
+        Send the author a link to the specified message via DMs.
+
+        Members can either give a message as an argument, or reply to a message.
+
+        Bookmarks can subsequently be deleted by using the `bookmark delete` command in DMs.
+        """
+        target_message: Optional[discord.Message] = target_message or getattr(ctx.message.reference, "resolved", None)
+        if target_message is None:
+            raise commands.UserInputError(MESSAGE_NOT_FOUND_ERROR)
 
         # Prevent users from bookmarking a message in a channel they don't have access to
         permissions = target_message.channel.permissions_for(ctx.author)
         if not permissions.read_messages:
             log.info(f"{ctx.author} tried to bookmark a message in #{target_message.channel} but has no permissions.")
-            embed = discord.Embed(
-                title=random.choice(ERROR_REPLIES),
-                color=Colours.soft_red,
-                description="You don't have permission to view this channel."
-            )
+            embed = self.build_error_embed(f"{ctx.author.mention} You don't have permission to view this channel.")
             await ctx.send(embed=embed)
             return
 
+        await self.action_bookmark(ctx.channel, ctx.author, target_message, title)
+
+        # Keep track of who has already bookmarked, so users can't spam reactions and cause loads of DMs
+        bookmarked_users = [ctx.author.id]
+
+        reaction_embed = discord.Embed(
+            description=(
+                f"React with {BOOKMARK_EMOJI} to be sent your very own bookmark to "
+                f"[this message]({ctx.message.jump_url})."
+            ),
+            colour=Colours.soft_green
+        )
+        reaction_message = await ctx.send(embed=reaction_embed)
+        await reaction_message.add_reaction(BOOKMARK_EMOJI)
+
         def event_check(reaction: discord.Reaction, user: discord.Member) -> bool:
             """Make sure that this reaction is what we want to operate on."""
             return (
@@ -134,11 +137,6 @@ class Bookmark(commands.Cog):
                     user.id != self.bot.user.id
                 ))
             )
-        await self.action_bookmark(ctx.channel, ctx.author, target_message, title)
-
-        # Keep track of who has already bookmarked, so users can't spam reactions and cause loads of DMs
-        bookmarked_users = [ctx.author.id]
-        reaction_message = await self.send_reaction_embed(ctx.channel, target_message)
 
         while True:
             try:
@@ -152,6 +150,31 @@ class Bookmark(commands.Cog):
 
         await reaction_message.delete()
 
+    @bookmark.command(name="delete", aliases=("del", "rm"), root_aliases=("unbm", "unbookmark", "dmdelete", "dmdel"))
+    @whitelist_override(bypass_defaults=True, allow_dm=True)
+    async def delete_bookmark(
+        self,
+        ctx: commands.Context,
+    ) -> None:
+        """
+        Delete the Sir-Lancebot message that the command invocation is replying to.
+
+        This command allows deleting any message sent by Sir-Lancebot in the user's DM channel with the bot.
+        The command invocation must be a reply to the message that is to be deleted.
+        """
+        target_message: Optional[discord.Message] = getattr(ctx.message.reference, "resolved", None)
+        if target_message is None:
+            raise commands.UserInputError("You must reply to the message from Sir-Lancebot you wish to delete.")
+
+        if not isinstance(ctx.channel, discord.DMChannel):
+            raise commands.UserInputError("You can only run this command your own DMs!")
+        elif target_message.channel != ctx.channel:
+            raise commands.UserInputError("You can only delete messages in your own DMs!")
+        elif target_message.author != self.bot.user:
+            raise commands.UserInputError("You can only delete messages sent by Sir Lancebot!")
+
+        await target_message.delete()
+
 
 def setup(bot: Bot) -> None:
     """Load the Bookmark cog."""
diff --git a/bot/exts/utilities/epoch.py b/bot/exts/utilities/epoch.py
index b9feed18..42312dd1 100644
--- a/bot/exts/utilities/epoch.py
+++ b/bot/exts/utilities/epoch.py
@@ -35,7 +35,7 @@ class DateString(commands.Converter):
         """
         try:
             return arrow.utcnow().dehumanize(argument)
-        except ValueError:
+        except (ValueError, OverflowError):
             try:
                 dt, ignored_tokens = parser.parse(argument, fuzzy_with_tokens=True)
             except parser.ParserError:
@@ -86,7 +86,10 @@ class Epoch(commands.Cog):
         view = TimestampMenuView(ctx, self._format_dates(date_time), epoch)
         original = await ctx.send(f"`{epoch}`", view=view)
         await view.wait()  # wait until expiration before removing the dropdown
-        await original.edit(view=None)
+        try:
+            await original.edit(view=None)
+        except discord.NotFound:  # disregard the error message if the message is deleled
+            pass
 
     @staticmethod
     def _format_dates(date: arrow.Arrow) -> list[str]:
diff --git a/bot/exts/utilities/githubinfo.py b/bot/exts/utilities/githubinfo.py
index 539e388b..046f67df 100644
--- a/bot/exts/utilities/githubinfo.py
+++ b/bot/exts/utilities/githubinfo.py
@@ -1,30 +1,167 @@
 import logging
 import random
+import re
+import typing as t
+from dataclasses import dataclass
 from datetime import datetime
-from urllib.parse import quote, quote_plus
+from urllib.parse import quote
 
 import discord
+from aiohttp import ClientResponse
 from discord.ext import commands
 
 from bot.bot import Bot
-from bot.constants import Colours, NEGATIVE_REPLIES
+from bot.constants import Colours, ERROR_REPLIES, Emojis, NEGATIVE_REPLIES, Tokens
 from bot.exts.core.extensions import invoke_help_command
 
 log = logging.getLogger(__name__)
 
 GITHUB_API_URL = "https://api.github.com"
 
+REQUEST_HEADERS = {
+    "Accept": "application/vnd.github.v3+json"
+}
+
+REPOSITORY_ENDPOINT = "https://api.github.com/orgs/{org}/repos?per_page=100&type=public"
+ISSUE_ENDPOINT = "https://api.github.com/repos/{user}/{repository}/issues/{number}"
+PR_ENDPOINT = "https://api.github.com/repos/{user}/{repository}/pulls/{number}"
+
+if Tokens.github:
+    REQUEST_HEADERS["Authorization"] = f"token {Tokens.github}"
+
+CODE_BLOCK_RE = re.compile(
+    r"^`([^`\n]+)`"   # Inline codeblock
+    r"|```(.+?)```",  # Multiline codeblock
+    re.DOTALL | re.MULTILINE
+)
+
+# Maximum number of issues in one message
+MAXIMUM_ISSUES = 5
+
+# Regex used when looking for automatic linking in messages
+# regex101 of current regex https://regex101.com/r/V2ji8M/6
+AUTOMATIC_REGEX = re.compile(
+    r"((?P<org>[a-zA-Z0-9][a-zA-Z0-9\-]{1,39})\/)?(?P<repo>[\w\-\.]{1,100})#(?P<number>[0-9]+)"
+)
+
+
+@dataclass(eq=True, frozen=True)
+class FoundIssue:
+    """Dataclass representing an issue found by the regex."""
+
+    organisation: t.Optional[str]
+    repository: str
+    number: str
+
+
+@dataclass(eq=True, frozen=True)
+class FetchError:
+    """Dataclass representing an error while fetching an issue."""
+
+    return_code: int
+    message: str
+
+
+@dataclass(eq=True, frozen=True)
+class IssueState:
+    """Dataclass representing the state of an issue."""
+
+    repository: str
+    number: int
+    url: str
+    title: str
+    emoji: str
+
 
 class GithubInfo(commands.Cog):
-    """Fetches info from GitHub."""
+    """A Cog that fetches info from GitHub."""
 
     def __init__(self, bot: Bot):
         self.bot = bot
+        self.repos = []
+
+    @staticmethod
+    def remove_codeblocks(message: str) -> str:
+        """Remove any codeblock in a message."""
+        return CODE_BLOCK_RE.sub("", message)
+
+    async def fetch_issue(
+        self,
+        number: int,
+        repository: str,
+        user: str
+    ) -> t.Union[IssueState, FetchError]:
+        """
+        Retrieve an issue from a GitHub repository.
+
+        Returns IssueState on success, FetchError on failure.
+        """
+        url = ISSUE_ENDPOINT.format(user=user, repository=repository, number=number)
+        pulls_url = PR_ENDPOINT.format(user=user, repository=repository, number=number)
+
+        json_data, r = await self.fetch_data(url)
+
+        if r.status == 403:
+            if r.headers.get("X-RateLimit-Remaining") == "0":
+                log.info(f"Ratelimit reached while fetching {url}")
+                return FetchError(403, "Ratelimit reached, please retry in a few minutes.")
+            return FetchError(403, "Cannot access issue.")
+        elif r.status in (404, 410):
+            return FetchError(r.status, "Issue not found.")
+        elif r.status != 200:
+            return FetchError(r.status, "Error while fetching issue.")
+
+        # The initial API request is made to the issues API endpoint, which will return information
+        # if the issue or PR is present. However, the scope of information returned for PRs differs
+        # from issues: if the 'issues' key is present in the response then we can pull the data we
+        # need from the initial API call.
+        if "issues" in json_data["html_url"]:
+            if json_data.get("state") == "open":
+                emoji = Emojis.issue_open
+            else:
+                emoji = Emojis.issue_closed
+
+        # If the 'issues' key is not contained in the API response and there is no error code, then
+        # we know that a PR has been requested and a call to the pulls API endpoint is necessary
+        # to get the desired information for the PR.
+        else:
+            pull_data, _ = await self.fetch_data(pulls_url)
+            if pull_data["draft"]:
+                emoji = Emojis.pull_request_draft
+            elif pull_data["state"] == "open":
+                emoji = Emojis.pull_request_open
+            # When 'merged_at' is not None, this means that the state of the PR is merged
+            elif pull_data["merged_at"] is not None:
+                emoji = Emojis.pull_request_merged
+            else:
+                emoji = Emojis.pull_request_closed
+
+        issue_url = json_data.get("html_url")
+
+        return IssueState(repository, number, issue_url, json_data.get("title", ""), emoji)
+
+    @staticmethod
+    def format_embed(
+        results: t.List[t.Union[IssueState, FetchError]]
+    ) -> discord.Embed:
+        """Take a list of IssueState or FetchError and format a Discord embed for them."""
+        description_list = []
+
+        for result in results:
+            if isinstance(result, IssueState):
+                description_list.append(
+                    f"{result.emoji} [[{result.repository}] #{result.number} {result.title}]({result.url})"
+                )
+            elif isinstance(result, FetchError):
+                description_list.append(f":x: [{result.return_code}] {result.message}")
+
+        resp = discord.Embed(
+            colour=Colours.bright_green,
+            description="\n".join(description_list)
+        )
 
-    async def fetch_data(self, url: str) -> dict:
-        """Retrieve data as a dictionary."""
-        async with self.bot.http_session.get(url) as r:
-            return await r.json()
+        resp.set_author(name="GitHub")
+        return resp
 
     @commands.group(name="github", aliases=("gh", "git"))
     @commands.cooldown(1, 10, commands.BucketType.user)
@@ -33,11 +170,67 @@ class GithubInfo(commands.Cog):
         if ctx.invoked_subcommand is None:
             await invoke_help_command(ctx)
 
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message) -> None:
+        """
+        Automatic issue linking.
+
+        Listener to retrieve issue(s) from a GitHub repository using automatic linking if matching <org>/<repo>#<issue>.
+        """
+        # Ignore bots
+        if message.author.bot:
+            return
+
+        issues = [
+            FoundIssue(*match.group("org", "repo", "number"))
+            for match in AUTOMATIC_REGEX.finditer(self.remove_codeblocks(message.content))
+        ]
+        links = []
+
+        if issues:
+            # Block this from working in DMs
+            if not message.guild:
+                return
+
+            log.trace(f"Found {issues = }")
+            # Remove duplicates
+            issues = list(dict.fromkeys(issues))
+
+            if len(issues) > MAXIMUM_ISSUES:
+                embed = discord.Embed(
+                    title=random.choice(ERROR_REPLIES),
+                    color=Colours.soft_red,
+                    description=f"Too many issues/PRs! (maximum of {MAXIMUM_ISSUES})"
+                )
+                await message.channel.send(embed=embed, delete_after=5)
+                return
+
+            for repo_issue in issues:
+                result = await self.fetch_issue(
+                    int(repo_issue.number),
+                    repo_issue.repository,
+                    repo_issue.organisation or "python-discord"
+                )
+                if isinstance(result, IssueState):
+                    links.append(result)
+
+        if not links:
+            return
+
+        resp = self.format_embed(links)
+        await message.channel.send(embed=resp)
+
+    async def fetch_data(self, url: str) -> tuple[dict[str], ClientResponse]:
+        """Retrieve data as a dictionary and the response in a tuple."""
+        log.trace(f"Querying GH issues API: {url}")
+        async with self.bot.http_session.get(url, headers=REQUEST_HEADERS) as r:
+            return await r.json(), r
+
     @github_group.command(name="user", aliases=("userinfo",))
     async def github_user_info(self, ctx: commands.Context, username: str) -> None:
         """Fetches a user's GitHub information."""
         async with ctx.typing():
-            user_data = await self.fetch_data(f"{GITHUB_API_URL}/users/{quote_plus(username)}")
+            user_data, _ = await self.fetch_data(f"{GITHUB_API_URL}/users/{username}")
 
             # User_data will not have a message key if the user exists
             if "message" in user_data:
@@ -50,7 +243,7 @@ class GithubInfo(commands.Cog):
                 await ctx.send(embed=embed)
                 return
 
-            org_data = await self.fetch_data(user_data["organizations_url"])
+            org_data, _ = await self.fetch_data(user_data["organizations_url"])
             orgs = [f"[{org['login']}](https://github.com/{org['login']})" for org in org_data]
             orgs_to_add = " | ".join(orgs)
 
@@ -91,10 +284,7 @@ class GithubInfo(commands.Cog):
             )
 
             if user_data["type"] == "User":
-                embed.add_field(
-                    name="Gists",
-                    value=f"[{gists}](https://gist.github.com/{quote_plus(username, safe='')})"
-                )
+                embed.add_field(name="Gists", value=f"[{gists}](https://gist.github.com/{quote(username, safe='')})")
 
                 embed.add_field(
                     name=f"Organization{'s' if len(orgs)!=1 else ''}",
@@ -123,7 +313,7 @@ class GithubInfo(commands.Cog):
             return
 
         async with ctx.typing():
-            repo_data = await self.fetch_data(f"{GITHUB_API_URL}/repos/{quote(repo)}")
+            repo_data, _ = await self.fetch_data(f"{GITHUB_API_URL}/repos/{quote(repo)}")
 
             # There won't be a message key if this repo exists
             if "message" in repo_data:
diff --git a/bot/exts/utilities/issues.py b/bot/exts/utilities/issues.py
deleted file mode 100644
index b6d5a43e..00000000
--- a/bot/exts/utilities/issues.py
+++ /dev/null
@@ -1,277 +0,0 @@
-import logging
-import random
-import re
-from dataclasses import dataclass
-from typing import Optional, Union
-
-import discord
-from discord.ext import commands
-
-from bot.bot import Bot
-from bot.constants import (
-    Categories, Channels, Colours, ERROR_REPLIES, Emojis, NEGATIVE_REPLIES, Tokens, WHITELISTED_CHANNELS
-)
-from bot.utils.decorators import whitelist_override
-from bot.utils.extensions import invoke_help_command
-
-log = logging.getLogger(__name__)
-
-BAD_RESPONSE = {
-    404: "Issue/pull request not located! Please enter a valid number!",
-    403: "Rate limit has been hit! Please try again later!"
-}
-REQUEST_HEADERS = {
-    "Accept": "application/vnd.github.v3+json"
-}
-
-REPOSITORY_ENDPOINT = "https://api.github.com/orgs/{org}/repos?per_page=100&type=public"
-ISSUE_ENDPOINT = "https://api.github.com/repos/{user}/{repository}/issues/{number}"
-PR_ENDPOINT = "https://api.github.com/repos/{user}/{repository}/pulls/{number}"
-
-if GITHUB_TOKEN := Tokens.github:
-    REQUEST_HEADERS["Authorization"] = f"token {GITHUB_TOKEN}"
-
-WHITELISTED_CATEGORIES = (
-    Categories.development, Categories.devprojects, Categories.media, Categories.staff
-)
-
-CODE_BLOCK_RE = re.compile(
-    r"^`([^`\n]+)`"  # Inline codeblock
-    r"|```(.+?)```",  # Multiline codeblock
-    re.DOTALL | re.MULTILINE
-)
-
-# Maximum number of issues in one message
-MAXIMUM_ISSUES = 5
-
-# Regex used when looking for automatic linking in messages
-# regex101 of current regex https://regex101.com/r/V2ji8M/6
-AUTOMATIC_REGEX = re.compile(
-    r"((?P<org>[a-zA-Z0-9][a-zA-Z0-9\-]{1,39})\/)?(?P<repo>[\w\-\.]{1,100})#(?P<number>[0-9]+)"
-)
-
-
-@dataclass
-class FoundIssue:
-    """Dataclass representing an issue found by the regex."""
-
-    organisation: Optional[str]
-    repository: str
-    number: str
-
-    def __hash__(self) -> int:
-        return hash((self.organisation, self.repository, self.number))
-
-
-@dataclass
-class FetchError:
-    """Dataclass representing an error while fetching an issue."""
-
-    return_code: int
-    message: str
-
-
-@dataclass
-class IssueState:
-    """Dataclass representing the state of an issue."""
-
-    repository: str
-    number: int
-    url: str
-    title: str
-    emoji: str
-
-
-class Issues(commands.Cog):
-    """Cog that allows users to retrieve issues from GitHub."""
-
-    def __init__(self, bot: Bot):
-        self.bot = bot
-        self.repos = []
-
-    @staticmethod
-    def remove_codeblocks(message: str) -> str:
-        """Remove any codeblock in a message."""
-        return re.sub(CODE_BLOCK_RE, "", message)
-
-    async def fetch_issues(
-            self,
-            number: int,
-            repository: str,
-            user: str
-    ) -> Union[IssueState, FetchError]:
-        """
-        Retrieve an issue from a GitHub repository.
-
-        Returns IssueState on success, FetchError on failure.
-        """
-        url = ISSUE_ENDPOINT.format(user=user, repository=repository, number=number)
-        pulls_url = PR_ENDPOINT.format(user=user, repository=repository, number=number)
-        log.trace(f"Querying GH issues API: {url}")
-
-        async with self.bot.http_session.get(url, headers=REQUEST_HEADERS) as r:
-            json_data = await r.json()
-
-        if r.status == 403:
-            if r.headers.get("X-RateLimit-Remaining") == "0":
-                log.info(f"Ratelimit reached while fetching {url}")
-                return FetchError(403, "Ratelimit reached, please retry in a few minutes.")
-            return FetchError(403, "Cannot access issue.")
-        elif r.status in (404, 410):
-            return FetchError(r.status, "Issue not found.")
-        elif r.status != 200:
-            return FetchError(r.status, "Error while fetching issue.")
-
-        # The initial API request is made to the issues API endpoint, which will return information
-        # if the issue or PR is present. However, the scope of information returned for PRs differs
-        # from issues: if the 'issues' key is present in the response then we can pull the data we
-        # need from the initial API call.
-        if "issues" in json_data["html_url"]:
-            if json_data.get("state") == "open":
-                emoji = Emojis.issue_open
-            else:
-                emoji = Emojis.issue_closed
-
-        # If the 'issues' key is not contained in the API response and there is no error code, then
-        # we know that a PR has been requested and a call to the pulls API endpoint is necessary
-        # to get the desired information for the PR.
-        else:
-            log.trace(f"PR provided, querying GH pulls API for additional information: {pulls_url}")
-            async with self.bot.http_session.get(pulls_url) as p:
-                pull_data = await p.json()
-                if pull_data["draft"]:
-                    emoji = Emojis.pull_request_draft
-                elif pull_data["state"] == "open":
-                    emoji = Emojis.pull_request_open
-                # When 'merged_at' is not None, this means that the state of the PR is merged
-                elif pull_data["merged_at"] is not None:
-                    emoji = Emojis.pull_request_merged
-                else:
-                    emoji = Emojis.pull_request_closed
-
-        issue_url = json_data.get("html_url")
-
-        return IssueState(repository, number, issue_url, json_data.get("title", ""), emoji)
-
-    @staticmethod
-    def format_embed(
-        results: list[Union[IssueState, FetchError]],
-        user: str,
-        repository: Optional[str] = None
-    ) -> discord.Embed:
-        """Take a list of IssueState or FetchError and format a Discord embed for them."""
-        description_list = []
-
-        for result in results:
-            if isinstance(result, IssueState):
-                description_list.append(f"{result.emoji} [{result.title}]({result.url})")
-            elif isinstance(result, FetchError):
-                description_list.append(f":x: [{result.return_code}] {result.message}")
-
-        resp = discord.Embed(
-            colour=Colours.bright_green,
-            description="\n".join(description_list)
-        )
-
-        embed_url = f"https://github.com/{user}/{repository}" if repository else f"https://github.com/{user}"
-        resp.set_author(name="GitHub", url=embed_url)
-        return resp
-
-    @whitelist_override(channels=WHITELISTED_CHANNELS, categories=WHITELISTED_CATEGORIES)
-    @commands.command(aliases=("issues", "pr", "prs"))
-    async def issue(
-        self,
-        ctx: commands.Context,
-        numbers: commands.Greedy[int],
-        repository: str = "sir-lancebot",
-        user: str = "python-discord"
-    ) -> None:
-        """Command to retrieve issue(s) from a GitHub repository."""
-        # Remove duplicates
-        numbers = set(numbers)
-
-        err_message = None
-        if not numbers:
-            err_message = "You must have at least one issue/PR!"
-
-        elif len(numbers) > MAXIMUM_ISSUES:
-            err_message = f"Too many issues/PRs! (maximum of {MAXIMUM_ISSUES})"
-
-        # If there's an error with command invocation then send an error embed
-        if err_message is not None:
-            err_embed = discord.Embed(
-                title=random.choice(ERROR_REPLIES),
-                color=Colours.soft_red,
-                description=err_message
-            )
-            await ctx.send(embed=err_embed)
-            await invoke_help_command(ctx)
-            return
-
-        results = [await self.fetch_issues(number, repository, user) for number in numbers]
-        await ctx.send(embed=self.format_embed(results, user, repository))
-
-    @commands.Cog.listener()
-    async def on_message(self, message: discord.Message) -> None:
-        """
-        Automatic issue linking.
-
-        Listener to retrieve issue(s) from a GitHub repository using automatic linking if matching <org>/<repo>#<issue>.
-        """
-        # Ignore bots
-        if message.author.bot:
-            return
-
-        issues = [
-            FoundIssue(*match.group("org", "repo", "number"))
-            for match in AUTOMATIC_REGEX.finditer(self.remove_codeblocks(message.content))
-        ]
-        links = []
-
-        if issues:
-            # Block this from working in DMs
-            if not message.guild:
-                await message.channel.send(
-                    embed=discord.Embed(
-                        title=random.choice(NEGATIVE_REPLIES),
-                        description=(
-                            "You can't retrieve issues from DMs. "
-                            f"Try again in <#{Channels.community_bot_commands}>"
-                        ),
-                        colour=Colours.soft_red
-                    )
-                )
-                return
-
-            log.trace(f"Found {issues = }")
-            # Remove duplicates
-            issues = set(issues)
-
-            if len(issues) > MAXIMUM_ISSUES:
-                embed = discord.Embed(
-                    title=random.choice(ERROR_REPLIES),
-                    color=Colours.soft_red,
-                    description=f"Too many issues/PRs! (maximum of {MAXIMUM_ISSUES})"
-                )
-                await message.channel.send(embed=embed, delete_after=5)
-                return
-
-            for repo_issue in issues:
-                result = await self.fetch_issues(
-                    int(repo_issue.number),
-                    repo_issue.repository,
-                    repo_issue.organisation or "python-discord"
-                )
-                if isinstance(result, IssueState):
-                    links.append(result)
-
-        if not links:
-            return
-
-        resp = self.format_embed(links, "python-discord")
-        await message.channel.send(embed=resp)
-
-
-def setup(bot: Bot) -> None:
-    """Load the Issues cog."""
-    bot.add_cog(Issues(bot))
diff --git a/bot/exts/utilities/realpython.py b/bot/exts/utilities/realpython.py
index bf8f1341..5e9757d0 100644
--- a/bot/exts/utilities/realpython.py
+++ b/bot/exts/utilities/realpython.py
@@ -11,11 +11,10 @@ from bot.constants import Colours
 
 logger = logging.getLogger(__name__)
 
-
 API_ROOT = "https://realpython.com/search/api/v1/"
 ARTICLE_URL = "https://realpython.com{article_url}"
 SEARCH_URL = "https://realpython.com/search?q={user_search}"
-
+HOME_URL = "https://realpython.com/"
 
 ERROR_EMBED = Embed(
     title="Error while searching Real Python",
@@ -32,13 +31,22 @@ class RealPython(commands.Cog):
 
     @commands.command(aliases=["rp"])
     @commands.cooldown(1, 10, commands.cooldowns.BucketType.user)
-    async def realpython(self, ctx: commands.Context, amount: Optional[int] = 5, *, user_search: str) -> None:
+    async def realpython(self, ctx: commands.Context, amount: Optional[int] = 5, *,
+                         user_search: Optional[str] = None) -> None:
         """
         Send some articles from RealPython that match the search terms.
 
-        By default the top 5 matches are sent, this can be overwritten to
+        By default, the top 5 matches are sent. This can be overwritten to
         a number between 1 and 5 by specifying an amount before the search query.
+        If no search query is specified by the user, the home page is sent.
         """
+        if user_search is None:
+            home_page_embed = Embed(title="Real Python Home Page", url=HOME_URL, colour=Colours.orange)
+
+            await ctx.send(embed=home_page_embed)
+
+            return
+
         if not 1 <= amount <= 5:
             await ctx.send("`amount` must be between 1 and 5 (inclusive).")
             return
diff --git a/bot/exts/utilities/twemoji.py b/bot/exts/utilities/twemoji.py
new file mode 100644
index 00000000..c915f05b
--- /dev/null
+++ b/bot/exts/utilities/twemoji.py
@@ -0,0 +1,150 @@
+import logging
+import re
+from typing import Literal, Optional
+
+import discord
+from discord.ext import commands
+from emoji import UNICODE_EMOJI_ENGLISH, is_emoji
+
+from bot.bot import Bot
+from bot.constants import Colours, Roles
+from bot.utils.decorators import whitelist_override
+from bot.utils.extensions import invoke_help_command
+
+log = logging.getLogger(__name__)
+BASE_URLS = {
+    "png": "https://raw.githubusercontent.com/twitter/twemoji/master/assets/72x72/",
+    "svg": "https://raw.githubusercontent.com/twitter/twemoji/master/assets/svg/",
+}
+CODEPOINT_REGEX = re.compile(r"[a-f1-9][a-f0-9]{3,5}$")
+
+
+class Twemoji(commands.Cog):
+    """Utilities for working with Twemojis."""
+
+    def __init__(self, bot: Bot):
+        self.bot = bot
+
+    @staticmethod
+    def get_url(codepoint: str, format: Literal["png", "svg"]) -> str:
+        """Returns a source file URL for the specified Twemoji, in the corresponding format."""
+        return f"{BASE_URLS[format]}{codepoint}.{format}"
+
+    @staticmethod
+    def alias_to_name(alias: str) -> str:
+        """
+        Transform a unicode alias to an emoji name.
+
+        Example usages:
+        >>> alias_to_name(":falling_leaf:")
+        "Falling leaf"
+        >>> alias_to_name(":family_man_girl_boy:")
+        "Family man girl boy"
+        """
+        name = alias.strip(":").replace("_", " ")
+        return name.capitalize()
+
+    @staticmethod
+    def build_embed(codepoint: str) -> discord.Embed:
+        """Returns the main embed for the `twemoji` commmand."""
+        emoji = "".join(Twemoji.emoji(e) or "" for e in codepoint.split("-"))
+
+        embed = discord.Embed(
+            title=Twemoji.alias_to_name(UNICODE_EMOJI_ENGLISH[emoji]),
+            description=f"{codepoint.replace('-', ' ')}\n[Download svg]({Twemoji.get_url(codepoint, 'svg')})",
+            colour=Colours.twitter_blue,
+        )
+        embed.set_thumbnail(url=Twemoji.get_url(codepoint, "png"))
+        return embed
+
+    @staticmethod
+    def emoji(codepoint: Optional[str]) -> Optional[str]:
+        """
+        Returns the emoji corresponding to a given `codepoint`, or `None` if no emoji was found.
+
+        The return value is an emoji character, such as "🍂". The `codepoint`
+        argument can be of any format, since it will be trimmed automatically.
+        """
+        if code := Twemoji.trim_code(codepoint):
+            return chr(int(code, 16))
+
+    @staticmethod
+    def codepoint(emoji: Optional[str]) -> Optional[str]:
+        """
+        Returns the codepoint, in a trimmed format, of a single emoji.
+
+        `emoji` should be an emoji character, such as "🐍" and "🥰", and
+        not a codepoint like "1f1f8". When working with combined emojis,
+        such as "🇸🇪" and "👨‍👩‍👦", send the component emojis through the method
+        one at a time.
+        """
+        if emoji is None:
+            return None
+        return hex(ord(emoji)).removeprefix("0x")
+
+    @staticmethod
+    def trim_code(codepoint: Optional[str]) -> Optional[str]:
+        """
+        Returns the meaningful information from the given `codepoint`.
+
+        If no codepoint is found, `None` is returned.
+
+        Example usages:
+        >>> trim_code("U+1f1f8")
+        "1f1f8"
+        >>> trim_code("\u0001f1f8")
+        "1f1f8"
+        >>> trim_code("1f466")
+        "1f466"
+        """
+        if code := CODEPOINT_REGEX.search(codepoint or ""):
+            return code.group()
+
+    @staticmethod
+    def codepoint_from_input(raw_emoji: tuple[str, ...]) -> str:
+        """
+        Returns the codepoint corresponding to the passed tuple, separated by "-".
+
+        The return format matches the format used in URLs for Twemoji source files.
+
+        Example usages:
+        >>> codepoint_from_input(("🐍",))
+        "1f40d"
+        >>> codepoint_from_input(("1f1f8", "1f1ea"))
+        "1f1f8-1f1ea"
+        >>> codepoint_from_input(("👨‍👧‍👦",))
+        "1f468-200d-1f467-200d-1f466"
+        """
+        raw_emoji = [emoji.lower() for emoji in raw_emoji]
+        if is_emoji(raw_emoji[0]):
+            emojis = (Twemoji.codepoint(emoji) or "" for emoji in raw_emoji[0])
+            return "-".join(emojis)
+
+        emoji = "".join(
+            Twemoji.emoji(Twemoji.trim_code(code)) or "" for code in raw_emoji
+        )
+        if is_emoji(emoji):
+            return "-".join(Twemoji.codepoint(e) or "" for e in emoji)
+
+        raise ValueError("No codepoint could be obtained from the given input")
+
+    @commands.command(aliases=("tw",))
+    @whitelist_override(roles=(Roles.everyone,))
+    async def twemoji(self, ctx: commands.Context, *raw_emoji: str) -> None:
+        """Sends a preview of a given Twemoji, specified by codepoint or emoji."""
+        if len(raw_emoji) == 0:
+            await invoke_help_command(ctx)
+            return
+        try:
+            codepoint = self.codepoint_from_input(raw_emoji)
+        except ValueError:
+            raise commands.BadArgument(
+                "please include a valid emoji or emoji codepoint."
+            )
+
+        await ctx.send(embed=self.build_embed(codepoint))
+
+
+def setup(bot: Bot) -> None:
+    """Load the Twemoji cog."""
+    bot.add_cog(Twemoji(bot))
diff --git a/bot/log.py b/bot/log.py
index 29e696e0..a87a836a 100644
--- a/bot/log.py
+++ b/bot/log.py
@@ -6,7 +6,7 @@ from pathlib import Path
 
 import coloredlogs
 
-from bot.constants import Client
+from bot.constants import Logging
 
 
 def setup() -> None:
@@ -20,7 +20,7 @@ def setup() -> None:
     log_format = logging.Formatter(format_string)
     root_logger = logging.getLogger()
 
-    if Client.file_logs:
+    if Logging.file_logs:
         # Set up file logging
         log_file = Path("logs/sir-lancebot.log")
         log_file.parent.mkdir(exist_ok=True)
@@ -45,7 +45,7 @@ def setup() -> None:
 
     coloredlogs.install(level=logging.TRACE, stream=sys.stdout)
 
-    root_logger.setLevel(logging.DEBUG if Client.debug else logging.INFO)
+    root_logger.setLevel(logging.DEBUG if Logging.debug else logging.INFO)
     # Silence irrelevant loggers
     logging.getLogger("discord").setLevel(logging.ERROR)
     logging.getLogger("websockets").setLevel(logging.ERROR)
@@ -81,7 +81,7 @@ def _set_trace_loggers() -> None:
     Otherwise if the env var begins with a "*",
     the root logger is set to the trace level and other contents are ignored.
     """
-    level_filter = Client.trace_loggers
+    level_filter = Logging.trace_loggers
     if level_filter:
         if level_filter.startswith("*"):
             logging.getLogger().setLevel(logging.TRACE)
diff --git a/bot/resources/fun/latex_template.txt b/bot/resources/fun/latex_template.txt
new file mode 100644
index 00000000..6e67b810
--- /dev/null
+++ b/bot/resources/fun/latex_template.txt
@@ -0,0 +1,13 @@
+\documentclass{article}
+\usepackage{amsmath,amsthm,amssymb,amsfonts}
+\usepackage{bm}  % nice bold symbols for matrices and vectors
+\usepackage{bbm}  % bold and calligraphic numbers
+\usepackage[binary-units=true]{siunitx}  % SI unit handling
+\usepackage{tikz}  % from here on, to make nice diagrams with tikz
+\usepackage{ifthen}
+\usetikzlibrary{patterns}
+\usetikzlibrary{shapes, arrows, chains, fit, positioning, calc, decorations.pathreplacing}
+\begin{document}
+    \pagenumbering{gobble}
+    $text
+\end{document}
diff --git a/bot/resources/utilities/py_topics.yaml b/bot/resources/utilities/py_topics.yaml
index 1cd2c325..4527e8de 100644
--- a/bot/resources/utilities/py_topics.yaml
+++ b/bot/resources/utilities/py_topics.yaml
@@ -35,12 +35,31 @@
     - Have you ever worked with a microcontroller or anything physical with Python before?
     - Have you ever tried making your own programming language?
     - Has a recently discovered Python module changed your general use of Python?
+    - What is your motivation for programming?
+    - What's your favorite Python related book?
+    - What's your favorite use of recursion in Python?
+    - If you could change one thing in Python, what would it be?
+    - What third-party library do you wish was in the Python standard library?
+    - Which package do you use the most and why?
+    - Which Python feature do you love the most?
+    - Do you have any plans for future projects?
+    - What modules/libraries do you want to see more projects using?
+    - What's the most ambitious thing you've done with Python so far?
+
+# programming-pedagogy
+934931964509691966:
+    - What is the best way to teach/learn OOP?
+    - What benefits are there to teaching programming to students who aren't training to become developers?
+    - What are some basic concepts that we need to know before teaching programming to others?
+    - What are the most common difficulties/misconceptions students encounter while learning to program?
+    - What makes a project a good learning experience for beginners?
+    - What can make difficult concepts more fun for students to learn?
 
 # algos-and-data-structs
 650401909852864553:
     -
 
-# async
+# async-and-concurrency
 630504881542791169:
     - Are there any frameworks you wish were async?
     - How have coroutines changed the way you write Python?
@@ -54,12 +73,13 @@
 342318764227821568:
     - Where do you get your best data?
     - What is your preferred database and for what use?
+    - What is the least safe use of databases you've seen?
 
-# data-science
+# data-science-and-ai
 366673247892275221:
     -
 
-# discord.py
+# discord-bots
 343944376055103488:
     - What unique features does your bot contain, if any?
     - What commands/features are you proud of making?
@@ -78,6 +98,8 @@
     - What's a common part of programming we can make harder?
     - What are the pros and cons of messing with __magic__()?
     - What's your favorite Python hack?
+    - What's the weirdest language feature that Python doesn't have, and how can we change that?
+    - What is the most esoteric code you've written?
 
 # game-development
 660625198390837248:
@@ -87,6 +109,17 @@
     - What books or tutorials would you recommend for game-development beginners?
     - What made you start developing games?
 
+# media-processing
+971142229462777926:
+    - Where do you start with media processing? What is a good beginner project for first-timers in media processing?
+    - What are some ways you could manipulate media using Python?
+    - What is your favorite algorithm for manipulating media with Python?
+    - What is the most surprising result you have gotten after manipulating media with Python?
+    - What is the worst outcome you have gotten after manipulating media with Python?
+    - What is your most advanced media processing related achievement?
+    - Do you know any cool tricks or optimizations for manipulating media with Python?
+    - Can a computer truly generate and/or understand art?
+
 # microcontrollers
 545603026732318730:
     - What is your favorite version of the Raspberry Pi?
@@ -110,6 +143,10 @@
     - How often do you use GitHub Actions and workflows to automate your repositories?
     - What's your favorite app on GitHub?
 
+# type-hinting
+891788761371906108:
+    -
+
 # unit-testing
 463035728335732738:
     -
@@ -120,6 +157,7 @@
     - What's your most used Bash command?
     - How often do you update your Unix machine?
     - How often do you upgrade on production?
+    - What is your least favorite thing about interoperability amongst *NIX operating systems and/or platforms?
 
 # user-interfaces
 338993628049571840:
@@ -128,6 +166,7 @@
     - Do you perfer Command Line Interfaces (CLI) or Graphic User Interfaces (GUI)?
     - What's your favorite CLI (Command Line Interface) or TUI (Terminal Line Interface)?
     - What's your best GUI project?
+    - What the best-looking app you've used?
 
 # web-development
 366673702533988363:
@@ -136,3 +175,4 @@
     - What is your favorite API library?
     - What do you use for your frontend?
     - What does your stack look like?
+    - What's the best-looking website you've visited?
diff --git a/bot/resources/utilities/starter.yaml b/bot/resources/utilities/starter.yaml
index 6b0de0ef..ce759e1a 100644
--- a/bot/resources/utilities/starter.yaml
+++ b/bot/resources/utilities/starter.yaml
@@ -32,8 +32,6 @@
 - How many years have you spent coding?
 - What book do you highly recommend everyone to read?
 - What websites do you use daily to keep yourself up to date with the industry?
-- What made you want to join this Discord server?
-- How are you?
 - What is the best advice you have ever gotten in regards to programming/software?
 - What is the most satisfying thing you've done in your life?
 - Who is your favorite music composer/producer/singer?
@@ -49,3 +47,4 @@
 - What artistic talents do you have?
 - What is the tallest building you've entered?
 - What is the oldest computer you've ever used?
+- What animals do you like?
diff --git a/bot/utils/checks.py b/bot/utils/checks.py
index 8c426ed7..5433f436 100644
--- a/bot/utils/checks.py
+++ b/bot/utils/checks.py
@@ -33,7 +33,7 @@ def in_whitelist_check(
     channels: Container[int] = (),
     categories: Container[int] = (),
     roles: Container[int] = (),
-    redirect: Optional[int] = constants.Channels.community_bot_commands,
+    redirect: Optional[int] = constants.Channels.sir_lancebot_playground,
     fail_silently: bool = False,
 ) -> bool:
     """
diff --git a/bot/utils/commands.py b/bot/utils/commands.py
new file mode 100644
index 00000000..7c04a25a
--- /dev/null
+++ b/bot/utils/commands.py
@@ -0,0 +1,11 @@
+from typing import Optional
+
+from rapidfuzz import process
+
+
+def get_command_suggestions(
+        all_commands: list[str], query: str, *, cutoff: int = 60, limit: int = 3
+) -> Optional[list]:
+    """Get similar command names."""
+    results = process.extract(query, all_commands, score_cutoff=cutoff, limit=limit)
+    return [result[0] for result in results]
diff --git a/bot/utils/decorators.py b/bot/utils/decorators.py
index 0061abd9..442eb841 100644
--- a/bot/utils/decorators.py
+++ b/bot/utils/decorators.py
@@ -272,10 +272,10 @@ def whitelist_check(**default_kwargs: Container[int]) -> Callable[[Context], boo
         channels = set(kwargs.get("channels") or {})
         categories = kwargs.get("categories")
 
-        # Only output override channels + community_bot_commands
+        # Only output override channels + sir_lancebot_playground
         if channels:
             default_whitelist_channels = set(WHITELISTED_CHANNELS)
-            default_whitelist_channels.discard(Channels.community_bot_commands)
+            default_whitelist_channels.discard(Channels.sir_lancebot_playground)
             channels.difference_update(default_whitelist_channels)
 
         # Add all whitelisted category channels, but skip if we're in DMs
diff --git a/bot/utils/messages.py b/bot/utils/messages.py
index a6c035f9..b0c95583 100644
--- a/bot/utils/messages.py
+++ b/bot/utils/messages.py
@@ -1,5 +1,12 @@
+import logging
 import re
-from typing import Optional
+from typing import Callable, Optional, Union
+
+from discord import Embed, Message
+from discord.ext import commands
+from discord.ext.commands import Context, MessageConverter
+
+log = logging.getLogger(__name__)
 
 
 def sub_clyde(username: Optional[str]) -> Optional[str]:
@@ -17,3 +24,66 @@ def sub_clyde(username: Optional[str]) -> Optional[str]:
         return re.sub(r"(clyd)(e)", replace_e, username, flags=re.I)
     else:
         return username  # Empty string or None
+
+
+async def get_discord_message(ctx: Context, text: str) -> Union[Message, str]:
+    """
+    Attempts to convert a given `text` to a discord Message object and return it.
+
+    Conversion will succeed if given a discord Message ID or link.
+    Returns `text` if the conversion fails.
+    """
+    try:
+        text = await MessageConverter().convert(ctx, text)
+    except commands.BadArgument:
+        pass
+
+    return text
+
+
+async def get_text_and_embed(ctx: Context, text: str) -> tuple[str, Optional[Embed]]:
+    """
+    Attempts to extract the text and embed from a possible link to a discord Message.
+
+    Does not retrieve the text and embed from the Message if it is in a channel the user does
+    not have read permissions in.
+
+    Returns a tuple of:
+        str: If `text` is a valid discord Message, the contents of the message, else `text`.
+        Optional[Embed]: The embed if found in the valid Message, else None
+    """
+    embed: Optional[Embed] = None
+
+    msg = await get_discord_message(ctx, text)
+    # Ensure the user has read permissions for the channel the message is in
+    if isinstance(msg, Message):
+        permissions = msg.channel.permissions_for(ctx.author)
+        if permissions.read_messages:
+            text = msg.clean_content
+            # Take first embed because we can't send multiple embeds
+            if msg.embeds:
+                embed = msg.embeds[0]
+
+    return text, embed
+
+
+def convert_embed(func: Callable[[str, ], str], embed: Embed) -> Embed:
+    """
+    Converts the text in an embed using a given conversion function, then return the embed.
+
+    Only modifies the following fields: title, description, footer, fields
+    """
+    embed_dict = embed.to_dict()
+
+    embed_dict["title"] = func(embed_dict.get("title", ""))
+    embed_dict["description"] = func(embed_dict.get("description", ""))
+
+    if "footer" in embed_dict:
+        embed_dict["footer"]["text"] = func(embed_dict["footer"].get("text", ""))
+
+    if "fields" in embed_dict:
+        for field in embed_dict["fields"]:
+            field["name"] = func(field.get("name", ""))
+            field["value"] = func(field.get("value", ""))
+
+    return Embed.from_dict(embed_dict)
diff --git a/poetry.lock b/poetry.lock
index 6a83efed..08d0de7e 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -193,6 +193,7 @@ voice = ["PyNaCl (>=1.3.0,<1.5)"]
 [package.source]
 type = "url"
 url = "https://github.com/Rapptz/discord.py/archive/45d498c1b76deaf3b394d17ccf56112fa691d160.zip"
+
 [[package]]
 name = "distlib"
 version = "0.3.4"
@@ -202,6 +203,17 @@ optional = false
 python-versions = "*"
 
 [[package]]
+name = "emoji"
+version = "1.6.3"
+description = "Emoji for Python"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.extras]
+dev = ["pytest", "coverage", "coveralls"]
+
+[[package]]
 name = "emojis"
 version = "0.6.0"
 description = "Emojis for Python"
@@ -224,8 +236,8 @@ six = ">=1.12"
 sortedcontainers = "*"
 
 [package.extras]
-aioredis = ["aioredis"]
 lua = ["lupa"]
+aioredis = ["aioredis"]
 
 [[package]]
 name = "filelock"
@@ -404,7 +416,7 @@ plugins = ["setuptools"]
 
 [[package]]
 name = "lxml"
-version = "4.7.1"
+version = "4.9.1"
 description = "Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API."
 category = "main"
 optional = false
@@ -473,11 +485,11 @@ flake8-polyfill = ">=1.0.2,<2"
 
 [[package]]
 name = "pillow"
-version = "8.4.0"
+version = "9.0.1"
 description = "Python Imaging Library (Fork)"
 category = "main"
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.7"
 
 [[package]]
 name = "pip-licenses"
@@ -542,7 +554,7 @@ python-versions = "*"
 
 [[package]]
 name = "pycares"
-version = "4.1.2"
+version = "4.2.0"
 description = "Python interface for c-ares"
 category = "main"
 optional = false
@@ -593,6 +605,18 @@ optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
 
 [[package]]
+name = "pyjokes"
+version = "0.6.0"
+description = "One line jokes for programmers (jokes as a service)"
+category = "main"
+optional = false
+python-versions = "*"
+
+[package.extras]
+test = ["tox", "coverage", "pytest"]
+doc = ["mkdocs"]
+
+[[package]]
 name = "pyparsing"
 version = "3.0.6"
 description = "Python parsing module"
@@ -823,829 +847,80 @@ multidict = ">=4.0"
 [metadata]
 lock-version = "1.1"
 python-versions = "^3.9"
-content-hash = "e3682fd5b518ada5066b36015210f00d223c5485c24e4e7c377e371fe6ef0a0d"
+content-hash = "86ef4c274176e805702da51d96711698a09ca6e04c145b607258c34d04638b9e"
 
 [metadata.files]
-aiodns = [
-    {file = "aiodns-2.0.0-py2.py3-none-any.whl", hash = "sha256:aaa5ac584f40fe778013df0aa6544bf157799bd3f608364b451840ed2c8688de"},
-    {file = "aiodns-2.0.0.tar.gz", hash = "sha256:815fdef4607474295d68da46978a54481dd1e7be153c7d60f9e72773cd38d77d"},
-]
-aiohttp = [
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:3cf75f7cdc2397ed4442594b935a11ed5569961333d49b7539ea741be2cc79d5"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:4b302b45040890cea949ad092479e01ba25911a15e648429c7c5aae9650c67a8"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:fe60131d21b31fd1a14bd43e6bb88256f69dfc3188b3a89d736d6c71ed43ec95"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_i686.whl", hash = "sha256:393f389841e8f2dfc86f774ad22f00923fdee66d238af89b70ea314c4aefd290"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_ppc64le.whl", hash = "sha256:c6e9dcb4cb338d91a73f178d866d051efe7c62a7166653a91e7d9fb18274058f"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_s390x.whl", hash = "sha256:5df68496d19f849921f05f14f31bd6ef53ad4b00245da3195048c69934521809"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-manylinux2014_x86_64.whl", hash = "sha256:0563c1b3826945eecd62186f3f5c7d31abb7391fedc893b7e2b26303b5a9f3fe"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-win32.whl", hash = "sha256:3d78619672183be860b96ed96f533046ec97ca067fd46ac1f6a09cd9b7484287"},
-    {file = "aiohttp-3.7.4.post0-cp36-cp36m-win_amd64.whl", hash = "sha256:f705e12750171c0ab4ef2a3c76b9a4024a62c4103e3a55dd6f99265b9bc6fcfc"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:230a8f7e24298dea47659251abc0fd8b3c4e38a664c59d4b89cca7f6c09c9e87"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:2e19413bf84934d651344783c9f5e22dee452e251cfd220ebadbed2d9931dbf0"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:e4b2b334e68b18ac9817d828ba44d8fcb391f6acb398bcc5062b14b2cbeac970"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_i686.whl", hash = "sha256:d012ad7911653a906425d8473a1465caa9f8dea7fcf07b6d870397b774ea7c0f"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_ppc64le.whl", hash = "sha256:40eced07f07a9e60e825554a31f923e8d3997cfc7fb31dbc1328c70826e04cde"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_s390x.whl", hash = "sha256:209b4a8ee987eccc91e2bd3ac36adee0e53a5970b8ac52c273f7f8fd4872c94c"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-manylinux2014_x86_64.whl", hash = "sha256:14762875b22d0055f05d12abc7f7d61d5fd4fe4642ce1a249abdf8c700bf1fd8"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-win32.whl", hash = "sha256:7615dab56bb07bff74bc865307aeb89a8bfd9941d2ef9d817b9436da3a0ea54f"},
-    {file = "aiohttp-3.7.4.post0-cp37-cp37m-win_amd64.whl", hash = "sha256:d9e13b33afd39ddeb377eff2c1c4f00544e191e1d1dee5b6c51ddee8ea6f0cf5"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:547da6cacac20666422d4882cfcd51298d45f7ccb60a04ec27424d2f36ba3eaf"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux1_i686.whl", hash = "sha256:af9aa9ef5ba1fd5b8c948bb11f44891968ab30356d65fd0cc6707d989cd521df"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:64322071e046020e8797117b3658b9c2f80e3267daec409b350b6a7a05041213"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_i686.whl", hash = "sha256:bb437315738aa441251214dad17428cafda9cdc9729499f1d6001748e1d432f4"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_ppc64le.whl", hash = "sha256:e54962802d4b8b18b6207d4a927032826af39395a3bd9196a5af43fc4e60b009"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_s390x.whl", hash = "sha256:a00bb73540af068ca7390e636c01cbc4f644961896fa9363154ff43fd37af2f5"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:79ebfc238612123a713a457d92afb4096e2148be17df6c50fb9bf7a81c2f8013"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-win32.whl", hash = "sha256:515dfef7f869a0feb2afee66b957cc7bbe9ad0cdee45aec7fdc623f4ecd4fb16"},
-    {file = "aiohttp-3.7.4.post0-cp38-cp38-win_amd64.whl", hash = "sha256:114b281e4d68302a324dd33abb04778e8557d88947875cbf4e842c2c01a030c5"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:7b18b97cf8ee5452fa5f4e3af95d01d84d86d32c5e2bfa260cf041749d66360b"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux1_i686.whl", hash = "sha256:15492a6368d985b76a2a5fdd2166cddfea5d24e69eefed4630cbaae5c81d89bd"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:bdb230b4943891321e06fc7def63c7aace16095be7d9cf3b1e01be2f10fba439"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_i686.whl", hash = "sha256:cffe3ab27871bc3ea47df5d8f7013945712c46a3cc5a95b6bee15887f1675c22"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_ppc64le.whl", hash = "sha256:f881853d2643a29e643609da57b96d5f9c9b93f62429dcc1cbb413c7d07f0e1a"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_s390x.whl", hash = "sha256:a5ca29ee66f8343ed336816c553e82d6cade48a3ad702b9ffa6125d187e2dedb"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:17c073de315745a1510393a96e680d20af8e67e324f70b42accbd4cb3315c9fb"},
-    {file = "aiohttp-3.7.4.post0-cp39-cp39-win32.whl", hash = "sha256:932bb1ea39a54e9ea27fc9232163059a0b8855256f4052e776357ad9add6f1c9"},
-    {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"},
-]
-aioredis = [
-    {file = "aioredis-1.3.1-py3-none-any.whl", hash = "sha256:b61808d7e97b7cd5a92ed574937a079c9387fdadd22bfbfa7ad2fd319ecc26e3"},
-    {file = "aioredis-1.3.1.tar.gz", hash = "sha256:15f8af30b044c771aee6787e5ec24694c048184c7b9e54c3b60c750a4b93273a"},
-]
-arrow = [
-    {file = "arrow-1.1.1-py3-none-any.whl", hash = "sha256:77a60a4db5766d900a2085ce9074c5c7b8e2c99afeaa98ad627637ff6f292510"},
-    {file = "arrow-1.1.1.tar.gz", hash = "sha256:dee7602f6c60e3ec510095b5e301441bc56288cb8f51def14dcb3079f623823a"},
-]
-async-rediscache = [
-    {file = "async-rediscache-0.1.4.tar.gz", hash = "sha256:6be8a657d724ccbcfb1946d29a80c3478c5f9ecd2f78a0a26d2f4013a622258f"},
-    {file = "async_rediscache-0.1.4-py3-none-any.whl", hash = "sha256:c25e4fff73f64d20645254783c3224a4c49e083e3fab67c44f17af944c5e26af"},
-]
-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"},
-]
-attrs = [
-    {file = "attrs-21.3.0-py2.py3-none-any.whl", hash = "sha256:8f7335278dedd26b58c38e006338242cc0977f06d51579b2b8b87b9b33bff66c"},
-    {file = "attrs-21.3.0.tar.gz", hash = "sha256:50f3c9b216dc9021042f71b392859a773b904ce1a029077f58f6598272432045"},
-]
-beautifulsoup4 = [
-    {file = "beautifulsoup4-4.10.0-py3-none-any.whl", hash = "sha256:9a315ce70049920ea4572a4055bc4bd700c940521d36fc858205ad4fcde149bf"},
-    {file = "beautifulsoup4-4.10.0.tar.gz", hash = "sha256:c23ad23c521d818955a4151a67d81580319d4bf548d3d49f4223ae041ff98891"},
-]
-certifi = [
-    {file = "certifi-2021.10.8-py2.py3-none-any.whl", hash = "sha256:d62a0163eb4c2344ac042ab2bdf75399a71a2d8c7d47eac2e2ee91b9d6339569"},
-    {file = "certifi-2021.10.8.tar.gz", hash = "sha256:78884e7c1d4b00ce3cea67b44566851c4343c120abd683433ce934a68ea58872"},
-]
-cffi = [
-    {file = "cffi-1.15.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:c2502a1a03b6312837279c8c1bd3ebedf6c12c4228ddbad40912d671ccc8a962"},
-    {file = "cffi-1.15.0-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:23cfe892bd5dd8941608f93348c0737e369e51c100d03718f108bf1add7bd6d0"},
-    {file = "cffi-1.15.0-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:41d45de54cd277a7878919867c0f08b0cf817605e4eb94093e7516505d3c8d14"},
-    {file = "cffi-1.15.0-cp27-cp27m-win32.whl", hash = "sha256:4a306fa632e8f0928956a41fa8e1d6243c71e7eb59ffbd165fc0b41e316b2474"},
-    {file = "cffi-1.15.0-cp27-cp27m-win_amd64.whl", hash = "sha256:e7022a66d9b55e93e1a845d8c9eba2a1bebd4966cd8bfc25d9cd07d515b33fa6"},
-    {file = "cffi-1.15.0-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:14cd121ea63ecdae71efa69c15c5543a4b5fbcd0bbe2aad864baca0063cecf27"},
-    {file = "cffi-1.15.0-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:d4d692a89c5cf08a8557fdeb329b82e7bf609aadfaed6c0d79f5a449a3c7c023"},
-    {file = "cffi-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0104fb5ae2391d46a4cb082abdd5c69ea4eab79d8d44eaaf79f1b1fd806ee4c2"},
-    {file = "cffi-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:91ec59c33514b7c7559a6acda53bbfe1b283949c34fe7440bcf917f96ac0723e"},
-    {file = "cffi-1.15.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f5c7150ad32ba43a07c4479f40241756145a1f03b43480e058cfd862bf5041c7"},
-    {file = "cffi-1.15.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:00c878c90cb53ccfaae6b8bc18ad05d2036553e6d9d1d9dbcf323bbe83854ca3"},
-    {file = "cffi-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:abb9a20a72ac4e0fdb50dae135ba5e77880518e742077ced47eb1499e29a443c"},
-    {file = "cffi-1.15.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a5263e363c27b653a90078143adb3d076c1a748ec9ecc78ea2fb916f9b861962"},
-    {file = "cffi-1.15.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f54a64f8b0c8ff0b64d18aa76675262e1700f3995182267998c31ae974fbc382"},
-    {file = "cffi-1.15.0-cp310-cp310-win32.whl", hash = "sha256:c21c9e3896c23007803a875460fb786118f0cdd4434359577ea25eb556e34c55"},
-    {file = "cffi-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:5e069f72d497312b24fcc02073d70cb989045d1c91cbd53979366077959933e0"},
-    {file = "cffi-1.15.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:64d4ec9f448dfe041705426000cc13e34e6e5bb13736e9fd62e34a0b0c41566e"},
-    {file = "cffi-1.15.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2756c88cbb94231c7a147402476be2c4df2f6078099a6f4a480d239a8817ae39"},
-    {file = "cffi-1.15.0-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b96a311ac60a3f6be21d2572e46ce67f09abcf4d09344c49274eb9e0bf345fc"},
-    {file = "cffi-1.15.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75e4024375654472cc27e91cbe9eaa08567f7fbdf822638be2814ce059f58032"},
-    {file = "cffi-1.15.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:59888172256cac5629e60e72e86598027aca6bf01fa2465bdb676d37636573e8"},
-    {file = "cffi-1.15.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:27c219baf94952ae9d50ec19651a687b826792055353d07648a5695413e0c605"},
-    {file = "cffi-1.15.0-cp36-cp36m-win32.whl", hash = "sha256:4958391dbd6249d7ad855b9ca88fae690783a6be9e86df65865058ed81fc860e"},
-    {file = "cffi-1.15.0-cp36-cp36m-win_amd64.whl", hash = "sha256:f6f824dc3bce0edab5f427efcfb1d63ee75b6fcb7282900ccaf925be84efb0fc"},
-    {file = "cffi-1.15.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:06c48159c1abed75c2e721b1715c379fa3200c7784271b3c46df01383b593636"},
-    {file = "cffi-1.15.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c2051981a968d7de9dd2d7b87bcb9c939c74a34626a6e2f8181455dd49ed69e4"},
-    {file = "cffi-1.15.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:fd8a250edc26254fe5b33be00402e6d287f562b6a5b2152dec302fa15bb3e997"},
-    {file = "cffi-1.15.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:91d77d2a782be4274da750752bb1650a97bfd8f291022b379bb8e01c66b4e96b"},
-    {file = "cffi-1.15.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:45db3a33139e9c8f7c09234b5784a5e33d31fd6907800b316decad50af323ff2"},
-    {file = "cffi-1.15.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:263cc3d821c4ab2213cbe8cd8b355a7f72a8324577dc865ef98487c1aeee2bc7"},
-    {file = "cffi-1.15.0-cp37-cp37m-win32.whl", hash = "sha256:17771976e82e9f94976180f76468546834d22a7cc404b17c22df2a2c81db0c66"},
-    {file = "cffi-1.15.0-cp37-cp37m-win_amd64.whl", hash = "sha256:3415c89f9204ee60cd09b235810be700e993e343a408693e80ce7f6a40108029"},
-    {file = "cffi-1.15.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4238e6dab5d6a8ba812de994bbb0a79bddbdf80994e4ce802b6f6f3142fcc880"},
-    {file = "cffi-1.15.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0808014eb713677ec1292301ea4c81ad277b6cdf2fdd90fd540af98c0b101d20"},
-    {file = "cffi-1.15.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:57e9ac9ccc3101fac9d6014fba037473e4358ef4e89f8e181f8951a2c0162024"},
-    {file = "cffi-1.15.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b6c2ea03845c9f501ed1313e78de148cd3f6cad741a75d43a29b43da27f2e1e"},
-    {file = "cffi-1.15.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:10dffb601ccfb65262a27233ac273d552ddc4d8ae1bf93b21c94b8511bffe728"},
-    {file = "cffi-1.15.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:786902fb9ba7433aae840e0ed609f45c7bcd4e225ebb9c753aa39725bb3e6ad6"},
-    {file = "cffi-1.15.0-cp38-cp38-win32.whl", hash = "sha256:da5db4e883f1ce37f55c667e5c0de439df76ac4cb55964655906306918e7363c"},
-    {file = "cffi-1.15.0-cp38-cp38-win_amd64.whl", hash = "sha256:181dee03b1170ff1969489acf1c26533710231c58f95534e3edac87fff06c443"},
-    {file = "cffi-1.15.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:45e8636704eacc432a206ac7345a5d3d2c62d95a507ec70d62f23cd91770482a"},
-    {file = "cffi-1.15.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:31fb708d9d7c3f49a60f04cf5b119aeefe5644daba1cd2a0fe389b674fd1de37"},
-    {file = "cffi-1.15.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6dc2737a3674b3e344847c8686cf29e500584ccad76204efea14f451d4cc669a"},
-    {file = "cffi-1.15.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:74fdfdbfdc48d3f47148976f49fab3251e550a8720bebc99bf1483f5bfb5db3e"},
-    {file = "cffi-1.15.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffaa5c925128e29efbde7301d8ecaf35c8c60ffbcd6a1ffd3a552177c8e5e796"},
-    {file = "cffi-1.15.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f7d084648d77af029acb79a0ff49a0ad7e9d09057a9bf46596dac9514dc07df"},
-    {file = "cffi-1.15.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ef1f279350da2c586a69d32fc8733092fd32cc8ac95139a00377841f59a3f8d8"},
-    {file = "cffi-1.15.0-cp39-cp39-win32.whl", hash = "sha256:2a23af14f408d53d5e6cd4e3d9a24ff9e05906ad574822a10563efcef137979a"},
-    {file = "cffi-1.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:3773c4d81e6e818df2efbc7dd77325ca0dcb688116050fb2b3011218eda36139"},
-    {file = "cffi-1.15.0.tar.gz", hash = "sha256:920f0d66a896c2d99f0adbb391f990a84091179542c205fa53ce5787aff87954"},
-]
-cfgv = [
-    {file = "cfgv-3.3.1-py2.py3-none-any.whl", hash = "sha256:c6a0883f3917a037485059700b9e75da2464e6c27051014ad85ba6aaa5884426"},
-    {file = "cfgv-3.3.1.tar.gz", hash = "sha256:f5a830efb9ce7a445376bb66ec94c638a9787422f96264c98edc6bdeed8ab736"},
-]
-chardet = [
-    {file = "chardet-4.0.0-py2.py3-none-any.whl", hash = "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5"},
-    {file = "chardet-4.0.0.tar.gz", hash = "sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa"},
-]
-colorama = [
-    {file = "colorama-0.4.4-py2.py3-none-any.whl", hash = "sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2"},
-    {file = "colorama-0.4.4.tar.gz", hash = "sha256:5941b2b48a20143d2267e95b1c2a7603ce057ee39fd88e7329b0c292aa16869b"},
-]
-coloredlogs = [
-    {file = "coloredlogs-15.0.1-py2.py3-none-any.whl", hash = "sha256:612ee75c546f53e92e70049c9dbfcc18c935a2b9a53b66085ce9ef6a6e5c0934"},
-    {file = "coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0"},
-]
-deprecated = [
-    {file = "Deprecated-1.2.13-py2.py3-none-any.whl", hash = "sha256:64756e3e14c8c5eea9795d93c524551432a0be75629f8f29e67ab8caf076c76d"},
-    {file = "Deprecated-1.2.13.tar.gz", hash = "sha256:43ac5335da90c31c24ba028af536a91d41d53f9e6901ddb021bcc572ce44e38d"},
-]
+aiodns = []
+aiohttp = []
+aioredis = []
+arrow = []
+async-rediscache = []
+async-timeout = []
+attrs = []
+beautifulsoup4 = []
+certifi = []
+cffi = []
+cfgv = []
+chardet = []
+colorama = []
+coloredlogs = []
+deprecated = []
 "discord.py" = []
-distlib = [
-    {file = "distlib-0.3.4-py2.py3-none-any.whl", hash = "sha256:6564fe0a8f51e734df6333d08b8b94d4ea8ee6b99b5ed50613f731fd4089f34b"},
-    {file = "distlib-0.3.4.zip", hash = "sha256:e4b58818180336dc9c529bfb9a0b58728ffc09ad92027a3f30b7cd91e3458579"},
-]
-emojis = [
-    {file = "emojis-0.6.0-py3-none-any.whl", hash = "sha256:7da34c8a78ae262fd68cef9e2c78a3c1feb59784489eeea0f54ba1d4b7111c7c"},
-    {file = "emojis-0.6.0.tar.gz", hash = "sha256:bf605d1f1a27a81cd37fe82eb65781c904467f569295a541c33710b97e4225ec"},
-]
-fakeredis = [
-    {file = "fakeredis-1.7.0-py3-none-any.whl", hash = "sha256:6f1e04f64557ad3b6835bdc6e5a8d022cbace4bdc24a47ad58f6a72e0fbff760"},
-    {file = "fakeredis-1.7.0.tar.gz", hash = "sha256:c9bd12e430336cbd3e189fae0e91eb99997b93e76dbfdd6ed67fa352dc684c71"},
-]
-filelock = [
-    {file = "filelock-3.4.2-py3-none-any.whl", hash = "sha256:cf0fc6a2f8d26bd900f19bf33915ca70ba4dd8c56903eeb14e1e7a2fd7590146"},
-    {file = "filelock-3.4.2.tar.gz", hash = "sha256:38b4f4c989f9d06d44524df1b24bd19e167d851f19b50bf3e3559952dddc5b80"},
-]
-flake8 = [
-    {file = "flake8-3.9.2-py2.py3-none-any.whl", hash = "sha256:bf8fd333346d844f616e8d47905ef3a3384edae6b4e9beb0c5101e25e3110907"},
-    {file = "flake8-3.9.2.tar.gz", hash = "sha256:07528381786f2a6237b061f6e96610a4167b226cb926e2aa2b6b1d78057c576b"},
-]
-flake8-annotations = [
-    {file = "flake8-annotations-2.7.0.tar.gz", hash = "sha256:52e53c05b0c06cac1c2dec192ea2c36e85081238add3bd99421d56f574b9479b"},
-    {file = "flake8_annotations-2.7.0-py3-none-any.whl", hash = "sha256:3edfbbfb58e404868834fe6ec3eaf49c139f64f0701259f707d043185545151e"},
-]
-flake8-bugbear = [
-    {file = "flake8-bugbear-20.11.1.tar.gz", hash = "sha256:528020129fea2dea33a466b9d64ab650aa3e5f9ffc788b70ea4bc6cf18283538"},
-    {file = "flake8_bugbear-20.11.1-py36.py37.py38-none-any.whl", hash = "sha256:f35b8135ece7a014bc0aee5b5d485334ac30a6da48494998cc1fabf7ec70d703"},
-]
-flake8-docstrings = [
-    {file = "flake8-docstrings-1.6.0.tar.gz", hash = "sha256:9fe7c6a306064af8e62a055c2f61e9eb1da55f84bb39caef2b84ce53708ac34b"},
-    {file = "flake8_docstrings-1.6.0-py2.py3-none-any.whl", hash = "sha256:99cac583d6c7e32dd28bbfbef120a7c0d1b6dde4adb5a9fd441c4227a6534bde"},
-]
-flake8-isort = [
-    {file = "flake8-isort-4.1.1.tar.gz", hash = "sha256:d814304ab70e6e58859bc5c3e221e2e6e71c958e7005239202fee19c24f82717"},
-    {file = "flake8_isort-4.1.1-py3-none-any.whl", hash = "sha256:c4e8b6dcb7be9b71a02e6e5d4196cefcef0f3447be51e82730fb336fff164949"},
-]
-flake8-polyfill = [
-    {file = "flake8-polyfill-1.0.2.tar.gz", hash = "sha256:e44b087597f6da52ec6393a709e7108b2905317d0c0b744cdca6208e670d8eda"},
-    {file = "flake8_polyfill-1.0.2-py2.py3-none-any.whl", hash = "sha256:12be6a34ee3ab795b19ca73505e7b55826d5f6ad7230d31b18e106400169b9e9"},
-]
-flake8-string-format = [
-    {file = "flake8-string-format-0.3.0.tar.gz", hash = "sha256:65f3da786a1461ef77fca3780b314edb2853c377f2e35069723348c8917deaa2"},
-    {file = "flake8_string_format-0.3.0-py2.py3-none-any.whl", hash = "sha256:812ff431f10576a74c89be4e85b8e075a705be39bc40c4b4278b5b13e2afa9af"},
-]
-flake8-tidy-imports = [
-    {file = "flake8-tidy-imports-4.5.0.tar.gz", hash = "sha256:ac637961d0f319012d099e49619f8c928e3221f74e00fe6eb89513bc64c40adb"},
-    {file = "flake8_tidy_imports-4.5.0-py3-none-any.whl", hash = "sha256:87eed94ae6a2fda6a5918d109746feadf1311e0eb8274ab7a7920f6db00a41c9"},
-]
-flake8-todo = [
-    {file = "flake8-todo-0.7.tar.gz", hash = "sha256:6e4c5491ff838c06fe5a771b0e95ee15fc005ca57196011011280fc834a85915"},
-]
-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"},
-    {file = "hiredis-2.0.0-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:3d55e36715ff06cdc0ab62f9591607c4324297b6b6ce5b58cb9928b3defe30ea"},
-    {file = "hiredis-2.0.0-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:5d2a48c80cf5a338d58aae3c16872f4d452345e18350143b3bf7216d33ba7b99"},
-    {file = "hiredis-2.0.0-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:240ce6dc19835971f38caf94b5738092cb1e641f8150a9ef9251b7825506cb05"},
-    {file = "hiredis-2.0.0-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:5dc7a94bb11096bc4bffd41a3c4f2b958257085c01522aa81140c68b8bf1630a"},
-    {file = "hiredis-2.0.0-cp36-cp36m-win32.whl", hash = "sha256:139705ce59d94eef2ceae9fd2ad58710b02aee91e7fa0ccb485665ca0ecbec63"},
-    {file = "hiredis-2.0.0-cp36-cp36m-win_amd64.whl", hash = "sha256:c39c46d9e44447181cd502a35aad2bb178dbf1b1f86cf4db639d7b9614f837c6"},
-    {file = "hiredis-2.0.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:adf4dd19d8875ac147bf926c727215a0faf21490b22c053db464e0bf0deb0485"},
-    {file = "hiredis-2.0.0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:0f41827028901814c709e744060843c77e78a3aca1e0d6875d2562372fcb405a"},
-    {file = "hiredis-2.0.0-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:508999bec4422e646b05c95c598b64bdbef1edf0d2b715450a078ba21b385bcc"},
-    {file = "hiredis-2.0.0-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:0d5109337e1db373a892fdcf78eb145ffb6bbd66bb51989ec36117b9f7f9b579"},
-    {file = "hiredis-2.0.0-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:04026461eae67fdefa1949b7332e488224eac9e8f2b5c58c98b54d29af22093e"},
-    {file = "hiredis-2.0.0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:a00514362df15af041cc06e97aebabf2895e0a7c42c83c21894be12b84402d79"},
-    {file = "hiredis-2.0.0-cp37-cp37m-win32.whl", hash = "sha256:09004096e953d7ebd508cded79f6b21e05dff5d7361771f59269425108e703bc"},
-    {file = "hiredis-2.0.0-cp37-cp37m-win_amd64.whl", hash = "sha256:f8196f739092a78e4f6b1b2172679ed3343c39c61a3e9d722ce6fcf1dac2824a"},
-    {file = "hiredis-2.0.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:294a6697dfa41a8cba4c365dd3715abc54d29a86a40ec6405d677ca853307cfb"},
-    {file = "hiredis-2.0.0-cp38-cp38-manylinux1_i686.whl", hash = "sha256:3dddf681284fe16d047d3ad37415b2e9ccdc6c8986c8062dbe51ab9a358b50a5"},
-    {file = "hiredis-2.0.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:dcef843f8de4e2ff5e35e96ec2a4abbdf403bd0f732ead127bd27e51f38ac298"},
-    {file = "hiredis-2.0.0-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:87c7c10d186f1743a8fd6a971ab6525d60abd5d5d200f31e073cd5e94d7e7a9d"},
-    {file = "hiredis-2.0.0-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:7f0055f1809b911ab347a25d786deff5e10e9cf083c3c3fd2dd04e8612e8d9db"},
-    {file = "hiredis-2.0.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:11d119507bb54e81f375e638225a2c057dda748f2b1deef05c2b1a5d42686048"},
-    {file = "hiredis-2.0.0-cp38-cp38-win32.whl", hash = "sha256:7492af15f71f75ee93d2a618ca53fea8be85e7b625e323315169977fae752426"},
-    {file = "hiredis-2.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:65d653df249a2f95673976e4e9dd7ce10de61cfc6e64fa7eeaa6891a9559c581"},
-    {file = "hiredis-2.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ae8427a5e9062ba66fc2c62fb19a72276cf12c780e8db2b0956ea909c48acff5"},
-    {file = "hiredis-2.0.0-cp39-cp39-manylinux1_i686.whl", hash = "sha256:3f5f7e3a4ab824e3de1e1700f05ad76ee465f5f11f5db61c4b297ec29e692b2e"},
-    {file = "hiredis-2.0.0-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:e3447d9e074abf0e3cd85aef8131e01ab93f9f0e86654db7ac8a3f73c63706ce"},
-    {file = "hiredis-2.0.0-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:8b42c0dc927b8d7c0eb59f97e6e34408e53bc489f9f90e66e568f329bff3e443"},
-    {file = "hiredis-2.0.0-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:b84f29971f0ad4adaee391c6364e6f780d5aae7e9226d41964b26b49376071d0"},
-    {file = "hiredis-2.0.0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:0b39ec237459922c6544d071cdcf92cbb5bc6685a30e7c6d985d8a3e3a75326e"},
-    {file = "hiredis-2.0.0-cp39-cp39-win32.whl", hash = "sha256:a7928283143a401e72a4fad43ecc85b35c27ae699cf5d54d39e1e72d97460e1d"},
-    {file = "hiredis-2.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:a4ee8000454ad4486fb9f28b0cab7fa1cd796fc36d639882d0b34109b5b3aec9"},
-    {file = "hiredis-2.0.0-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:1f03d4dadd595f7a69a75709bc81902673fa31964c75f93af74feac2f134cc54"},
-    {file = "hiredis-2.0.0-pp36-pypy36_pp73-manylinux1_x86_64.whl", hash = "sha256:04927a4c651a0e9ec11c68e4427d917e44ff101f761cd3b5bc76f86aaa431d27"},
-    {file = "hiredis-2.0.0-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:a39efc3ade8c1fb27c097fd112baf09d7fd70b8cb10ef1de4da6efbe066d381d"},
-    {file = "hiredis-2.0.0-pp36-pypy36_pp73-win32.whl", hash = "sha256:07bbf9bdcb82239f319b1f09e8ef4bdfaec50ed7d7ea51a56438f39193271163"},
-    {file = "hiredis-2.0.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:807b3096205c7cec861c8803a6738e33ed86c9aae76cac0e19454245a6bbbc0a"},
-    {file = "hiredis-2.0.0-pp37-pypy37_pp73-manylinux1_x86_64.whl", hash = "sha256:1233e303645f468e399ec906b6b48ab7cd8391aae2d08daadbb5cad6ace4bd87"},
-    {file = "hiredis-2.0.0-pp37-pypy37_pp73-manylinux2010_x86_64.whl", hash = "sha256:cb2126603091902767d96bcb74093bd8b14982f41809f85c9b96e519c7e1dc41"},
-    {file = "hiredis-2.0.0-pp37-pypy37_pp73-win32.whl", hash = "sha256:f52010e0a44e3d8530437e7da38d11fb822acfb0d5b12e9cd5ba655509937ca0"},
-    {file = "hiredis-2.0.0.tar.gz", hash = "sha256:81d6d8e39695f2c37954d1011c0480ef7cf444d4e3ae24bc5e89ee5de360139a"},
-]
-humanfriendly = [
-    {file = "humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477"},
-    {file = "humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc"},
-]
-identify = [
-    {file = "identify-2.4.1-py2.py3-none-any.whl", hash = "sha256:0192893ff68b03d37fed553e261d4a22f94ea974093aefb33b29df2ff35fed3c"},
-    {file = "identify-2.4.1.tar.gz", hash = "sha256:64d4885e539f505dd8ffb5e93c142a1db45480452b1594cacd3e91dca9a984e9"},
-]
-idna = [
-    {file = "idna-3.3-py3-none-any.whl", hash = "sha256:84d9dd047ffa80596e0f246e2eab0b391788b0503584e8945f2368256d2735ff"},
-    {file = "idna-3.3.tar.gz", hash = "sha256:9d643ff0a55b762d5cdb124b8eaa99c66322e2157b69160bc32796e824360e6d"},
-]
-isort = [
-    {file = "isort-5.10.1-py3-none-any.whl", hash = "sha256:6f62d78e2f89b4500b080fe3a81690850cd254227f27f75c3a0c491a1f351ba7"},
-    {file = "isort-5.10.1.tar.gz", hash = "sha256:e8443a5e7a020e9d7f97f1d7d9cd17c88bcb3bc7e218bf9cf5095fe550be2951"},
-]
-lxml = [
-    {file = "lxml-4.7.1-cp27-cp27m-macosx_10_14_x86_64.whl", hash = "sha256:d546431636edb1d6a608b348dd58cc9841b81f4116745857b6cb9f8dadb2725f"},
-    {file = "lxml-4.7.1-cp27-cp27m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6308062534323f0d3edb4e702a0e26a76ca9e0e23ff99be5d82750772df32a9e"},
-    {file = "lxml-4.7.1-cp27-cp27m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:f76dbe44e31abf516114f6347a46fa4e7c2e8bceaa4b6f7ee3a0a03c8eba3c17"},
-    {file = "lxml-4.7.1-cp27-cp27m-win32.whl", hash = "sha256:d5618d49de6ba63fe4510bdada62d06a8acfca0b4b5c904956c777d28382b419"},
-    {file = "lxml-4.7.1-cp27-cp27m-win_amd64.whl", hash = "sha256:9393a05b126a7e187f3e38758255e0edf948a65b22c377414002d488221fdaa2"},
-    {file = "lxml-4.7.1-cp27-cp27mu-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:50d3dba341f1e583265c1a808e897b4159208d814ab07530202b6036a4d86da5"},
-    {file = "lxml-4.7.1-cp27-cp27mu-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:44f552e0da3c8ee3c28e2eb82b0b784200631687fc6a71277ea8ab0828780e7d"},
-    {file = "lxml-4.7.1-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:e662c6266e3a275bdcb6bb049edc7cd77d0b0f7e119a53101d367c841afc66dc"},
-    {file = "lxml-4.7.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:4c093c571bc3da9ebcd484e001ba18b8452903cd428c0bc926d9b0141bcb710e"},
-    {file = "lxml-4.7.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:3e26ad9bc48d610bf6cc76c506b9e5ad9360ed7a945d9be3b5b2c8535a0145e3"},
-    {file = "lxml-4.7.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:a5f623aeaa24f71fce3177d7fee875371345eb9102b355b882243e33e04b7175"},
-    {file = "lxml-4.7.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7b5e2acefd33c259c4a2e157119c4373c8773cf6793e225006a1649672ab47a6"},
-    {file = "lxml-4.7.1-cp310-cp310-win32.whl", hash = "sha256:67fa5f028e8a01e1d7944a9fb616d1d0510d5d38b0c41708310bd1bc45ae89f6"},
-    {file = "lxml-4.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:b1d381f58fcc3e63fcc0ea4f0a38335163883267f77e4c6e22d7a30877218a0e"},
-    {file = "lxml-4.7.1-cp35-cp35m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:38d9759733aa04fb1697d717bfabbedb21398046bd07734be7cccc3d19ea8675"},
-    {file = "lxml-4.7.1-cp35-cp35m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:dfd0d464f3d86a1460683cd742306d1138b4e99b79094f4e07e1ca85ee267fe7"},
-    {file = "lxml-4.7.1-cp35-cp35m-win32.whl", hash = "sha256:534e946bce61fd162af02bad7bfd2daec1521b71d27238869c23a672146c34a5"},
-    {file = "lxml-4.7.1-cp35-cp35m-win_amd64.whl", hash = "sha256:6ec829058785d028f467be70cd195cd0aaf1a763e4d09822584ede8c9eaa4b03"},
-    {file = "lxml-4.7.1-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:ade74f5e3a0fd17df5782896ddca7ddb998845a5f7cd4b0be771e1ffc3b9aa5b"},
-    {file = "lxml-4.7.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:41358bfd24425c1673f184d7c26c6ae91943fe51dfecc3603b5e08187b4bcc55"},
-    {file = "lxml-4.7.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:6e56521538f19c4a6690f439fefed551f0b296bd785adc67c1777c348beb943d"},
-    {file = "lxml-4.7.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5b0f782f0e03555c55e37d93d7a57454efe7495dab33ba0ccd2dbe25fc50f05d"},
-    {file = "lxml-4.7.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:490712b91c65988012e866c411a40cc65b595929ececf75eeb4c79fcc3bc80a6"},
-    {file = "lxml-4.7.1-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:34c22eb8c819d59cec4444d9eebe2e38b95d3dcdafe08965853f8799fd71161d"},
-    {file = "lxml-4.7.1-cp36-cp36m-win32.whl", hash = "sha256:2a906c3890da6a63224d551c2967413b8790a6357a80bf6b257c9a7978c2c42d"},
-    {file = "lxml-4.7.1-cp36-cp36m-win_amd64.whl", hash = "sha256:36b16fecb10246e599f178dd74f313cbdc9f41c56e77d52100d1361eed24f51a"},
-    {file = "lxml-4.7.1-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:a5edc58d631170de90e50adc2cc0248083541affef82f8cd93bea458e4d96db8"},
-    {file = "lxml-4.7.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:87c1b0496e8c87ec9db5383e30042357b4839b46c2d556abd49ec770ce2ad868"},
-    {file = "lxml-4.7.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:0a5f0e4747f31cff87d1eb32a6000bde1e603107f632ef4666be0dc065889c7a"},
-    {file = "lxml-4.7.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:bf6005708fc2e2c89a083f258b97709559a95f9a7a03e59f805dd23c93bc3986"},
-    {file = "lxml-4.7.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc15874816b9320581133ddc2096b644582ab870cf6a6ed63684433e7af4b0d3"},
-    {file = "lxml-4.7.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0b5e96e25e70917b28a5391c2ed3ffc6156513d3db0e1476c5253fcd50f7a944"},
-    {file = "lxml-4.7.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ec9027d0beb785a35aa9951d14e06d48cfbf876d8ff67519403a2522b181943b"},
-    {file = "lxml-4.7.1-cp37-cp37m-win32.whl", hash = "sha256:9fbc0dee7ff5f15c4428775e6fa3ed20003140560ffa22b88326669d53b3c0f4"},
-    {file = "lxml-4.7.1-cp37-cp37m-win_amd64.whl", hash = "sha256:1104a8d47967a414a436007c52f533e933e5d52574cab407b1e49a4e9b5ddbd1"},
-    {file = "lxml-4.7.1-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:fc9fb11b65e7bc49f7f75aaba1b700f7181d95d4e151cf2f24d51bfd14410b77"},
-    {file = "lxml-4.7.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:317bd63870b4d875af3c1be1b19202de34c32623609ec803b81c99193a788c1e"},
-    {file = "lxml-4.7.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:610807cea990fd545b1559466971649e69302c8a9472cefe1d6d48a1dee97440"},
-    {file = "lxml-4.7.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:09b738360af8cb2da275998a8bf79517a71225b0de41ab47339c2beebfff025f"},
-    {file = "lxml-4.7.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6a2ab9d089324d77bb81745b01f4aeffe4094306d939e92ba5e71e9a6b99b71e"},
-    {file = "lxml-4.7.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:eed394099a7792834f0cb4a8f615319152b9d801444c1c9e1b1a2c36d2239f9e"},
-    {file = "lxml-4.7.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:735e3b4ce9c0616e85f302f109bdc6e425ba1670a73f962c9f6b98a6d51b77c9"},
-    {file = "lxml-4.7.1-cp38-cp38-win32.whl", hash = "sha256:772057fba283c095db8c8ecde4634717a35c47061d24f889468dc67190327bcd"},
-    {file = "lxml-4.7.1-cp38-cp38-win_amd64.whl", hash = "sha256:13dbb5c7e8f3b6a2cf6e10b0948cacb2f4c9eb05029fe31c60592d08ac63180d"},
-    {file = "lxml-4.7.1-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:718d7208b9c2d86aaf0294d9381a6acb0158b5ff0f3515902751404e318e02c9"},
-    {file = "lxml-4.7.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:5bee1b0cbfdb87686a7fb0e46f1d8bd34d52d6932c0723a86de1cc532b1aa489"},
-    {file = "lxml-4.7.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:e410cf3a2272d0a85526d700782a2fa92c1e304fdcc519ba74ac80b8297adf36"},
-    {file = "lxml-4.7.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:585ea241ee4961dc18a95e2f5581dbc26285fcf330e007459688096f76be8c42"},
-    {file = "lxml-4.7.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a555e06566c6dc167fbcd0ad507ff05fd9328502aefc963cb0a0547cfe7f00db"},
-    {file = "lxml-4.7.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:adaab25be351fff0d8a691c4f09153647804d09a87a4e4ea2c3f9fe9e8651851"},
-    {file = "lxml-4.7.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:82d16a64236970cb93c8d63ad18c5b9f138a704331e4b916b2737ddfad14e0c4"},
-    {file = "lxml-4.7.1-cp39-cp39-win32.whl", hash = "sha256:59e7da839a1238807226f7143c68a479dee09244d1b3cf8c134f2fce777d12d0"},
-    {file = "lxml-4.7.1-cp39-cp39-win_amd64.whl", hash = "sha256:a1bbc4efa99ed1310b5009ce7f3a1784698082ed2c1ef3895332f5df9b3b92c2"},
-    {file = "lxml-4.7.1-pp37-pypy37_pp73-macosx_10_14_x86_64.whl", hash = "sha256:0607ff0988ad7e173e5ddf7bf55ee65534bd18a5461183c33e8e41a59e89edf4"},
-    {file = "lxml-4.7.1-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:6c198bfc169419c09b85ab10cb0f572744e686f40d1e7f4ed09061284fc1303f"},
-    {file = "lxml-4.7.1-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:a58d78653ae422df6837dd4ca0036610b8cb4962b5cfdbd337b7b24de9e5f98a"},
-    {file = "lxml-4.7.1-pp38-pypy38_pp73-macosx_10_14_x86_64.whl", hash = "sha256:e18281a7d80d76b66a9f9e68a98cf7e1d153182772400d9a9ce855264d7d0ce7"},
-    {file = "lxml-4.7.1-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:8e54945dd2eeb50925500957c7c579df3cd07c29db7810b83cf30495d79af267"},
-    {file = "lxml-4.7.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:447d5009d6b5447b2f237395d0018901dcc673f7d9f82ba26c1b9f9c3b444b60"},
-    {file = "lxml-4.7.1.tar.gz", hash = "sha256:a1613838aa6b89af4ba10a0f3a972836128801ed008078f8c1244e65958f1b24"},
-]
-mccabe = [
-    {file = "mccabe-0.6.1-py2.py3-none-any.whl", hash = "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42"},
-    {file = "mccabe-0.6.1.tar.gz", hash = "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"},
-]
-mslex = [
-    {file = "mslex-0.3.0-py2.py3-none-any.whl", hash = "sha256:380cb14abf8fabf40e56df5c8b21a6d533dc5cbdcfe42406bbf08dda8f42e42a"},
-    {file = "mslex-0.3.0.tar.gz", hash = "sha256:4a1ac3f25025cad78ad2fe499dd16d42759f7a3801645399cce5c404415daa97"},
-]
-multidict = [
-    {file = "multidict-5.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3822c5894c72e3b35aae9909bef66ec83e44522faf767c0ad39e0e2de11d3b55"},
-    {file = "multidict-5.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:28e6d883acd8674887d7edc896b91751dc2d8e87fbdca8359591a13872799e4e"},
-    {file = "multidict-5.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b61f85101ef08cbbc37846ac0e43f027f7844f3fade9b7f6dd087178caedeee7"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9b668c065968c5979fe6b6fa6760bb6ab9aeb94b75b73c0a9c1acf6393ac3bf"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:517d75522b7b18a3385726b54a081afd425d4f41144a5399e5abd97ccafdf36b"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1b4ac3ba7a97b35a5ccf34f41b5a8642a01d1e55454b699e5e8e7a99b5a3acf5"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:df23c83398715b26ab09574217ca21e14694917a0c857e356fd39e1c64f8283f"},
-    {file = "multidict-5.2.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e58a9b5cc96e014ddf93c2227cbdeca94b56a7eb77300205d6e4001805391747"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f76440e480c3b2ca7f843ff8a48dc82446b86ed4930552d736c0bac507498a52"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cfde464ca4af42a629648c0b0d79b8f295cf5b695412451716531d6916461628"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:0fed465af2e0eb6357ba95795d003ac0bdb546305cc2366b1fc8f0ad67cc3fda"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:b70913cbf2e14275013be98a06ef4b412329fe7b4f83d64eb70dce8269ed1e1a"},
-    {file = "multidict-5.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a5635bcf1b75f0f6ef3c8a1ad07b500104a971e38d3683167b9454cb6465ac86"},
-    {file = "multidict-5.2.0-cp310-cp310-win32.whl", hash = "sha256:77f0fb7200cc7dedda7a60912f2059086e29ff67cefbc58d2506638c1a9132d7"},
-    {file = "multidict-5.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:9416cf11bcd73c861267e88aea71e9fcc35302b3943e45e1dbb4317f91a4b34f"},
-    {file = "multidict-5.2.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:fd77c8f3cba815aa69cb97ee2b2ef385c7c12ada9c734b0f3b32e26bb88bbf1d"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98ec9aea6223adf46999f22e2c0ab6cf33f5914be604a404f658386a8f1fba37"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e5283c0a00f48e8cafcecadebfa0ed1dac8b39e295c7248c44c665c16dc1138b"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5f79c19c6420962eb17c7e48878a03053b7ccd7b69f389d5831c0a4a7f1ac0a1"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e4a67f1080123de76e4e97a18d10350df6a7182e243312426d508712e99988d4"},
-    {file = "multidict-5.2.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:94b117e27efd8e08b4046c57461d5a114d26b40824995a2eb58372b94f9fca02"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:2e77282fd1d677c313ffcaddfec236bf23f273c4fba7cdf198108f5940ae10f5"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:116347c63ba049c1ea56e157fa8aa6edaf5e92925c9b64f3da7769bdfa012858"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:dc3a866cf6c13d59a01878cd806f219340f3e82eed514485e094321f24900677"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:ac42181292099d91217a82e3fa3ce0e0ddf3a74fd891b7c2b347a7f5aa0edded"},
-    {file = "multidict-5.2.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:f0bb0973f42ffcb5e3537548e0767079420aefd94ba990b61cf7bb8d47f4916d"},
-    {file = "multidict-5.2.0-cp36-cp36m-win32.whl", hash = "sha256:ea21d4d5104b4f840b91d9dc8cbc832aba9612121eaba503e54eaab1ad140eb9"},
-    {file = "multidict-5.2.0-cp36-cp36m-win_amd64.whl", hash = "sha256:e6453f3cbeb78440747096f239d282cc57a2997a16b5197c9bc839099e1633d0"},
-    {file = "multidict-5.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:d3def943bfd5f1c47d51fd324df1e806d8da1f8e105cc7f1c76a1daf0f7e17b0"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35591729668a303a02b06e8dba0eb8140c4a1bfd4c4b3209a436a02a5ac1de11"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce8cacda0b679ebc25624d5de66c705bc53dcc7c6f02a7fb0f3ca5e227d80422"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:baf1856fab8212bf35230c019cde7c641887e3fc08cadd39d32a421a30151ea3"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:a43616aec0f0d53c411582c451f5d3e1123a68cc7b3475d6f7d97a626f8ff90d"},
-    {file = "multidict-5.2.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:25cbd39a9029b409167aa0a20d8a17f502d43f2efebfe9e3ac019fe6796c59ac"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:0a2cbcfbea6dc776782a444db819c8b78afe4db597211298dd8b2222f73e9cd0"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:3d2d7d1fff8e09d99354c04c3fd5b560fb04639fd45926b34e27cfdec678a704"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:a37e9a68349f6abe24130846e2f1d2e38f7ddab30b81b754e5a1fde32f782b23"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:637c1896497ff19e1ee27c1c2c2ddaa9f2d134bbb5e0c52254361ea20486418d"},
-    {file = "multidict-5.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:9815765f9dcda04921ba467957be543423e5ec6a1136135d84f2ae092c50d87b"},
-    {file = "multidict-5.2.0-cp37-cp37m-win32.whl", hash = "sha256:8b911d74acdc1fe2941e59b4f1a278a330e9c34c6c8ca1ee21264c51ec9b67ef"},
-    {file = "multidict-5.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:380b868f55f63d048a25931a1632818f90e4be71d2081c2338fcf656d299949a"},
-    {file = "multidict-5.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e7d81ce5744757d2f05fc41896e3b2ae0458464b14b5a2c1e87a6a9d69aefaa8"},
-    {file = "multidict-5.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2d1d55cdf706ddc62822d394d1df53573d32a7a07d4f099470d3cb9323b721b6"},
-    {file = "multidict-5.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a4771d0d0ac9d9fe9e24e33bed482a13dfc1256d008d101485fe460359476065"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da7d57ea65744d249427793c042094c4016789eb2562576fb831870f9c878d9e"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cdd68778f96216596218b4e8882944d24a634d984ee1a5a049b300377878fa7c"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ecc99bce8ee42dcad15848c7885197d26841cb24fa2ee6e89d23b8993c871c64"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:067150fad08e6f2dd91a650c7a49ba65085303fcc3decbd64a57dc13a2733031"},
-    {file = "multidict-5.2.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:78c106b2b506b4d895ddc801ff509f941119394b89c9115580014127414e6c2d"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e6c4fa1ec16e01e292315ba76eb1d012c025b99d22896bd14a66628b245e3e01"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:b227345e4186809d31f22087d0265655114af7cda442ecaf72246275865bebe4"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:06560fbdcf22c9387100979e65b26fba0816c162b888cb65b845d3def7a54c9b"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:7878b61c867fb2df7a95e44b316f88d5a3742390c99dfba6c557a21b30180cac"},
-    {file = "multidict-5.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:246145bff76cc4b19310f0ad28bd0769b940c2a49fc601b86bfd150cbd72bb22"},
-    {file = "multidict-5.2.0-cp38-cp38-win32.whl", hash = "sha256:c30ac9f562106cd9e8071c23949a067b10211917fdcb75b4718cf5775356a940"},
-    {file = "multidict-5.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:f19001e790013ed580abfde2a4465388950728861b52f0da73e8e8a9418533c0"},
-    {file = "multidict-5.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c1ff762e2ee126e6f1258650ac641e2b8e1f3d927a925aafcfde943b77a36d24"},
-    {file = "multidict-5.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bd6c9c50bf2ad3f0448edaa1a3b55b2e6866ef8feca5d8dbec10ec7c94371d21"},
-    {file = "multidict-5.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fc66d4016f6e50ed36fb39cd287a3878ffcebfa90008535c62e0e90a7ab713ae"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9acb76d5f3dd9421874923da2ed1e76041cb51b9337fd7f507edde1d86535d6"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dfc924a7e946dd3c6360e50e8f750d51e3ef5395c95dc054bc9eab0f70df4f9c"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32fdba7333eb2351fee2596b756d730d62b5827d5e1ab2f84e6cbb287cc67fe0"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b9aad49466b8d828b96b9e3630006234879c8d3e2b0a9d99219b3121bc5cdb17"},
-    {file = "multidict-5.2.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:93de39267c4c676c9ebb2057e98a8138bade0d806aad4d864322eee0803140a0"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f9bef5cff994ca3026fcc90680e326d1a19df9841c5e3d224076407cc21471a1"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:5f841c4f14331fd1e36cbf3336ed7be2cb2a8f110ce40ea253e5573387db7621"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:38ba256ee9b310da6a1a0f013ef4e422fca30a685bcbec86a969bd520504e341"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:3bc3b1621b979621cee9f7b09f024ec76ec03cc365e638126a056317470bde1b"},
-    {file = "multidict-5.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6ee908c070020d682e9b42c8f621e8bb10c767d04416e2ebe44e37d0f44d9ad5"},
-    {file = "multidict-5.2.0-cp39-cp39-win32.whl", hash = "sha256:1c7976cd1c157fa7ba5456ae5d31ccdf1479680dc9b8d8aa28afabc370df42b8"},
-    {file = "multidict-5.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:c9631c642e08b9fff1c6255487e62971d8b8e821808ddd013d8ac058087591ac"},
-    {file = "multidict-5.2.0.tar.gz", hash = "sha256:0dd1c93edb444b33ba2274b66f63def8a327d607c6c790772f448a53b6ea59ce"},
-]
-nodeenv = [
-    {file = "nodeenv-1.6.0-py2.py3-none-any.whl", hash = "sha256:621e6b7076565ddcacd2db0294c0381e01fd28945ab36bcf00f41c5daf63bef7"},
-    {file = "nodeenv-1.6.0.tar.gz", hash = "sha256:3ef13ff90291ba2a4a7a4ff9a979b63ffdd00a464dbe04acf0ea6471517a4c2b"},
-]
-packaging = [
-    {file = "packaging-21.3-py3-none-any.whl", hash = "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"},
-    {file = "packaging-21.3.tar.gz", hash = "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb"},
-]
-pep8-naming = [
-    {file = "pep8-naming-0.12.1.tar.gz", hash = "sha256:bb2455947757d162aa4cad55dba4ce029005cd1692f2899a21d51d8630ca7841"},
-    {file = "pep8_naming-0.12.1-py2.py3-none-any.whl", hash = "sha256:4a8daeaeb33cfcde779309fc0c9c0a68a3bbe2ad8a8308b763c5068f86eb9f37"},
-]
-pillow = [
-    {file = "Pillow-8.4.0-cp310-cp310-macosx_10_10_universal2.whl", hash = "sha256:81f8d5c81e483a9442d72d182e1fb6dcb9723f289a57e8030811bac9ea3fef8d"},
-    {file = "Pillow-8.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3f97cfb1e5a392d75dd8b9fd274d205404729923840ca94ca45a0af57e13dbe6"},
-    {file = "Pillow-8.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb9fc393f3c61f9054e1ed26e6fe912c7321af2f41ff49d3f83d05bacf22cc78"},
-    {file = "Pillow-8.4.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d82cdb63100ef5eedb8391732375e6d05993b765f72cb34311fab92103314649"},
-    {file = "Pillow-8.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:62cc1afda735a8d109007164714e73771b499768b9bb5afcbbee9d0ff374b43f"},
-    {file = "Pillow-8.4.0-cp310-cp310-win32.whl", hash = "sha256:e3dacecfbeec9a33e932f00c6cd7996e62f53ad46fbe677577394aaa90ee419a"},
-    {file = "Pillow-8.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:620582db2a85b2df5f8a82ddeb52116560d7e5e6b055095f04ad828d1b0baa39"},
-    {file = "Pillow-8.4.0-cp36-cp36m-macosx_10_10_x86_64.whl", hash = "sha256:1bc723b434fbc4ab50bb68e11e93ce5fb69866ad621e3c2c9bdb0cd70e345f55"},
-    {file = "Pillow-8.4.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:72cbcfd54df6caf85cc35264c77ede902452d6df41166010262374155947460c"},
-    {file = "Pillow-8.4.0-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70ad9e5c6cb9b8487280a02c0ad8a51581dcbbe8484ce058477692a27c151c0a"},
-    {file = "Pillow-8.4.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:25a49dc2e2f74e65efaa32b153527fc5ac98508d502fa46e74fa4fd678ed6645"},
-    {file = "Pillow-8.4.0-cp36-cp36m-win32.whl", hash = "sha256:93ce9e955cc95959df98505e4608ad98281fff037350d8c2671c9aa86bcf10a9"},
-    {file = "Pillow-8.4.0-cp36-cp36m-win_amd64.whl", hash = "sha256:2e4440b8f00f504ee4b53fe30f4e381aae30b0568193be305256b1462216feff"},
-    {file = "Pillow-8.4.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:8c803ac3c28bbc53763e6825746f05cc407b20e4a69d0122e526a582e3b5e153"},
-    {file = "Pillow-8.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8a17b5d948f4ceeceb66384727dde11b240736fddeda54ca740b9b8b1556b29"},
-    {file = "Pillow-8.4.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1394a6ad5abc838c5cd8a92c5a07535648cdf6d09e8e2d6df916dfa9ea86ead8"},
-    {file = "Pillow-8.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:792e5c12376594bfcb986ebf3855aa4b7c225754e9a9521298e460e92fb4a488"},
-    {file = "Pillow-8.4.0-cp37-cp37m-win32.whl", hash = "sha256:d99ec152570e4196772e7a8e4ba5320d2d27bf22fdf11743dd882936ed64305b"},
-    {file = "Pillow-8.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:7b7017b61bbcdd7f6363aeceb881e23c46583739cb69a3ab39cb384f6ec82e5b"},
-    {file = "Pillow-8.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:d89363f02658e253dbd171f7c3716a5d340a24ee82d38aab9183f7fdf0cdca49"},
-    {file = "Pillow-8.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:0a0956fdc5defc34462bb1c765ee88d933239f9a94bc37d132004775241a7585"},
-    {file = "Pillow-8.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b7bb9de00197fb4261825c15551adf7605cf14a80badf1761d61e59da347779"},
-    {file = "Pillow-8.4.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:72b9e656e340447f827885b8d7a15fc8c4e68d410dc2297ef6787eec0f0ea409"},
-    {file = "Pillow-8.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5a4532a12314149d8b4e4ad8ff09dde7427731fcfa5917ff16d0291f13609df"},
-    {file = "Pillow-8.4.0-cp38-cp38-win32.whl", hash = "sha256:82aafa8d5eb68c8463b6e9baeb4f19043bb31fefc03eb7b216b51e6a9981ae09"},
-    {file = "Pillow-8.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:066f3999cb3b070a95c3652712cffa1a748cd02d60ad7b4e485c3748a04d9d76"},
-    {file = "Pillow-8.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:5503c86916d27c2e101b7f71c2ae2cddba01a2cf55b8395b0255fd33fa4d1f1a"},
-    {file = "Pillow-8.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4acc0985ddf39d1bc969a9220b51d94ed51695d455c228d8ac29fcdb25810e6e"},
-    {file = "Pillow-8.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b052a619a8bfcf26bd8b3f48f45283f9e977890263e4571f2393ed8898d331b"},
-    {file = "Pillow-8.4.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:493cb4e415f44cd601fcec11c99836f707bb714ab03f5ed46ac25713baf0ff20"},
-    {file = "Pillow-8.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8831cb7332eda5dc89b21a7bce7ef6ad305548820595033a4b03cf3091235ed"},
-    {file = "Pillow-8.4.0-cp39-cp39-win32.whl", hash = "sha256:5e9ac5f66616b87d4da618a20ab0a38324dbe88d8a39b55be8964eb520021e02"},
-    {file = "Pillow-8.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:3eb1ce5f65908556c2d8685a8f0a6e989d887ec4057326f6c22b24e8a172c66b"},
-    {file = "Pillow-8.4.0-pp36-pypy36_pp73-macosx_10_10_x86_64.whl", hash = "sha256:ddc4d832a0f0b4c52fff973a0d44b6c99839a9d016fe4e6a1cb8f3eea96479c2"},
-    {file = "Pillow-8.4.0-pp36-pypy36_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9a3e5ddc44c14042f0844b8cf7d2cd455f6cc80fd7f5eefbe657292cf601d9ad"},
-    {file = "Pillow-8.4.0-pp36-pypy36_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c70e94281588ef053ae8998039610dbd71bc509e4acbc77ab59d7d2937b10698"},
-    {file = "Pillow-8.4.0-pp37-pypy37_pp73-macosx_10_10_x86_64.whl", hash = "sha256:3862b7256046fcd950618ed22d1d60b842e3a40a48236a5498746f21189afbbc"},
-    {file = "Pillow-8.4.0-pp37-pypy37_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a4901622493f88b1a29bd30ec1a2f683782e57c3c16a2dbc7f2595ba01f639df"},
-    {file = "Pillow-8.4.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84c471a734240653a0ec91dec0996696eea227eafe72a33bd06c92697728046b"},
-    {file = "Pillow-8.4.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:244cf3b97802c34c41905d22810846802a3329ddcb93ccc432870243211c79fc"},
-    {file = "Pillow-8.4.0.tar.gz", hash = "sha256:b8e2f83c56e141920c39464b852de3719dfbfb6e3c99a2d8da0edf4fb33176ed"},
-]
-pip-licenses = [
-    {file = "pip-licenses-3.5.3.tar.gz", hash = "sha256:f44860e00957b791c6c6005a3328f2d5eaeee96ddb8e7d87d4b0aa25b02252e4"},
-    {file = "pip_licenses-3.5.3-py3-none-any.whl", hash = "sha256:59c148d6a03784bf945d232c0dc0e9de4272a3675acaa0361ad7712398ca86ba"},
-]
-platformdirs = [
-    {file = "platformdirs-2.4.1-py3-none-any.whl", hash = "sha256:1d7385c7db91728b83efd0ca99a5afb296cab9d0ed8313a45ed8ba17967ecfca"},
-    {file = "platformdirs-2.4.1.tar.gz", hash = "sha256:440633ddfebcc36264232365d7840a970e75e1018d15b4327d11f91909045fda"},
-]
-pre-commit = [
-    {file = "pre_commit-2.16.0-py2.py3-none-any.whl", hash = "sha256:758d1dc9b62c2ed8881585c254976d66eae0889919ab9b859064fc2fe3c7743e"},
-    {file = "pre_commit-2.16.0.tar.gz", hash = "sha256:fe9897cac830aa7164dbd02a4e7b90cae49630451ce88464bca73db486ba9f65"},
-]
-psutil = [
-    {file = "psutil-5.8.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:0066a82f7b1b37d334e68697faba68e5ad5e858279fd6351c8ca6024e8d6ba64"},
-    {file = "psutil-5.8.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:0ae6f386d8d297177fd288be6e8d1afc05966878704dad9847719650e44fc49c"},
-    {file = "psutil-5.8.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:12d844996d6c2b1d3881cfa6fa201fd635971869a9da945cf6756105af73d2df"},
-    {file = "psutil-5.8.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:02b8292609b1f7fcb34173b25e48d0da8667bc85f81d7476584d889c6e0f2131"},
-    {file = "psutil-5.8.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:6ffe81843131ee0ffa02c317186ed1e759a145267d54fdef1bc4ea5f5931ab60"},
-    {file = "psutil-5.8.0-cp27-none-win32.whl", hash = "sha256:ea313bb02e5e25224e518e4352af4bf5e062755160f77e4b1767dd5ccb65f876"},
-    {file = "psutil-5.8.0-cp27-none-win_amd64.whl", hash = "sha256:5da29e394bdedd9144c7331192e20c1f79283fb03b06e6abd3a8ae45ffecee65"},
-    {file = "psutil-5.8.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:74fb2557d1430fff18ff0d72613c5ca30c45cdbfcddd6a5773e9fc1fe9364be8"},
-    {file = "psutil-5.8.0-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:74f2d0be88db96ada78756cb3a3e1b107ce8ab79f65aa885f76d7664e56928f6"},
-    {file = "psutil-5.8.0-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:99de3e8739258b3c3e8669cb9757c9a861b2a25ad0955f8e53ac662d66de61ac"},
-    {file = "psutil-5.8.0-cp36-cp36m-win32.whl", hash = "sha256:36b3b6c9e2a34b7d7fbae330a85bf72c30b1c827a4366a07443fc4b6270449e2"},
-    {file = "psutil-5.8.0-cp36-cp36m-win_amd64.whl", hash = "sha256:52de075468cd394ac98c66f9ca33b2f54ae1d9bff1ef6b67a212ee8f639ec06d"},
-    {file = "psutil-5.8.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c6a5fd10ce6b6344e616cf01cc5b849fa8103fbb5ba507b6b2dee4c11e84c935"},
-    {file = "psutil-5.8.0-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:61f05864b42fedc0771d6d8e49c35f07efd209ade09a5afe6a5059e7bb7bf83d"},
-    {file = "psutil-5.8.0-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:0dd4465a039d343925cdc29023bb6960ccf4e74a65ad53e768403746a9207023"},
-    {file = "psutil-5.8.0-cp37-cp37m-win32.whl", hash = "sha256:1bff0d07e76114ec24ee32e7f7f8d0c4b0514b3fae93e3d2aaafd65d22502394"},
-    {file = "psutil-5.8.0-cp37-cp37m-win_amd64.whl", hash = "sha256:fcc01e900c1d7bee2a37e5d6e4f9194760a93597c97fee89c4ae51701de03563"},
-    {file = "psutil-5.8.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6223d07a1ae93f86451d0198a0c361032c4c93ebd4bf6d25e2fb3edfad9571ef"},
-    {file = "psutil-5.8.0-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:d225cd8319aa1d3c85bf195c4e07d17d3cd68636b8fc97e6cf198f782f99af28"},
-    {file = "psutil-5.8.0-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:28ff7c95293ae74bf1ca1a79e8805fcde005c18a122ca983abf676ea3466362b"},
-    {file = "psutil-5.8.0-cp38-cp38-win32.whl", hash = "sha256:ce8b867423291cb65cfc6d9c4955ee9bfc1e21fe03bb50e177f2b957f1c2469d"},
-    {file = "psutil-5.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:90f31c34d25b1b3ed6c40cdd34ff122b1887a825297c017e4cbd6796dd8b672d"},
-    {file = "psutil-5.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6323d5d845c2785efb20aded4726636546b26d3b577aded22492908f7c1bdda7"},
-    {file = "psutil-5.8.0-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:245b5509968ac0bd179287d91210cd3f37add77dad385ef238b275bad35fa1c4"},
-    {file = "psutil-5.8.0-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:90d4091c2d30ddd0a03e0b97e6a33a48628469b99585e2ad6bf21f17423b112b"},
-    {file = "psutil-5.8.0-cp39-cp39-win32.whl", hash = "sha256:ea372bcc129394485824ae3e3ddabe67dc0b118d262c568b4d2602a7070afdb0"},
-    {file = "psutil-5.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:f4634b033faf0d968bb9220dd1c793b897ab7f1189956e1aa9eae752527127d3"},
-    {file = "psutil-5.8.0.tar.gz", hash = "sha256:0c9ccb99ab76025f2f0bbecf341d4656e9c1351db8cc8a03ccd62e318ab4b5c6"},
-]
-ptable = [
-    {file = "PTable-0.9.2.tar.gz", hash = "sha256:aa7fc151cb40f2dabcd2275ba6f7fd0ff8577a86be3365cd3fb297cbe09cc292"},
-]
-pycares = [
-    {file = "pycares-4.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:71b99b9e041ae3356b859822c511f286f84c8889ec9ed1fbf6ac30fb4da13e4c"},
-    {file = "pycares-4.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c000942f5fc64e6e046aa61aa53b629b576ba11607d108909727c3c8f211a157"},
-    {file = "pycares-4.1.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b0e50ddc78252f2e2b6b5f2c73e5b2449dfb6bea7a5a0e21dfd1e2bcc9e17382"},
-    {file = "pycares-4.1.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6831e963a910b0a8cbdd2750ffcdf5f2bb0edb3f53ca69ff18484de2cc3807c4"},
-    {file = "pycares-4.1.2-cp310-cp310-win32.whl", hash = "sha256:ad7b28e1b6bc68edd3d678373fa3af84e39d287090434f25055d21b4716b2fc6"},
-    {file = "pycares-4.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:27a6f09dbfb69bb79609724c0f90dfaa7c215876a7cd9f12d585574d1f922112"},
-    {file = "pycares-4.1.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:e5a060f5fa90ae245aa99a4a8ad13ec39c2340400de037c7e8d27b081e1a3c64"},
-    {file = "pycares-4.1.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:056330275dea42b7199494047a745e1d9785d39fb8c4cd469dca043532240b80"},
-    {file = "pycares-4.1.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:0aa897543a786daba74ec5e19638bd38b2b432d179a0e248eac1e62de5756207"},
-    {file = "pycares-4.1.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:cbceaa9b2c416aa931627466d3240aecfc905c292c842252e3d77b8630072505"},
-    {file = "pycares-4.1.2-cp36-cp36m-win32.whl", hash = "sha256:112e1385c451069112d6b5ea1f9c378544f3c6b89882ff964e9a64be3336d7e4"},
-    {file = "pycares-4.1.2-cp36-cp36m-win_amd64.whl", hash = "sha256:c6680f7fdc0f1163e8f6c2a11d11b9a0b524a61000d2a71f9ccd410f154fb171"},
-    {file = "pycares-4.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:58a41a2baabcd95266db776c510d349d417919407f03510fc87ac7488730d913"},
-    {file = "pycares-4.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a810d01c9a426ee8b0f36969c2aef5fb966712be9d7e466920beb328cd9cefa3"},
-    {file = "pycares-4.1.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:b266cec81dcea2c3efbbd3dda00af8d7eb0693ae9e47e8706518334b21f27d4a"},
-    {file = "pycares-4.1.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8319afe4838e09df267c421ca93da408f770b945ec6217dda72f1f6a493e37e4"},
-    {file = "pycares-4.1.2-cp37-cp37m-win32.whl", hash = "sha256:4d5da840aa0d9b15fa51107f09270c563a348cb77b14ae9653d0bbdbe326fcc2"},
-    {file = "pycares-4.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:5632f21d92cc0225ba5ff906e4e5dec415ef0b3df322c461d138190681cd5d89"},
-    {file = "pycares-4.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8fd1ff17a26bb004f0f6bb902ba7dddd810059096ae0cc3b45e4f5be46315d19"},
-    {file = "pycares-4.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:439799be4b7576e907139a7f9b3c8a01b90d3e38af4af9cd1fc6c1ee9a42b9e6"},
-    {file = "pycares-4.1.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:40079ed58efa91747c50aac4edf8ecc7e570132ab57dc0a4030eb0d016a6cab8"},
-    {file = "pycares-4.1.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4e190471a015f8225fa38069617192e06122771cce2b169ac7a60bfdbd3d4ab2"},
-    {file = "pycares-4.1.2-cp38-cp38-win32.whl", hash = "sha256:2b837315ed08c7df009b67725fe1f50489e99de9089f58ec1b243dc612f172aa"},
-    {file = "pycares-4.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:c7eba3c8354b730a54d23237d0b6445a2f68570fa68d0848887da23a3f3b71f3"},
-    {file = "pycares-4.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2f5f84fe9f83eab9cd68544b165b74ba6e3412d029cc9ab20098d9c332869fc5"},
-    {file = "pycares-4.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569eef8597b5e02b1bc4644b9f272160304d8c9985357d7ecfcd054da97c0771"},
-    {file = "pycares-4.1.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e1489aa25d14dbf7176110ead937c01176ed5a0ebefd3b092bbd6b202241814c"},
-    {file = "pycares-4.1.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dc942692fca0e27081b7bb414bb971d34609c80df5e953f6d0c62ecc8019acd9"},
-    {file = "pycares-4.1.2-cp39-cp39-win32.whl", hash = "sha256:ed71dc4290d9c3353945965604ef1f6a4de631733e9819a7ebc747220b27e641"},
-    {file = "pycares-4.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:ec00f3594ee775665167b1a1630edceefb1b1283af9ac57480dba2fb6fd6c360"},
-    {file = "pycares-4.1.2.tar.gz", hash = "sha256:03490be0e7b51a0c8073f877bec347eff31003f64f57d9518d419d9369452837"},
-]
-pycodestyle = [
-    {file = "pycodestyle-2.7.0-py2.py3-none-any.whl", hash = "sha256:514f76d918fcc0b55c6680472f0a37970994e07bbb80725808c17089be302068"},
-    {file = "pycodestyle-2.7.0.tar.gz", hash = "sha256:c389c1d06bf7904078ca03399a4816f974a1d590090fecea0c63ec26ebaf1cef"},
-]
-pycparser = [
-    {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"},
-    {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"},
-]
-pydocstyle = [
-    {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-3.0.6-py3-none-any.whl", hash = "sha256:04ff808a5b90911829c55c4e26f75fa5ca8a2f5f36aa3a51f68e27033341d3e4"},
-    {file = "pyparsing-3.0.6.tar.gz", hash = "sha256:d9bdec0013ef1eb5a84ab39a3b3868911598afa494f5faa038647101504e2b81"},
-]
-pyreadline3 = [
-    {file = "pyreadline3-3.3-py3-none-any.whl", hash = "sha256:0003fd0079d152ecbd8111202c5a7dfa6a5569ffd65b235e45f3c2ecbee337b4"},
-    {file = "pyreadline3-3.3.tar.gz", hash = "sha256:ff3b5a1ac0010d0967869f723e687d42cabc7dccf33b14934c92aa5168d260b3"},
-]
-python-dateutil = [
-    {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"},
-    {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"},
-]
-python-dotenv = [
-    {file = "python-dotenv-0.19.2.tar.gz", hash = "sha256:a5de49a31e953b45ff2d2fd434bbc2670e8db5273606c1e737cc6b93eff3655f"},
-    {file = "python_dotenv-0.19.2-py2.py3-none-any.whl", hash = "sha256:32b2bdc1873fd3a3c346da1c6db83d0053c3c62f28f1f38516070c4c8971b1d3"},
-]
-pyyaml = [
-    {file = "PyYAML-5.4.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:3b2b1824fe7112845700f815ff6a489360226a5609b96ec2190a45e62a9fc922"},
-    {file = "PyYAML-5.4.1-cp27-cp27m-win32.whl", hash = "sha256:129def1b7c1bf22faffd67b8f3724645203b79d8f4cc81f674654d9902cb4393"},
-    {file = "PyYAML-5.4.1-cp27-cp27m-win_amd64.whl", hash = "sha256:4465124ef1b18d9ace298060f4eccc64b0850899ac4ac53294547536533800c8"},
-    {file = "PyYAML-5.4.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:bb4191dfc9306777bc594117aee052446b3fa88737cd13b7188d0e7aa8162185"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:6c78645d400265a062508ae399b60b8c167bf003db364ecb26dcab2bda048253"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:4e0583d24c881e14342eaf4ec5fbc97f934b999a6828693a99157fde912540cc"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:72a01f726a9c7851ca9bfad6fd09ca4e090a023c00945ea05ba1638c09dc3347"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-manylinux2014_s390x.whl", hash = "sha256:895f61ef02e8fed38159bb70f7e100e00f471eae2bc838cd0f4ebb21e28f8541"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-win32.whl", hash = "sha256:3bd0e463264cf257d1ffd2e40223b197271046d09dadf73a0fe82b9c1fc385a5"},
-    {file = "PyYAML-5.4.1-cp36-cp36m-win_amd64.whl", hash = "sha256:e4fac90784481d221a8e4b1162afa7c47ed953be40d31ab4629ae917510051df"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:5accb17103e43963b80e6f837831f38d314a0495500067cb25afab2e8d7a4018"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:e1d4970ea66be07ae37a3c2e48b5ec63f7ba6804bdddfdbd3cfd954d25a82e63"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:cb333c16912324fd5f769fff6bc5de372e9e7a202247b48870bc251ed40239aa"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-manylinux2014_s390x.whl", hash = "sha256:fe69978f3f768926cfa37b867e3843918e012cf83f680806599ddce33c2c68b0"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-win32.whl", hash = "sha256:dd5de0646207f053eb0d6c74ae45ba98c3395a571a2891858e87df7c9b9bd51b"},
-    {file = "PyYAML-5.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:08682f6b72c722394747bddaf0aa62277e02557c0fd1c42cb853016a38f8dedf"},
-    {file = "PyYAML-5.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d2d9808ea7b4af864f35ea216be506ecec180628aced0704e34aca0b040ffe46"},
-    {file = "PyYAML-5.4.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:8c1be557ee92a20f184922c7b6424e8ab6691788e6d86137c5d93c1a6ec1b8fb"},
-    {file = "PyYAML-5.4.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:fd7f6999a8070df521b6384004ef42833b9bd62cfee11a09bda1079b4b704247"},
-    {file = "PyYAML-5.4.1-cp38-cp38-manylinux2014_s390x.whl", hash = "sha256:bfb51918d4ff3d77c1c856a9699f8492c612cde32fd3bcd344af9be34999bfdc"},
-    {file = "PyYAML-5.4.1-cp38-cp38-win32.whl", hash = "sha256:fa5ae20527d8e831e8230cbffd9f8fe952815b2b7dae6ffec25318803a7528fc"},
-    {file = "PyYAML-5.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:0f5f5786c0e09baddcd8b4b45f20a7b5d61a7e7e99846e3c799b05c7c53fa696"},
-    {file = "PyYAML-5.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:294db365efa064d00b8d1ef65d8ea2c3426ac366c0c4368d930bf1c5fb497f77"},
-    {file = "PyYAML-5.4.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:74c1485f7707cf707a7aef42ef6322b8f97921bd89be2ab6317fd782c2d53183"},
-    {file = "PyYAML-5.4.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:d483ad4e639292c90170eb6f7783ad19490e7a8defb3e46f97dfe4bacae89122"},
-    {file = "PyYAML-5.4.1-cp39-cp39-manylinux2014_s390x.whl", hash = "sha256:fdc842473cd33f45ff6bce46aea678a54e3d21f1b61a7750ce3c498eedfe25d6"},
-    {file = "PyYAML-5.4.1-cp39-cp39-win32.whl", hash = "sha256:49d4cdd9065b9b6e206d0595fee27a96b5dd22618e7520c33204a4a3239d5b10"},
-    {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.9.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:68227a8b25291d6a2140aef049271ea30a77be5ef672a58e582a55a5cc1fce93"},
-    {file = "rapidfuzz-1.9.1-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:c33541995b96ff40025c1456b8c74b7dd2ab9cbf91943fc35a7bb621f48940e2"},
-    {file = "rapidfuzz-1.9.1-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:c2fafbbf97a4632822248f4201601b691e2eac5fdb30e5d7a96d07a6d058a7d4"},
-    {file = "rapidfuzz-1.9.1-cp27-cp27m-win32.whl", hash = "sha256:364795f617a99e1dbb55ac3947ab8366588b72531cb2d6152666287d20610706"},
-    {file = "rapidfuzz-1.9.1-cp27-cp27m-win_amd64.whl", hash = "sha256:f171d9e66144b0647f9b998ef10bdd919a640e4b1357250c8ef6259deb5ffe0d"},
-    {file = "rapidfuzz-1.9.1-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:c83801a7c5209663aa120b815a4f2c39e95fe8e0b774ec58a1e0affd6a2fcfc6"},
-    {file = "rapidfuzz-1.9.1-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:67e61c2baa6bb1848c4a33752f1781124dcc90bf3f31b18b44db1ae4e4e26634"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8ab7eb003a18991347174910f11d38ff40399081185d9e3199ec277535f7828b"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5ad450badf06ddf98a246140b5059ba895ee8445e8102a5a289908327f551f81"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:402b2174bded62a793c5f7d9aec16bc32c661402360a934819ae72b54cfbce1e"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:92066ccb054efc2e17afb4049c98b550969653cd58f71dd756cfcc8e6864630a"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8dc0bf1814accee08a9c9bace6672ef06eae6b0446fce88e3e97e23dfaf3ea10"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bdbd387efb8478605951344f327dd03bf053c138d757369a43404305b99e55db"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-win32.whl", hash = "sha256:b1c54807e556dbcc6caf4ce0f24446c01b195f3cc46e2a6e74b82d3a21eaa45d"},
-    {file = "rapidfuzz-1.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:ac3273364cd1619cab3bf0ba731efea5405833f9eba362da7dcd70bd42073d8e"},
-    {file = "rapidfuzz-1.9.1-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:d9faf62606c08a0a6992dd480c72b6a068733ae02688dc35f2e36ba0d44673f4"},
-    {file = "rapidfuzz-1.9.1-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:f6a56a48be047637b1b0b2459a11cf7cd5aa7bbe16a439bd4f73b4af39e620e4"},
-    {file = "rapidfuzz-1.9.1-cp35-cp35m-win32.whl", hash = "sha256:aa91609979e9d2700f0ff100df99b36e7d700b70169ee385d43d5de9e471ae97"},
-    {file = "rapidfuzz-1.9.1-cp35-cp35m-win_amd64.whl", hash = "sha256:b4cfdd0915ab4cec86c2ff6bab9f01b03454f3de0963c37f9f219df2ddf42b95"},
-    {file = "rapidfuzz-1.9.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:c6bfa4ad0158a093cd304f795ceefdc3861ae6942a61432b2a50858be6de88ca"},
-    {file = "rapidfuzz-1.9.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:eb0ea02295d9278bd2dcd2df4760b0f2887b6c3f2f374005ec5af320d8d3a37e"},
-    {file = "rapidfuzz-1.9.1-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d5187cd5cd6273e9fee07de493a42a2153134a4914df74cb1abb0744551c548a"},
-    {file = "rapidfuzz-1.9.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6e5b8af63f9c05b64454460759ed84a715d581d598ec4484f4ec512f398e8b1"},
-    {file = "rapidfuzz-1.9.1-cp36-cp36m-win32.whl", hash = "sha256:36137f88f2b28115af506118e64e11c816611eab2434293af7fdacd1290ffb9d"},
-    {file = "rapidfuzz-1.9.1-cp36-cp36m-win_amd64.whl", hash = "sha256:fcc420cad46be7c9887110edf04cdee545f26dbf22650a443d89790fc35f7b88"},
-    {file = "rapidfuzz-1.9.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b06de314f426aebff8a44319016bbe2b22f7848c84e44224f80b0690b7b08b18"},
-    {file = "rapidfuzz-1.9.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e5de44e719faea79e45322b037f0d4a141d750b80d2204fa68f43a42a24f0fbc"},
-    {file = "rapidfuzz-1.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f9439df09a782afd01b67005a3b110c70bbf9e1cf06d2ac9b293ce2d02d3c549"},
-    {file = "rapidfuzz-1.9.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e903d4702647465721e2d0431c95f04fd56a06577f06f41e2960c83fd63c1bad"},
-    {file = "rapidfuzz-1.9.1-cp37-cp37m-win32.whl", hash = "sha256:a5298f4ac1975edcbb15583eab659a44b33aebaf3bccf172e185cfea68771c08"},
-    {file = "rapidfuzz-1.9.1-cp37-cp37m-win_amd64.whl", hash = "sha256:103193a01921b54fcdad6b01cfda3a68e00aeafca236b7ecd5b1b2c2e7e96337"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1d98a3187040dca855e02179a35c137f72ef83ce243783d44ea59efa86b94b3a"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cb92bf7fc911b787055a88d9295ca3b4fe8576e3b59271f070f1b1b181eb087d"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3f014a0f5f8159a94c6ee884fedd1c30e07fb866a5d76ff2c18091bc6363b76f"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:31474074a99f72289ac325fbd77983e7d355d48860bfe7a4f6f6396fdb24410a"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec67d79af5a2d7b0cf67b570a5579710e461cadda4120478e813b63491f394dd"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ebc0d3d15ed32f98f0052cf6e3e9c9b8010fb93c04fb74d2022e3c51ec540e2"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-win32.whl", hash = "sha256:477ab1a3044bab89db45caabc562b158f68765ecaa638b73ba17e92f09dfa5ff"},
-    {file = "rapidfuzz-1.9.1-cp38-cp38-win_amd64.whl", hash = "sha256:8e872763dc0367d7544aa585d2e8b27af233323b8a7cd2f9b78cafa05bae5018"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8401c41e219ae36ca7a88762776a6270511650d4cc70d024ae61561e96d67e47"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ea10bd8e0436801c3264f7084a5ea194f12ba9fe1ba898aa4a2107d276501292"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:433737914b46c1ffa0c678eceae1c260dc6b7fb5b6cad4c725d3e3607c764b32"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8c3b08e90e45acbc469d1f456681643256e952bf84ec7714f58979baba0c8a1c"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:bbcd265b3c86176e5db4cbba7b4364d7333c214ee80e2d259c7085929934ca9d"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d69fabcd635783cd842e7d5ee4b77164314c5124b82df5a0c436ab3d698f8a9"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-win32.whl", hash = "sha256:01f16b6f3fa5d1a26c12f5da5de0032f1e12c919d876005b57492a8ec9a5c043"},
-    {file = "rapidfuzz-1.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:0bcc5bbfdbe6068cc2cf0029ab6cde08dceac498d232fa3a61dd34fbfa0b3f36"},
-    {file = "rapidfuzz-1.9.1-pp27-pypy_73-manylinux2010_x86_64.whl", hash = "sha256:de869c8f4e8edb9b2f7b8232a04896645501defcbd9d85bc0202ff3ec6285f6b"},
-    {file = "rapidfuzz-1.9.1-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:db5978e970fb0955974d51021da4b929e2e4890fef17792989ee32658e2b159c"},
-    {file = "rapidfuzz-1.9.1-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:33479f75f36ac3a1d8421365d4fa906e013490790730a89caba31d06e6f71738"},
-    {file = "rapidfuzz-1.9.1-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:af991cb333ec526d894923163050931b3a870b7694bf7687aaa6154d341a98f5"},
-    {file = "rapidfuzz-1.9.1.tar.gz", hash = "sha256:bd7a4fe33ba49db3417f0f57a8af02462554f1296dedcf35b026cd3525efef74"},
-]
-redis = [
-    {file = "redis-4.0.2-py3-none-any.whl", hash = "sha256:c8481cf414474e3497ec7971a1ba9b998c8efad0f0d289a009a5bbef040894f9"},
-    {file = "redis-4.0.2.tar.gz", hash = "sha256:ccf692811f2c1fc7a92b466aa2599e4a6d2d73d5f736a2c70be600657c0da34a"},
-]
-sentry-sdk = [
-    {file = "sentry-sdk-0.20.3.tar.gz", hash = "sha256:4ae8d1ced6c67f1c8ea51d82a16721c166c489b76876c9f2c202b8a50334b237"},
-    {file = "sentry_sdk-0.20.3-py2.py3-none-any.whl", hash = "sha256:e75c8c58932bda8cd293ea8e4b242527129e1caaec91433d21b8b2f20fee030b"},
-]
-six = [
-    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
-    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
-]
-snowballstemmer = [
-    {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"},
-    {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"},
-]
-sortedcontainers = [
-    {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.3.1-py3-none-any.whl", hash = "sha256:1a3cca2617c6b38c0343ed661b1fa5de5637f257d4fe22bd9f1338010a1efefb"},
-    {file = "soupsieve-2.3.1.tar.gz", hash = "sha256:b8d49b1cd4f037c7082a9683dfa1801aa2597fb11c3a1155b7a5b94829b4f1f9"},
-]
-taskipy = [
-    {file = "taskipy-1.9.0-py3-none-any.whl", hash = "sha256:02bd2c51c7356ed3f7f8853210ada1cd2ab273e68359ee865021c3057eec6615"},
-    {file = "taskipy-1.9.0.tar.gz", hash = "sha256:449c160b557cdb1d9c17097a5ea4aa0cd5223723ddbaaa5d5032dd16274fb8f0"},
-]
-testfixtures = [
-    {file = "testfixtures-6.18.3-py2.py3-none-any.whl", hash = "sha256:6ddb7f56a123e1a9339f130a200359092bd0a6455e31838d6c477e8729bb7763"},
-    {file = "testfixtures-6.18.3.tar.gz", hash = "sha256:2600100ae96ffd082334b378e355550fef8b4a529a6fa4c34f47130905c7426d"},
-]
-toml = [
-    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
-    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
-]
-typing-extensions = [
-    {file = "typing_extensions-4.0.1-py3-none-any.whl", hash = "sha256:7f001e5ac290a0c0401508864c7ec868be4e701886d5b573a9528ed3973d9d3b"},
-    {file = "typing_extensions-4.0.1.tar.gz", hash = "sha256:4ca091dea149f945ec56afb48dae714f21e8692ef22a395223bcd328961b6a0e"},
-]
-urllib3 = [
-    {file = "urllib3-1.26.7-py2.py3-none-any.whl", hash = "sha256:c4fdf4019605b6e5423637e01bc9fe4daef873709a7973e195ceba0a62bbc844"},
-    {file = "urllib3-1.26.7.tar.gz", hash = "sha256:4987c65554f7a2dbf30c18fd48778ef124af6fab771a377103da0585e2336ece"},
-]
-virtualenv = [
-    {file = "virtualenv-20.11.0-py2.py3-none-any.whl", hash = "sha256:eb0cb34160f32c6596405308ee6a8a4abbf3247b2b9794ae655a156d43abf48e"},
-    {file = "virtualenv-20.11.0.tar.gz", hash = "sha256:2f15b9226cb74b59c21e8236dd791c395bee08cdd33b99cddd18e1f866cdb098"},
-]
-wrapt = [
-    {file = "wrapt-1.13.3-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:e05e60ff3b2b0342153be4d1b597bbcfd8330890056b9619f4ad6b8d5c96a81a"},
-    {file = "wrapt-1.13.3-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:85148f4225287b6a0665eef08a178c15097366d46b210574a658c1ff5b377489"},
-    {file = "wrapt-1.13.3-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:2dded5496e8f1592ec27079b28b6ad2a1ef0b9296d270f77b8e4a3a796cf6909"},
-    {file = "wrapt-1.13.3-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:e94b7d9deaa4cc7bac9198a58a7240aaf87fe56c6277ee25fa5b3aa1edebd229"},
-    {file = "wrapt-1.13.3-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:498e6217523111d07cd67e87a791f5e9ee769f9241fcf8a379696e25806965af"},
-    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:ec7e20258ecc5174029a0f391e1b948bf2906cd64c198a9b8b281b811cbc04de"},
-    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:87883690cae293541e08ba2da22cacaae0a092e0ed56bbba8d018cc486fbafbb"},
-    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:f99c0489258086308aad4ae57da9e8ecf9e1f3f30fa35d5e170b4d4896554d80"},
-    {file = "wrapt-1.13.3-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:6a03d9917aee887690aa3f1747ce634e610f6db6f6b332b35c2dd89412912bca"},
-    {file = "wrapt-1.13.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:936503cb0a6ed28dbfa87e8fcd0a56458822144e9d11a49ccee6d9a8adb2ac44"},
-    {file = "wrapt-1.13.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f9c51d9af9abb899bd34ace878fbec8bf357b3194a10c4e8e0a25512826ef056"},
-    {file = "wrapt-1.13.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:220a869982ea9023e163ba915077816ca439489de6d2c09089b219f4e11b6785"},
-    {file = "wrapt-1.13.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:0877fe981fd76b183711d767500e6b3111378ed2043c145e21816ee589d91096"},
-    {file = "wrapt-1.13.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:43e69ffe47e3609a6aec0fe723001c60c65305784d964f5007d5b4fb1bc6bf33"},
-    {file = "wrapt-1.13.3-cp310-cp310-win32.whl", hash = "sha256:78dea98c81915bbf510eb6a3c9c24915e4660302937b9ae05a0947164248020f"},
-    {file = "wrapt-1.13.3-cp310-cp310-win_amd64.whl", hash = "sha256:ea3e746e29d4000cd98d572f3ee2a6050a4f784bb536f4ac1f035987fc1ed83e"},
-    {file = "wrapt-1.13.3-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:8c73c1a2ec7c98d7eaded149f6d225a692caa1bd7b2401a14125446e9e90410d"},
-    {file = "wrapt-1.13.3-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:086218a72ec7d986a3eddb7707c8c4526d677c7b35e355875a0fe2918b059179"},
-    {file = "wrapt-1.13.3-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:e92d0d4fa68ea0c02d39f1e2f9cb5bc4b4a71e8c442207433d8db47ee79d7aa3"},
-    {file = "wrapt-1.13.3-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:d4a5f6146cfa5c7ba0134249665acd322a70d1ea61732723c7d3e8cc0fa80755"},
-    {file = "wrapt-1.13.3-cp35-cp35m-win32.whl", hash = "sha256:8aab36778fa9bba1a8f06a4919556f9f8c7b33102bd71b3ab307bb3fecb21851"},
-    {file = "wrapt-1.13.3-cp35-cp35m-win_amd64.whl", hash = "sha256:944b180f61f5e36c0634d3202ba8509b986b5fbaf57db3e94df11abee244ba13"},
-    {file = "wrapt-1.13.3-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:2ebdde19cd3c8cdf8df3fc165bc7827334bc4e353465048b36f7deeae8ee0918"},
-    {file = "wrapt-1.13.3-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:610f5f83dd1e0ad40254c306f4764fcdc846641f120c3cf424ff57a19d5f7ade"},
-    {file = "wrapt-1.13.3-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5601f44a0f38fed36cc07db004f0eedeaadbdcec90e4e90509480e7e6060a5bc"},
-    {file = "wrapt-1.13.3-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:e6906d6f48437dfd80464f7d7af1740eadc572b9f7a4301e7dd3d65db285cacf"},
-    {file = "wrapt-1.13.3-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:766b32c762e07e26f50d8a3468e3b4228b3736c805018e4b0ec8cc01ecd88125"},
-    {file = "wrapt-1.13.3-cp36-cp36m-win32.whl", hash = "sha256:5f223101f21cfd41deec8ce3889dc59f88a59b409db028c469c9b20cfeefbe36"},
-    {file = "wrapt-1.13.3-cp36-cp36m-win_amd64.whl", hash = "sha256:f122ccd12fdc69628786d0c947bdd9cb2733be8f800d88b5a37c57f1f1d73c10"},
-    {file = "wrapt-1.13.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:46f7f3af321a573fc0c3586612db4decb7eb37172af1bc6173d81f5b66c2e068"},
-    {file = "wrapt-1.13.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:778fd096ee96890c10ce96187c76b3e99b2da44e08c9e24d5652f356873f6709"},
-    {file = "wrapt-1.13.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:0cb23d36ed03bf46b894cfec777eec754146d68429c30431c99ef28482b5c1df"},
-    {file = "wrapt-1.13.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:96b81ae75591a795d8c90edc0bfaab44d3d41ffc1aae4d994c5aa21d9b8e19a2"},
-    {file = "wrapt-1.13.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:7dd215e4e8514004c8d810a73e342c536547038fb130205ec4bba9f5de35d45b"},
-    {file = "wrapt-1.13.3-cp37-cp37m-win32.whl", hash = "sha256:47f0a183743e7f71f29e4e21574ad3fa95676136f45b91afcf83f6a050914829"},
-    {file = "wrapt-1.13.3-cp37-cp37m-win_amd64.whl", hash = "sha256:fd76c47f20984b43d93de9a82011bb6e5f8325df6c9ed4d8310029a55fa361ea"},
-    {file = "wrapt-1.13.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b73d4b78807bd299b38e4598b8e7bd34ed55d480160d2e7fdaabd9931afa65f9"},
-    {file = "wrapt-1.13.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ec9465dd69d5657b5d2fa6133b3e1e989ae27d29471a672416fd729b429eb554"},
-    {file = "wrapt-1.13.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dd91006848eb55af2159375134d724032a2d1d13bcc6f81cd8d3ed9f2b8e846c"},
-    {file = "wrapt-1.13.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ae9de71eb60940e58207f8e71fe113c639da42adb02fb2bcbcaccc1ccecd092b"},
-    {file = "wrapt-1.13.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:51799ca950cfee9396a87f4a1240622ac38973b6df5ef7a41e7f0b98797099ce"},
-    {file = "wrapt-1.13.3-cp38-cp38-win32.whl", hash = "sha256:4b9c458732450ec42578b5642ac53e312092acf8c0bfce140ada5ca1ac556f79"},
-    {file = "wrapt-1.13.3-cp38-cp38-win_amd64.whl", hash = "sha256:7dde79d007cd6dfa65afe404766057c2409316135cb892be4b1c768e3f3a11cb"},
-    {file = "wrapt-1.13.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:981da26722bebb9247a0601e2922cedf8bb7a600e89c852d063313102de6f2cb"},
-    {file = "wrapt-1.13.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:705e2af1f7be4707e49ced9153f8d72131090e52be9278b5dbb1498c749a1e32"},
-    {file = "wrapt-1.13.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:25b1b1d5df495d82be1c9d2fad408f7ce5ca8a38085e2da41bb63c914baadff7"},
-    {file = "wrapt-1.13.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:77416e6b17926d953b5c666a3cb718d5945df63ecf922af0ee576206d7033b5e"},
-    {file = "wrapt-1.13.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:865c0b50003616f05858b22174c40ffc27a38e67359fa1495605f96125f76640"},
-    {file = "wrapt-1.13.3-cp39-cp39-win32.whl", hash = "sha256:0a017a667d1f7411816e4bf214646d0ad5b1da2c1ea13dec6c162736ff25a374"},
-    {file = "wrapt-1.13.3-cp39-cp39-win_amd64.whl", hash = "sha256:81bd7c90d28a4b2e1df135bfbd7c23aee3050078ca6441bead44c42483f9ebfb"},
-    {file = "wrapt-1.13.3.tar.gz", hash = "sha256:1fea9cd438686e6682271d36f3481a9f3636195578bab9ca3382e2f5f01fc185"},
-]
-yarl = [
-    {file = "yarl-1.7.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f2a8508f7350512434e41065684076f640ecce176d262a7d54f0da41d99c5a95"},
-    {file = "yarl-1.7.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:da6df107b9ccfe52d3a48165e48d72db0eca3e3029b5b8cb4fe6ee3cb870ba8b"},
-    {file = "yarl-1.7.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a1d0894f238763717bdcfea74558c94e3bc34aeacd3351d769460c1a586a8b05"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfe4b95b7e00c6635a72e2d00b478e8a28bfb122dc76349a06e20792eb53a523"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c145ab54702334c42237a6c6c4cc08703b6aa9b94e2f227ceb3d477d20c36c63"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1ca56f002eaf7998b5fcf73b2421790da9d2586331805f38acd9997743114e98"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:1d3d5ad8ea96bd6d643d80c7b8d5977b4e2fb1bab6c9da7322616fd26203d125"},
-    {file = "yarl-1.7.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:167ab7f64e409e9bdd99333fe8c67b5574a1f0495dcfd905bc7454e766729b9e"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:95a1873b6c0dd1c437fb3bb4a4aaa699a48c218ac7ca1e74b0bee0ab16c7d60d"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6152224d0a1eb254f97df3997d79dadd8bb2c1a02ef283dbb34b97d4f8492d23"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:5bb7d54b8f61ba6eee541fba4b83d22b8a046b4ef4d8eb7f15a7e35db2e1e245"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:9c1f083e7e71b2dd01f7cd7434a5f88c15213194df38bc29b388ccdf1492b739"},
-    {file = "yarl-1.7.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f44477ae29025d8ea87ec308539f95963ffdc31a82f42ca9deecf2d505242e72"},
-    {file = "yarl-1.7.2-cp310-cp310-win32.whl", hash = "sha256:cff3ba513db55cc6a35076f32c4cdc27032bd075c9faef31fec749e64b45d26c"},
-    {file = "yarl-1.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:c9c6d927e098c2d360695f2e9d38870b2e92e0919be07dbe339aefa32a090265"},
-    {file = "yarl-1.7.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:9b4c77d92d56a4c5027572752aa35082e40c561eec776048330d2907aead891d"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c01a89a44bb672c38f42b49cdb0ad667b116d731b3f4c896f72302ff77d71656"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c19324a1c5399b602f3b6e7db9478e5b1adf5cf58901996fc973fe4fccd73eed"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3abddf0b8e41445426d29f955b24aeecc83fa1072be1be4e0d194134a7d9baee"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6a1a9fe17621af43e9b9fcea8bd088ba682c8192d744b386ee3c47b56eaabb2c"},
-    {file = "yarl-1.7.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:8b0915ee85150963a9504c10de4e4729ae700af11df0dc5550e6587ed7891e92"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:29e0656d5497733dcddc21797da5a2ab990c0cb9719f1f969e58a4abac66234d"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:bf19725fec28452474d9887a128e98dd67eee7b7d52e932e6949c532d820dc3b"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_ppc64le.whl", hash = "sha256:d6f3d62e16c10e88d2168ba2d065aa374e3c538998ed04996cd373ff2036d64c"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_s390x.whl", hash = "sha256:ac10bbac36cd89eac19f4e51c032ba6b412b3892b685076f4acd2de18ca990aa"},
-    {file = "yarl-1.7.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:aa32aaa97d8b2ed4e54dc65d241a0da1c627454950f7d7b1f95b13985afd6c5d"},
-    {file = "yarl-1.7.2-cp36-cp36m-win32.whl", hash = "sha256:87f6e082bce21464857ba58b569370e7b547d239ca22248be68ea5d6b51464a1"},
-    {file = "yarl-1.7.2-cp36-cp36m-win_amd64.whl", hash = "sha256:ac35ccde589ab6a1870a484ed136d49a26bcd06b6a1c6397b1967ca13ceb3913"},
-    {file = "yarl-1.7.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a467a431a0817a292121c13cbe637348b546e6ef47ca14a790aa2fa8cc93df63"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ab0c3274d0a846840bf6c27d2c60ba771a12e4d7586bf550eefc2df0b56b3b4"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d260d4dc495c05d6600264a197d9d6f7fc9347f21d2594926202fd08cf89a8ba"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fc4dd8b01a8112809e6b636b00f487846956402834a7fd59d46d4f4267181c41"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c1164a2eac148d85bbdd23e07dfcc930f2e633220f3eb3c3e2a25f6148c2819e"},
-    {file = "yarl-1.7.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:67e94028817defe5e705079b10a8438b8cb56e7115fa01640e9c0bb3edf67332"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:89ccbf58e6a0ab89d487c92a490cb5660d06c3a47ca08872859672f9c511fc52"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:8cce6f9fa3df25f55521fbb5c7e4a736683148bcc0c75b21863789e5185f9185"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:211fcd65c58bf250fb994b53bc45a442ddc9f441f6fec53e65de8cba48ded986"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c10ea1e80a697cf7d80d1ed414b5cb8f1eec07d618f54637067ae3c0334133c4"},
-    {file = "yarl-1.7.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:52690eb521d690ab041c3919666bea13ab9fbff80d615ec16fa81a297131276b"},
-    {file = "yarl-1.7.2-cp37-cp37m-win32.whl", hash = "sha256:695ba021a9e04418507fa930d5f0704edbce47076bdcfeeaba1c83683e5649d1"},
-    {file = "yarl-1.7.2-cp37-cp37m-win_amd64.whl", hash = "sha256:c17965ff3706beedafd458c452bf15bac693ecd146a60a06a214614dc097a271"},
-    {file = "yarl-1.7.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:fce78593346c014d0d986b7ebc80d782b7f5e19843ca798ed62f8e3ba8728576"},
-    {file = "yarl-1.7.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c2a1ac41a6aa980db03d098a5531f13985edcb451bcd9d00670b03129922cd0d"},
-    {file = "yarl-1.7.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:39d5493c5ecd75c8093fa7700a2fb5c94fe28c839c8e40144b7ab7ccba6938c8"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1eb6480ef366d75b54c68164094a6a560c247370a68c02dddb11f20c4c6d3c9d"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ba63585a89c9885f18331a55d25fe81dc2d82b71311ff8bd378fc8004202ff6"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e39378894ee6ae9f555ae2de332d513a5763276a9265f8e7cbaeb1b1ee74623a"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c0910c6b6c31359d2f6184828888c983d54d09d581a4a23547a35f1d0b9484b1"},
-    {file = "yarl-1.7.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6feca8b6bfb9eef6ee057628e71e1734caf520a907b6ec0d62839e8293e945c0"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8300401dc88cad23f5b4e4c1226f44a5aa696436a4026e456fe0e5d2f7f486e6"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:788713c2896f426a4e166b11f4ec538b5736294ebf7d5f654ae445fd44270832"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:fd547ec596d90c8676e369dd8a581a21227fe9b4ad37d0dc7feb4ccf544c2d59"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:737e401cd0c493f7e3dd4db72aca11cfe069531c9761b8ea474926936b3c57c8"},
-    {file = "yarl-1.7.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:baf81561f2972fb895e7844882898bda1eef4b07b5b385bcd308d2098f1a767b"},
-    {file = "yarl-1.7.2-cp38-cp38-win32.whl", hash = "sha256:ede3b46cdb719c794427dcce9d8beb4abe8b9aa1e97526cc20de9bd6583ad1ef"},
-    {file = "yarl-1.7.2-cp38-cp38-win_amd64.whl", hash = "sha256:cc8b7a7254c0fc3187d43d6cb54b5032d2365efd1df0cd1749c0c4df5f0ad45f"},
-    {file = "yarl-1.7.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:580c1f15500e137a8c37053e4cbf6058944d4c114701fa59944607505c2fe3a0"},
-    {file = "yarl-1.7.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3ec1d9a0d7780416e657f1e405ba35ec1ba453a4f1511eb8b9fbab81cb8b3ce1"},
-    {file = "yarl-1.7.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3bf8cfe8856708ede6a73907bf0501f2dc4e104085e070a41f5d88e7faf237f3"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1be4bbb3d27a4e9aa5f3df2ab61e3701ce8fcbd3e9846dbce7c033a7e8136746"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:534b047277a9a19d858cde163aba93f3e1677d5acd92f7d10ace419d478540de"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6ddcd80d79c96eb19c354d9dca95291589c5954099836b7c8d29278a7ec0bda"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9bfcd43c65fbb339dc7086b5315750efa42a34eefad0256ba114cd8ad3896f4b"},
-    {file = "yarl-1.7.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f64394bd7ceef1237cc604b5a89bf748c95982a84bcd3c4bbeb40f685c810794"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:044daf3012e43d4b3538562da94a88fb12a6490652dbc29fb19adfa02cf72eac"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:368bcf400247318382cc150aaa632582d0780b28ee6053cd80268c7e72796dec"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:bab827163113177aee910adb1f48ff7af31ee0289f434f7e22d10baf624a6dfe"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0cba38120db72123db7c58322fa69e3c0efa933040ffb586c3a87c063ec7cae8"},
-    {file = "yarl-1.7.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:59218fef177296451b23214c91ea3aba7858b4ae3306dde120224cfe0f7a6ee8"},
-    {file = "yarl-1.7.2-cp39-cp39-win32.whl", hash = "sha256:1edc172dcca3f11b38a9d5c7505c83c1913c0addc99cd28e993efeaafdfaa18d"},
-    {file = "yarl-1.7.2-cp39-cp39-win_amd64.whl", hash = "sha256:797c2c412b04403d2da075fb93c123df35239cd7b4cc4e0cd9e5839b73f52c58"},
-    {file = "yarl-1.7.2.tar.gz", hash = "sha256:45399b46d60c253327a460e99856752009fcee5f5d3c80b2f7c0cae1c38d56dd"},
-]
+distlib = []
+emoji = []
+emojis = []
+fakeredis = []
+filelock = []
+flake8 = []
+flake8-annotations = []
+flake8-bugbear = []
+flake8-docstrings = []
+flake8-isort = []
+flake8-polyfill = []
+flake8-string-format = []
+flake8-tidy-imports = []
+flake8-todo = []
+hiredis = []
+humanfriendly = []
+identify = []
+idna = []
+isort = []
+lxml = []
+mccabe = []
+mslex = []
+multidict = []
+nodeenv = []
+packaging = []
+pep8-naming = []
+pillow = []
+pip-licenses = []
+platformdirs = []
+pre-commit = []
+psutil = []
+ptable = []
+pycares = []
+pycodestyle = []
+pycparser = []
+pydocstyle = []
+pyflakes = []
+pyjokes = []
+pyparsing = []
+pyreadline3 = []
+python-dateutil = []
+python-dotenv = []
+pyyaml = []
+rapidfuzz = []
+redis = []
+sentry-sdk = []
+six = []
+snowballstemmer = []
+sortedcontainers = []
+soupsieve = []
+taskipy = []
+testfixtures = []
+toml = []
+typing-extensions = []
+urllib3 = []
+virtualenv = []
+wrapt = []
+yarl = []
diff --git a/pyproject.toml b/pyproject.toml
index 2a216209..729d67fa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,14 +13,16 @@ aioredis = "~1.3"
 rapidfuzz = "~=1.4"
 arrow = "~=1.1.0"
 beautifulsoup4 = "~=4.9"
-pillow = "~=8.1"
+pillow = "~=9.0"
 sentry-sdk = "~=0.19"
 PyYAML = "~=5.4"
 async-rediscache = {extras = ["fakeredis"], version = "~=0.1.4"}
 emojis = "~=0.6.0"
 coloredlogs = "~=15.0"
 colorama = { version = "~=0.4.3", markers = "sys_platform == 'win32'" }
-lxml = "~=4.6"
+lxml = "~=4.9"
+emoji = "^1.6.1"
+pyjokes = "0.6.0"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~=3.8"
diff --git a/sir-lancebot-logo.png b/sir-lancebot-logo.png
index fc606bf7..d8e28ad8 100644
--- a/sir-lancebot-logo.png
+++ b/sir-lancebot-logo.png
diff --git a/tox.ini b/tox.ini
index f561fcd9..61ff9616 100644
--- a/tox.ini
+++ b/tox.ini
@@ -20,5 +20,7 @@ exclude=
     __pycache__,.cache,
     venv,.venv,
     tests,
-    constants.py
+per-file-ignores =
+    # Don't require docstrings in constants
+    constants.py:D101
 import-order-style=pycharm