fix: Resolve Merge Conflicts

21 files changed, 725 insertions, 440 deletions

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index e2739287..ba418166 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,30 +1,20 @@
 ## Relevant Issues
-<!-- List relevant issue tickets here. -->
-<!-- Say "Closes #0" for issues that the PR resolves, replacing 0 with the issue number. -->
+<!--
+It is mandatory to link to an issue that has been approved by a Core Developer, indicated by an "approved" label.
+Issues can be skipped with explicit core dev approval, but you have to link the discussion.
+-->
 
-
-## Description
-<!-- Describe how you've implemented your changes. -->
-
-
-## Reasoning
-<!-- Outline the reasoning for how it's been implemented. -->
+<!-- Link the issue by typing: "Closes #<number>" (Closes #0 to close issue 0 for example). -->
 
 
-## Screenshots
-<!-- Remove this section if the changes don't impact anything user-facing. -->
-<!-- You can add images by just copy pasting them directly in the editor. -->
-
-
-## Additional Details
-<!-- Delete this section if not applicable. -->
-
+## Description
+<!-- Describe what changes you made, and how you've implemented them. -->
 
 ## Did you:
 <!-- These are required when contributing. -->
 <!-- Replace [ ] with [x] to mark items as done. -->
 
 - [ ] Join the [**Python Discord Community**](https://discord.gg/python)?
-- [ ] If dependencies have been added or updated, run `pipenv lock`?
-- [ ] **Lint your code** (`pipenv run lint`)?
-- [ ] Set the PR to **allow edits from contributors**?
+- [ ] Read all the comments in this template?
+- [ ] Ensure there is an issue open, or link relevant discord discussions?
+- [ ] Read the [contributing guidelines](https://pythondiscord.com/pages/contributing/contributing-guidelines/)?
diff --git a/bot/__init__.py b/bot/__init__.py
index bdb18666..71b7c8a3 100644
--- a/bot/__init__.py
+++ b/bot/__init__.py
@@ -2,11 +2,15 @@ import asyncio
 import logging
 import logging.handlers
 import os
+from functools import partial, partialmethod
 from pathlib import Path
 
 import arrow
+from discord.ext import commands
 
+from bot.command import Command
 from bot.constants import Client
+from bot.group import Group
 
 
 # Configure the "TRACE" logging level (e.g. "log.trace(message)")
@@ -56,6 +60,7 @@ if root.handlers:
 logging.getLogger("discord").setLevel(logging.ERROR)
 logging.getLogger("websockets").setLevel(logging.ERROR)
 logging.getLogger("PIL").setLevel(logging.ERROR)
+logging.getLogger("matplotlib").setLevel(logging.ERROR)
 
 # Setup new logging configuration
 logging.basicConfig(
@@ -70,3 +75,12 @@ logging.getLogger().info('Logging initialization complete')
 # On Windows, the selector event loop is required for aiodns.
 if os.name == "nt":
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+
+# Monkey-patch discord.py decorators to use the both the Command and Group subclasses which supports root aliases.
+# Must be patched before any cogs are added.
+commands.command = partial(commands.command, cls=Command)
+commands.GroupMixin.command = partialmethod(commands.GroupMixin.command, cls=Command)
+
+commands.group = partial(commands.group, cls=Group)
+commands.GroupMixin.group = partialmethod(commands.GroupMixin.group, cls=Group)
diff --git a/bot/bot.py b/bot/bot.py
index e9750697..7e495940 100644
--- a/bot/bot.py
+++ b/bot/bot.py
@@ -64,6 +64,26 @@ class Bot(commands.Bot):
         super().add_cog(cog)
         log.info(f"Cog loaded: {cog.qualified_name}")
 
+    def add_command(self, command: commands.Command) -> None:
+        """Add `command` as normal and then add its root aliases to the bot."""
+        super().add_command(command)
+        self._add_root_aliases(command)
+
+    def remove_command(self, name: str) -> Optional[commands.Command]:
+        """
+        Remove a command/alias as normal and then remove its root aliases from the bot.
+
+        Individual root aliases cannot be removed by this function.
+        To remove them, either remove the entire command or manually edit `bot.all_commands`.
+        """
+        command = super().remove_command(name)
+        if command is None:
+            # Even if it's a root alias, there's no way to get the Bot instance to remove the alias.
+            return
+
+        self._remove_root_aliases(command)
+        return command
+
     async def on_command_error(self, context: commands.Context, exception: DiscordException) -> None:
         """Check command errors for UserInputError and reset the cooldown if thrown."""
         if isinstance(exception, commands.UserInputError):
@@ -139,6 +159,27 @@ class Bot(commands.Bot):
         """
         await self._guild_available.wait()
 
+    def _add_root_aliases(self, command: commands.Command) -> None:
+        """Recursively add root aliases for `command` and any of its subcommands."""
+        if isinstance(command, commands.Group):
+            for subcommand in command.commands:
+                self._add_root_aliases(subcommand)
+
+        for alias in getattr(command, "root_aliases", ()):
+            if alias in self.all_commands:
+                raise commands.CommandRegistrationError(alias, alias_conflict=True)
+
+            self.all_commands[alias] = command
+
+    def _remove_root_aliases(self, command: commands.Command) -> None:
+        """Recursively remove root aliases for `command` and any of its subcommands."""
+        if isinstance(command, commands.Group):
+            for subcommand in command.commands:
+                self._remove_root_aliases(subcommand)
+
+        for alias in getattr(command, "root_aliases", ()):
+            self.all_commands.pop(alias, None)
+
 
 _allowed_roles = [discord.Object(id_) for id_ in constants.MODERATION_ROLES]
 
diff --git a/bot/command.py b/bot/command.py
new file mode 100644
index 00000000..0fb900f7
--- /dev/null
+++ b/bot/command.py
@@ -0,0 +1,18 @@
+from discord.ext import commands
+
+
+class Command(commands.Command):
+    """
+    A `discord.ext.commands.Command` subclass which supports root aliases.
+
+    A `root_aliases` keyword argument is added, which is a sequence of alias names that will act as
+    top-level commands rather than being aliases of the command's group. It's stored as an attribute
+    also named `root_aliases`.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.root_aliases = kwargs.get("root_aliases", [])
+
+        if not isinstance(self.root_aliases, (list, tuple)):
+            raise TypeError("Root aliases of a command must be a list or a tuple of strings.")
diff --git a/bot/constants.py b/bot/constants.py
index a64882db..6cbfa8db 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -8,6 +8,7 @@ from typing import Dict, NamedTuple
 __all__ = (
     "AdventOfCode",
     "Branding",
+    "Cats",
     "Channels",
     "Categories",
     "Client",
@@ -93,6 +94,10 @@ class Branding:
     cycle_frequency = int(environ.get("CYCLE_FREQUENCY", 3))  # 0: never, 1: every day, 2: every other day, ...
 
 
+class Cats:
+    cats = ["ᓚᘏᗢ", "ᘡᘏᗢ", "🐈", "ᓕᘏᗢ", "ᓇᘏᗢ", "ᓂᘏᗢ", "ᘣᘏᗢ", "ᕦᘏᗢ", "ᕂᘏᗢ"]
+
+
 class Channels(NamedTuple):
     advent_of_code = int(environ.get("AOC_CHANNEL_ID", 782715290437943306))
     advent_of_code_commands = int(environ.get("AOC_COMMANDS_CHANNEL_ID", 607247579608121354))
@@ -147,8 +152,25 @@ class Colours:
     python_yellow = 0xFFD43B
     grass_green = 0x66ff00
 
+    easter_like_colours = [
+        (255, 247, 0),
+        (255, 255, 224),
+        (0, 255, 127),
+        (189, 252, 201),
+        (255, 192, 203),
+        (255, 160, 122),
+        (181, 115, 220),
+        (221, 160, 221),
+        (200, 162, 200),
+        (238, 130, 238),
+        (135, 206, 235),
+        (0, 204, 204),
+        (64, 224, 208),
+    ]
+
 
 class Emojis:
+    cross_mark = "\u274C"
     star = "\u2B50"
     christmas_tree = "\U0001F384"
     check = "\u2611"
diff --git a/bot/exts/easter/avatar_easterifier.py b/bot/exts/easter/avatar_easterifier.py
deleted file mode 100644
index 8e8a3500..00000000
--- a/bot/exts/easter/avatar_easterifier.py
+++ /dev/null
@@ -1,128 +0,0 @@
-import asyncio
-import logging
-from io import BytesIO
-from pathlib import Path
-from typing import Tuple, Union
-
-import discord
-from PIL import Image
-from PIL.ImageOps import posterize
-from discord.ext import commands
-
-log = logging.getLogger(__name__)
-
-COLOURS = [
-    (255, 247, 0), (255, 255, 224), (0, 255, 127), (189, 252, 201), (255, 192, 203),
-    (255, 160, 122), (181, 115, 220), (221, 160, 221), (200, 162, 200), (238, 130, 238),
-    (135, 206, 235), (0, 204, 204), (64, 224, 208)
-]  # Pastel colours - Easter-like
-
-
-class AvatarEasterifier(commands.Cog):
-    """Put an Easter spin on your avatar or image!"""
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-
-    @staticmethod
-    def closest(x: Tuple[int, int, int]) -> Tuple[int, int, int]:
-        """
-        Finds the closest easter colour to a given pixel.
-
-        Returns a merge between the original colour and the closest colour
-        """
-        r1, g1, b1 = x
-
-        def distance(point: Tuple[int, int, int]) -> Tuple[int, int, int]:
-            """Finds the difference between a pastel colour and the original pixel colour."""
-            r2, g2, b2 = point
-            return ((r1 - r2)**2 + (g1 - g2)**2 + (b1 - b2)**2)
-
-        closest_colours = sorted(COLOURS, key=lambda point: distance(point))
-        r2, g2, b2 = closest_colours[0]
-        r = (r1 + r2) // 2
-        g = (g1 + g2) // 2
-        b = (b1 + b2) // 2
-
-        return (r, g, b)
-
-    @commands.command(pass_context=True, aliases=["easterify"])
-    async def avatareasterify(self, ctx: commands.Context, *colours: Union[discord.Colour, str]) -> None:
-        """
-        This "Easterifies" the user's avatar.
-
-        Given colours will produce a personalised egg in the corner, similar to the egg_decorate command.
-        If colours are not given, a nice little chocolate bunny will sit in the corner.
-        Colours are split by spaces, unless you wrap the colour name in double quotes.
-        Discord colour names, HTML colour names, XKCD colour names and hex values are accepted.
-        """
-        async def send(*args, **kwargs) -> str:
-            """
-            This replaces the original ctx.send.
-
-            When invoking the egg decorating command, the egg itself doesn't print to to the channel.
-            Returns the message content so that if any errors occur, the error message can be output.
-            """
-            if args:
-                return args[0]
-
-        async with ctx.typing():
-
-            # Grabs image of avatar
-            image_bytes = await ctx.author.avatar_url_as(size=256).read()
-
-            old = Image.open(BytesIO(image_bytes))
-            old = old.convert("RGBA")
-
-            # Grabs alpha channel since posterize can't be used with an RGBA image.
-            alpha = old.getchannel("A").getdata()
-            old = old.convert("RGB")
-            old = posterize(old, 6)
-
-            data = old.getdata()
-            setted_data = set(data)
-            new_d = {}
-
-            for x in setted_data:
-                new_d[x] = self.closest(x)
-                await asyncio.sleep(0)  # Ensures discord doesn't break in the background.
-            new_data = [(*new_d[x], alpha[i]) if x in new_d else x for i, x in enumerate(data)]
-
-            im = Image.new("RGBA", old.size)
-            im.putdata(new_data)
-
-            if colours:
-                send_message = ctx.send
-                ctx.send = send  # Assigns ctx.send to a fake send
-                egg = await ctx.invoke(self.bot.get_command("eggdecorate"), *colours)
-                if isinstance(egg, str):  # When an error message occurs in eggdecorate.
-                    return await send_message(egg)
-
-                ratio = 64 / egg.height
-                egg = egg.resize((round(egg.width * ratio), round(egg.height * ratio)))
-                egg = egg.convert("RGBA")
-                im.alpha_composite(egg, (im.width - egg.width, (im.height - egg.height)//2))  # Right centre.
-                ctx.send = send_message  # Reassigns ctx.send
-            else:
-                bunny = Image.open(Path("bot/resources/easter/chocolate_bunny.png"))
-                im.alpha_composite(bunny, (im.width - bunny.width, (im.height - bunny.height)//2))  # Right centre.
-
-            bufferedio = BytesIO()
-            im.save(bufferedio, format="PNG")
-
-            bufferedio.seek(0)
-
-            file = discord.File(bufferedio, filename="easterified_avatar.png")  # Creates file to be used in embed
-            embed = discord.Embed(
-                name="Your Lovely Easterified Avatar",
-                description="Here is your lovely avatar, all bright and colourful\nwith Easter pastel colours. Enjoy :D"
-            )
-            embed.set_image(url="attachment://easterified_avatar.png")
-            embed.set_footer(text=f"Made by {ctx.author.display_name}", icon_url=ctx.author.avatar_url)
-
-        await ctx.send(file=file, embed=embed)
-
-
-def setup(bot: commands.Bot) -> None:
-    """Avatar Easterifier Cog load."""
-    bot.add_cog(AvatarEasterifier(bot))
diff --git a/bot/exts/easter/egg_decorating.py b/bot/exts/easter/egg_decorating.py
index b18e6636..a847388d 100644
--- a/bot/exts/easter/egg_decorating.py
+++ b/bot/exts/easter/egg_decorating.py
@@ -10,6 +10,8 @@ import discord
 from PIL import Image
 from discord.ext import commands
 
+from bot.utils import helpers
+
 log = logging.getLogger(__name__)
 
 with open(Path("bot/resources/evergreen/html_colours.json"), encoding="utf8") as f:
@@ -65,7 +67,7 @@ class EggDecorating(commands.Cog):
             if value:
                 colours[idx] = discord.Colour(value)
             else:
-                invalid.append(colour)
+                invalid.append(helpers.suppress_links(colour))
 
         if len(invalid) > 1:
             return await ctx.send(f"Sorry, I don't know these colours: {' '.join(invalid)}")
diff --git a/bot/exts/evergreen/8bitify.py b/bot/exts/evergreen/8bitify.py
deleted file mode 100644
index 09a3eb5c..00000000
--- a/bot/exts/evergreen/8bitify.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from io import BytesIO
-
-import discord
-from PIL import Image
-from discord.ext import commands
-
-from bot.bot import Bot
-
-
-class EightBitify(commands.Cog):
-    """Make your avatar 8bit!"""
-
-    def __init__(self, bot: Bot) -> None:
-        self.bot = bot
-
-    @staticmethod
-    def pixelate(image: Image) -> Image:
-        """Takes an image and pixelates it."""
-        return image.resize((32, 32), resample=Image.NEAREST).resize((1024, 1024), resample=Image.NEAREST)
-
-    @staticmethod
-    def quantize(image: Image) -> Image:
-        """Reduces colour palette to 256 colours."""
-        return image.quantize()
-
-    @commands.command(name="8bitify")
-    async def eightbit_command(self, ctx: commands.Context) -> None:
-        """Pixelates your avatar and changes the palette to an 8bit one."""
-        async with ctx.typing():
-            author = await self.bot.fetch_user(ctx.author.id)
-            image_bytes = await author.avatar_url.read()
-            avatar = Image.open(BytesIO(image_bytes))
-            avatar = avatar.convert("RGBA").resize((1024, 1024))
-
-            eightbit = self.pixelate(avatar)
-            eightbit = self.quantize(eightbit)
-
-            bufferedio = BytesIO()
-            eightbit.save(bufferedio, format="PNG")
-            bufferedio.seek(0)
-
-            file = discord.File(bufferedio, filename="8bitavatar.png")
-
-            embed = discord.Embed(
-                title="Your 8-bit avatar",
-                description='Here is your avatar. I think it looks all cool and "retro"'
-            )
-
-            embed.set_image(url="attachment://8bitavatar.png")
-            embed.set_footer(text=f"Made by {ctx.author.display_name}", icon_url=ctx.author.avatar_url)
-
-        await ctx.send(file=file, embed=embed)
-
-
-def setup(bot: Bot) -> None:
-    """Cog the EightBitify load."""
-    bot.add_cog(EightBitify(bot))
diff --git a/bot/exts/evergreen/avatar_modification/__init__.py b/bot/exts/evergreen/avatar_modification/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/bot/exts/evergreen/avatar_modification/__init__.py
diff --git a/bot/exts/evergreen/avatar_modification/_effects.py b/bot/exts/evergreen/avatar_modification/_effects.py
new file mode 100644
index 00000000..e415d700
--- /dev/null
+++ b/bot/exts/evergreen/avatar_modification/_effects.py
@@ -0,0 +1,139 @@
+import typing as t
+from io import BytesIO
+from pathlib import Path
+
+import discord
+from PIL import Image, ImageDraw, ImageOps
+
+from bot.constants import Colours
+
+
+class PfpEffects:
+    """
+    Implements various image modifying effects, for the PfpModify cog.
+
+    All of these fuctions are slow, and blocking, so they should be ran in executors.
+    """
+
+    @staticmethod
+    def apply_effect(image_bytes: bytes, effect: t.Callable, filename: str, *args) -> discord.File:
+        """Applies the given effect to the image passed to it."""
+        im = Image.open(BytesIO(image_bytes))
+        im = im.convert("RGBA")
+        im = effect(im, *args)
+
+        bufferedio = BytesIO()
+        im.save(bufferedio, format="PNG")
+        bufferedio.seek(0)
+
+        return discord.File(bufferedio, filename=filename)
+
+    @staticmethod
+    def closest(x: t.Tuple[int, int, int]) -> t.Tuple[int, int, int]:
+        """
+        Finds the closest "easter" colour to a given pixel.
+
+        Returns a merge between the original colour and the closest colour.
+        """
+        r1, g1, b1 = x
+
+        def distance(point: t.Tuple[int, int, int]) -> t.Tuple[int, int, int]:
+            """Finds the difference between a pastel colour and the original pixel colour."""
+            r2, g2, b2 = point
+            return (r1 - r2) ** 2 + (g1 - g2) ** 2 + (b1 - b2) ** 2
+
+        closest_colours = sorted(Colours.easter_like_colours, key=distance)
+        r2, g2, b2 = closest_colours[0]
+        r = (r1 + r2) // 2
+        g = (g1 + g2) // 2
+        b = (b1 + b2) // 2
+
+        return r, g, b
+
+    @staticmethod
+    def crop_avatar_circle(avatar: Image) -> Image:
+        """This crops the avatar given into a circle."""
+        mask = Image.new("L", avatar.size, 0)
+        draw = ImageDraw.Draw(mask)
+        draw.ellipse((0, 0) + avatar.size, fill=255)
+        avatar.putalpha(mask)
+        return avatar
+
+    @staticmethod
+    def crop_ring(ring: Image, px: int) -> Image:
+        """This crops the given ring into a circle."""
+        mask = Image.new("L", ring.size, 0)
+        draw = ImageDraw.Draw(mask)
+        draw.ellipse((0, 0) + ring.size, fill=255)
+        draw.ellipse((px, px, 1024-px, 1024-px), fill=0)
+        ring.putalpha(mask)
+        return ring
+
+    @staticmethod
+    def pridify_effect(image: Image, pixels: int, flag: str) -> Image:
+        """Applies the given pride effect to the given image."""
+        image = image.resize((1024, 1024))
+        image = PfpEffects.crop_avatar_circle(image)
+
+        ring = Image.open(Path(f"bot/resources/pride/flags/{flag}.png")).resize((1024, 1024))
+        ring = ring.convert("RGBA")
+        ring = PfpEffects.crop_ring(ring, pixels)
+
+        image.alpha_composite(ring, (0, 0))
+        return image
+
+    @staticmethod
+    def eight_bitify_effect(image: Image) -> Image:
+        """
+        Applies the 8bit effect to the given image.
+
+        This is done by reducing the image to 32x32 and then back up to 1024x1024.
+        We then quantize the image before returning too.
+        """
+        image = image.resize((32, 32), resample=Image.NEAREST)
+        image = image.resize((1024, 1024), resample=Image.NEAREST)
+        return image.quantize()
+
+    @staticmethod
+    def easterify_effect(image: Image, overlay_image: Image = None) -> Image:
+        """
+        Applies the easter effect to the given image.
+
+        This is done by getting the closest "easter" colour to each pixel and changing the colour
+        to the half-way RGBvalue.
+
+        We also then add an overlay image on top in middle right, a chocolate bunny by default.
+        """
+        if overlay_image:
+            ratio = 64 / overlay_image.height
+            overlay_image = overlay_image.resize((
+                round(overlay_image.width * ratio),
+                round(overlay_image.height * ratio)
+            ))
+            overlay_image = overlay_image.convert("RGBA")
+        else:
+            overlay_image = Image.open(Path("bot/resources/easter/chocolate_bunny.png"))
+
+        alpha = image.getchannel("A").getdata()
+        image = image.convert("RGB")
+        image = ImageOps.posterize(image, 6)
+
+        data = image.getdata()
+        data_set = set(data)
+        easterified_data_set = {}
+
+        for x in data_set:
+            easterified_data_set[x] = PfpEffects.closest(x)
+        new_pixel_data = [
+            (*easterified_data_set[x], alpha[i])
+            if x in easterified_data_set else x
+            for i, x in enumerate(data)
+        ]
+
+        im = Image.new("RGBA", image.size)
+        im.putdata(new_pixel_data)
+        im.alpha_composite(
+            overlay_image,
+            (im.width - overlay_image.width, (im.height - overlay_image.height) // 2)
+        )
+        return im
diff --git a/bot/exts/evergreen/avatar_modification/avatar_modify.py b/bot/exts/evergreen/avatar_modification/avatar_modify.py
new file mode 100644
index 00000000..0baee8b2
--- /dev/null
+++ b/bot/exts/evergreen/avatar_modification/avatar_modify.py
@@ -0,0 +1,314 @@
+import asyncio
+import json
+import logging
+import string
+import typing as t
+import unicodedata
+from concurrent.futures import ThreadPoolExecutor
+
+import discord
+from aiohttp import client_exceptions
+from discord.ext import commands
+from discord.ext.commands.errors import BadArgument
+
+from bot.constants import Client, Colours, Emojis
+from bot.exts.evergreen.avatar_modification._effects import PfpEffects
+from bot.utils.extensions import invoke_help_command
+from bot.utils.halloween import spookifications
+
+log = logging.getLogger(__name__)
+
+_EXECUTOR = ThreadPoolExecutor(10)
+
+FILENAME_STRING = "{effect}_{author}.png"
+
+with open("bot/resources/pride/gender_options.json") as f:
+    GENDER_OPTIONS = json.load(f)
+
+
+async def in_executor(func: t.Callable, *args) -> t.Any:
+    """
+    Runs the given synchronus function `func` in an executor.
+
+    This is useful for running slow, blocking code within async
+    functions, so that they don't block the bot.
+    """
+    log.trace(f"Running {func.__name__} in an executor.")
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(_EXECUTOR, func, *args)
+
+
+def file_safe_name(effect: str, display_name: str) -> str:
+    """Returns a file safe filename based on the given effect and display name."""
+    valid_filename_chars = f"-_. {string.ascii_letters}{string.digits}"
+
+    file_name = FILENAME_STRING.format(effect=effect, author=display_name)
+
+    # Replace spaces
+    file_name = file_name.replace(" ", "_")
+
+    # Normalize unicode characters
+    cleaned_filename = unicodedata.normalize("NFKD", file_name).encode("ASCII", "ignore").decode()
+
+    # Remove invalid filename characters
+    cleaned_filename = "".join(c for c in cleaned_filename if c in valid_filename_chars)
+    return cleaned_filename
+
+
+class AvatarModify(commands.Cog):
+    """Various commands for users to apply affects to their own avatars."""
+
+    def __init__(self, bot: commands.Bot) -> None:
+        self.bot = bot
+
+    async def _fetch_member(self, member_id: int) -> t.Optional[discord.Member]:
+        """
+        Fetches a member and handles errors.
+
+        This helper funciton is required as the member cache doesn't always have the most up to date
+        profile picture. This can lead to errors if the image is delted from the Discord CDN.
+        """
+        try:
+            member = await self.bot.get_guild(Client.guild).fetch_member(member_id)
+        except discord.errors.NotFound:
+            log.debug(f"Member {member_id} left the guild before we could get their pfp.")
+            return None
+        except discord.HTTPException:
+            log.exception(f"Exception while trying to retrieve member {member_id} from Discord.")
+            return None
+
+        return member
+
+    @commands.group(aliases=("avatar_mod", "pfp_mod", "avatarmod", "pfpmod"))
+    async def avatar_modify(self, ctx: commands.Context) -> None:
+        """Groups all of the pfp modifying commands to allow a single concurrency limit."""
+        if not ctx.invoked_subcommand:
+            await invoke_help_command(ctx)
+
+    @avatar_modify.command(name="8bitify", root_aliases=("8bitify",))
+    async def eightbit_command(self, ctx: commands.Context) -> None:
+        """Pixelates your avatar and changes the palette to an 8bit one."""
+        async with ctx.typing():
+            member = await self._fetch_member(ctx.author.id)
+            if not member:
+                await ctx.send(f"{Emojis.cross_mark} Could not get member info.")
+                return
+
+            image_bytes = await member.avatar_url.read()
+            file_name = file_safe_name("eightbit_avatar", member.display_name)
+
+            file = await in_executor(
+                PfpEffects.apply_effect,
+                image_bytes,
+                PfpEffects.eight_bitify_effect,
+                file_name
+            )
+
+            embed = discord.Embed(
+                title="Your 8-bit avatar",
+                description="Here is your avatar. I think it looks all cool and 'retro'."
+            )
+
+            embed.set_image(url=f"attachment://{file_name}")
+            embed.set_footer(text=f"Made by {member.display_name}.", icon_url=member.avatar_url)
+
+        await ctx.send(embed=embed, file=file)
+
+    @avatar_modify.command(aliases=("easterify",), root_aliases=("easterify", "avatareasterify"))
+    async def avatareasterify(self, ctx: commands.Context, *colours: t.Union[discord.Colour, str]) -> None:
+        """
+        This "Easterifies" the user's avatar.
+
+        Given colours will produce a personalised egg in the corner, similar to the egg_decorate command.
+        If colours are not given, a nice little chocolate bunny will sit in the corner.
+        Colours are split by spaces, unless you wrap the colour name in double quotes.
+        Discord colour names, HTML colour names, XKCD colour names and hex values are accepted.
+        """
+        async def send(*args, **kwargs) -> str:
+            """
+            This replaces the original ctx.send.
+
+            When invoking the egg decorating command, the egg itself doesn't print to to the channel.
+            Returns the message content so that if any errors occur, the error message can be output.
+            """
+            if args:
+                return args[0]
+
+        async with ctx.typing():
+            member = await self._fetch_member(ctx.author.id)
+            if not member:
+                await ctx.send(f"{Emojis.cross_mark} Could not get member info.")
+                return
+
+            egg = None
+            if colours:
+                send_message = ctx.send
+                ctx.send = send  # Assigns ctx.send to a fake send
+                egg = await ctx.invoke(self.bot.get_command("eggdecorate"), *colours)
+                if isinstance(egg, str):  # When an error message occurs in eggdecorate.
+                    await send_message(egg)
+                    return
+                ctx.send = send_message  # Reassigns ctx.send
+
+            image_bytes = await member.avatar_url_as(size=256).read()
+            file_name = file_safe_name("easterified_avatar", member.display_name)
+
+            file = await in_executor(
+                PfpEffects.apply_effect,
+                image_bytes,
+                PfpEffects.easterify_effect,
+                file_name,
+                egg
+            )
+
+            embed = discord.Embed(
+                name="Your Lovely Easterified Avatar!",
+                description="Here is your lovely avatar, all bright and colourful\nwith Easter pastel colours. Enjoy :D"
+            )
+            embed.set_image(url=f"attachment://{file_name}")
+            embed.set_footer(text=f"Made by {member.display_name}.", icon_url=member.avatar_url)
+
+        await ctx.send(file=file, embed=embed)
+
+    @staticmethod
+    async def send_pride_image(
+        ctx: commands.Context,
+        image_bytes: bytes,
+        pixels: int,
+        flag: str,
+        option: str
+    ) -> None:
+        """Gets and sends the image in an embed. Used by the pride commands."""
+        async with ctx.typing():
+            file_name = file_safe_name("pride_avatar", ctx.author.display_name)
+
+            file = await in_executor(
+                PfpEffects.apply_effect,
+                image_bytes,
+                PfpEffects.pridify_effect,
+                file_name,
+                pixels,
+                flag
+            )
+
+            embed = discord.Embed(
+                name="Your Lovely Pride Avatar!",
+                description=f"Here is your lovely avatar, surrounded by\n a beautiful {option} flag. Enjoy :D"
+            )
+            embed.set_image(url=f"attachment://{file_name}")
+            embed.set_footer(text=f"Made by {ctx.author.display_name}.", icon_url=ctx.author.avatar_url)
+            await ctx.send(file=file, embed=embed)
+
+    @avatar_modify.group(
+        aliases=("avatarpride", "pridepfp", "prideprofile"),
+        root_aliases=("prideavatar", "avatarpride", "pridepfp", "prideprofile"),
+        invoke_without_command=True
+    )
+    async def prideavatar(self, ctx: commands.Context, option: str = "lgbt", pixels: int = 64) -> None:
+        """
+        This surrounds an avatar with a border of a specified LGBT flag.
+
+        This defaults to the LGBT rainbow flag if none is given.
+        The amount of pixels can be given which determines the thickness of the flag border.
+        This has a maximum of 512px and defaults to a 64px border.
+        The full image is 1024x1024.
+        """
+        option = option.lower()
+        pixels = max(0, min(512, pixels))
+        flag = GENDER_OPTIONS.get(option)
+        if flag is None:
+            await ctx.send("I don't have that flag!")
+            return
+
+        async with ctx.typing():
+            member = await self._fetch_member(ctx.author.id)
+            if not member:
+                await ctx.send(f"{Emojis.cross_mark} Could not get member info.")
+                return
+            image_bytes = await member.avatar_url_as(size=1024).read()
+            await self.send_pride_image(ctx, image_bytes, pixels, flag, option)
+
+    @prideavatar.command()
+    async def image(self, ctx: commands.Context, url: str, option: str = "lgbt", pixels: int = 64) -> None:
+        """
+        This surrounds the image specified by the URL with a border of a specified LGBT flag.
+
+        This defaults to the LGBT rainbow flag if none is given.
+        The amount of pixels can be given which determines the thickness of the flag border.
+        This has a maximum of 512px and defaults to a 64px border.
+        The full image is 1024x1024.
+        """
+        option = option.lower()
+        pixels = max(0, min(512, pixels))
+        flag = GENDER_OPTIONS.get(option)
+        if flag is None:
+            await ctx.send("I don't have that flag!")
+            return
+
+        async with ctx.typing():
+            try:
+                async with self.bot.http_session.get(url) as response:
+                    if response.status != 200:
+                        await ctx.send("Bad response from provided URL!")
+                        return
+                    image_bytes = await response.read()
+            except client_exceptions.ClientConnectorError:
+                raise BadArgument("Cannot connect to provided URL!")
+            except client_exceptions.InvalidURL:
+                raise BadArgument("Invalid URL!")
+
+            await self.send_pride_image(ctx, image_bytes, pixels, flag, option)
+
+    @prideavatar.command()
+    async def flags(self, ctx: commands.Context) -> None:
+        """This lists the flags that can be used with the prideavatar command."""
+        choices = sorted(set(GENDER_OPTIONS.values()))
+        options = "• " + "\n• ".join(choices)
+        embed = discord.Embed(
+            title="I have the following flags:",
+            description=options,
+            colour=Colours.soft_red
+        )
+        await ctx.send(embed=embed)
+
+    @avatar_modify.command(
+        aliases=("savatar", "spookify"),
+        root_aliases=("spookyavatar", "spookify", "savatar"),
+        brief="Spookify an user's avatar."
+    )
+    async def spookyavatar(self, ctx: commands.Context, member: discord.Member = None) -> None:
+        """This "spookifies" the given user's avatar, with a random *spooky* effect."""
+        if member is None:
+            member = ctx.author
+
+        member = await self._fetch_member(member.id)
+        if not member:
+            await ctx.send(f"{Emojis.cross_mark} Could not get member info.")
+            return
+
+        async with ctx.typing():
+            image_bytes = await member.avatar_url.read()
+
+            file_name = file_safe_name("spooky_avatar", member.display_name)
+
+            file = await in_executor(
+                PfpEffects.apply_effect,
+                image_bytes,
+                spookifications.get_random_effect,
+                file_name
+            )
+
+            embed = discord.Embed(
+                title="Is this you or am I just really paranoid?",
+                colour=Colours.soft_red
+            )
+            embed.set_author(name=member.name, icon_url=member.avatar_url)
+            embed.set_image(url=f"attachment://{file_name}")
+            embed.set_footer(text=f"Made by {ctx.author.display_name}.", icon_url=ctx.author.avatar_url)
+
+            await ctx.send(file=file, embed=embed)
+
+
+def setup(bot: commands.Bot) -> None:
+    """Load the PfpModify cog."""
+    bot.add_cog(AvatarModify(bot))
diff --git a/bot/exts/evergreen/catify.py b/bot/exts/evergreen/catify.py
new file mode 100644
index 00000000..d8a7442d
--- /dev/null
+++ b/bot/exts/evergreen/catify.py
@@ -0,0 +1,87 @@
+import random
+from contextlib import suppress
+from typing import Optional
+
+from discord import AllowedMentions, Embed, Forbidden
+from discord.ext import commands
+
+from bot.constants import Cats, Colours, NEGATIVE_REPLIES
+from bot.utils import helpers
+
+
+class Catify(commands.Cog):
+    """Cog for the catify command."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.command(aliases=["ᓚᘏᗢify", "ᓚᘏᗢ"])
+    async def catify(self, ctx: commands.Context, *, text: Optional[str]) -> None:
+        """
+        Convert the provided text into a cat themed sentence by interspercing cats throughout text.
+
+        If no text is given then the users nickname is edited.
+        """
+        if not text:
+            display_name = ctx.author.display_name
+
+            if len(display_name) > 26:
+                embed = Embed(
+                    title=random.choice(NEGATIVE_REPLIES),
+                    description=(
+                        "Your display name is too long to be catified! "
+                        "Please change it to be under 26 characters."
+                    ),
+                    color=Colours.soft_red
+                )
+                await ctx.send(embed=embed)
+                return
+
+            else:
+                display_name += f" | {random.choice(Cats.cats)}"
+
+                await ctx.send(f"Your catified nickname is: `{display_name}`", allowed_mentions=AllowedMentions.none())
+
+                with suppress(Forbidden):
+                    await ctx.author.edit(nick=display_name)
+        else:
+            if len(text) >= 1500:
+                embed = Embed(
+                    title=random.choice(NEGATIVE_REPLIES),
+                    description="Submitted text was too large! Please submit something under 1500 characters.",
+                    color=Colours.soft_red
+                )
+                await ctx.send(embed=embed)
+                return
+
+            string_list = text.split()
+            for index, name in enumerate(string_list):
+                name = name.lower()
+                if "cat" in name:
+                    if random.randint(0, 5) == 5:
+                        string_list[index] = name.replace("cat", f"**{random.choice(Cats.cats)}**")
+                    else:
+                        string_list[index] = name.replace("cat", random.choice(Cats.cats))
+                for element in Cats.cats:
+                    if element in name:
+                        string_list[index] = name.replace(element, "cat")
+
+            string_len = len(string_list) // 3 or len(string_list)
+
+            for _ in range(random.randint(1, string_len)):
+                # insert cat at random index
+                if random.randint(0, 5) == 5:
+                    string_list.insert(random.randint(0, len(string_list)), f"**{random.choice(Cats.cats)}**")
+                else:
+                    string_list.insert(random.randint(0, len(string_list)), random.choice(Cats.cats))
+
+            text = helpers.suppress_links(" ".join(string_list))
+            await ctx.send(
+                f">>> {text}",
+                allowed_mentions=AllowedMentions.none()
+            )
+
+
+def setup(bot: commands.Bot) -> None:
+    """Loads the catify cog."""
+    bot.add_cog(Catify(bot))
diff --git a/bot/exts/evergreen/fun.py b/bot/exts/evergreen/fun.py
index c7b0d7d9..ed51358c 100644
--- a/bot/exts/evergreen/fun.py
+++ b/bot/exts/evergreen/fun.py
@@ -12,6 +12,7 @@ from discord.ext.commands import BadArgument, Cog, Context, MessageConverter, cl
 from bot import utils
 from bot.bot import Bot
 from bot.constants import Client, Colours, Emojis
+from bot.utils import helpers
 
 log = logging.getLogger(__name__)
 
@@ -84,6 +85,7 @@ class Fun(Cog):
         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('> ')}"
@@ -102,6 +104,7 @@ class Fun(Cog):
         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('> ')}"
diff --git a/bot/exts/evergreen/help.py b/bot/exts/evergreen/help.py
index 91147243..f557e42e 100644
--- a/bot/exts/evergreen/help.py
+++ b/bot/exts/evergreen/help.py
@@ -289,7 +289,9 @@ class HelpSession:
             parent = self.query.full_parent_name + ' ' if self.query.parent else ''
             paginator.add_line(f'**```{prefix}{parent}{signature}```**')
 
-            aliases = ', '.join(f'`{a}`' for a 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:
                 paginator.add_line(f'**Can also use:** {aliases}\n')
 
diff --git a/bot/exts/evergreen/reddit.py b/bot/exts/evergreen/reddit.py
index ce22a864..518ffeb7 100644
--- a/bot/exts/evergreen/reddit.py
+++ b/bot/exts/evergreen/reddit.py
@@ -55,16 +55,16 @@ class Reddit(commands.Cog):
         if not posts:
             return await ctx.send('No posts available!')
 
-        if posts[1]["data"]["over_18"] is True:
+        if posts[0]["data"]["over_18"] is True:
             return await ctx.send(
-                "You cannot access this Subreddit as it is ment for those who "
+                "You cannot access this Subreddit as it is meant for those who "
                 "are 18 years or older."
             )
 
         embed_titles = ""
 
         # Chooses k unique random elements from a population sequence or set.
-        random_posts = random.sample(posts, k=5)
+        random_posts = random.sample(posts, k=min(len(posts), 5))
 
         # -----------------------------------------------------------
         # This code below is bound of change when the emojis are added.
diff --git a/bot/exts/halloween/spookyavatar.py b/bot/exts/halloween/spookyavatar.py
deleted file mode 100644
index 2d7df678..00000000
--- a/bot/exts/halloween/spookyavatar.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import logging
-import os
-from io import BytesIO
-
-import aiohttp
-import discord
-from PIL import Image
-from discord.ext import commands
-
-from bot.utils.halloween import spookifications
-
-log = logging.getLogger(__name__)
-
-
-class SpookyAvatar(commands.Cog):
-    """A cog that spookifies an avatar."""
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-
-    async def get(self, url: str) -> bytes:
-        """Returns the contents of the supplied URL."""
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url) as resp:
-                return await resp.read()
-
-    @commands.command(name='savatar', aliases=('spookyavatar', 'spookify'),
-                      brief='Spookify an user\'s avatar.')
-    async def spooky_avatar(self, ctx: commands.Context, user: discord.Member = None) -> None:
-        """A command to print the user's spookified avatar."""
-        if user is None:
-            user = ctx.message.author
-
-        async with ctx.typing():
-            embed = discord.Embed(colour=0xFF0000)
-            embed.title = "Is this you or am I just really paranoid?"
-            embed.set_author(name=str(user.name), icon_url=user.avatar_url)
-
-            image_bytes = await ctx.author.avatar_url.read()
-            im = Image.open(BytesIO(image_bytes))
-            modified_im = spookifications.get_random_effect(im)
-            modified_im.save(str(ctx.message.id)+'.png')
-            f = discord.File(str(ctx.message.id)+'.png')
-            embed.set_image(url='attachment://'+str(ctx.message.id)+'.png')
-
-        await ctx.send(file=f, embed=embed)
-        os.remove(str(ctx.message.id)+'.png')
-
-
-def setup(bot: commands.Bot) -> None:
-    """Spooky avatar Cog load."""
-    bot.add_cog(SpookyAvatar(bot))
diff --git a/bot/exts/pride/pride_avatar.py b/bot/exts/pride/pride_avatar.py
deleted file mode 100644
index 2eade796..00000000
--- a/bot/exts/pride/pride_avatar.py
+++ /dev/null
@@ -1,177 +0,0 @@
-import logging
-from io import BytesIO
-from pathlib import Path
-from typing import Tuple
-
-import aiohttp
-import discord
-from PIL import Image, ImageDraw, UnidentifiedImageError
-from discord.ext.commands import Bot, Cog, Context, group
-
-from bot.constants import Colours
-
-log = logging.getLogger(__name__)
-
-OPTIONS = {
-    "agender": "agender",
-    "androgyne": "androgyne",
-    "androgynous": "androgyne",
-    "aromantic": "aromantic",
-    "aro": "aromantic",
-    "ace": "asexual",
-    "asexual": "asexual",
-    "bigender": "bigender",
-    "bisexual": "bisexual",
-    "bi": "bisexual",
-    "demiboy": "demiboy",
-    "demigirl": "demigirl",
-    "demi": "demisexual",
-    "demisexual": "demisexual",
-    "gay": "gay",
-    "lgbt": "gay",
-    "queer": "gay",
-    "homosexual": "gay",
-    "fluid": "genderfluid",
-    "genderfluid": "genderfluid",
-    "genderqueer": "genderqueer",
-    "intersex": "intersex",
-    "lesbian": "lesbian",
-    "non-binary": "nonbinary",
-    "enby": "nonbinary",
-    "nb": "nonbinary",
-    "nonbinary": "nonbinary",
-    "omnisexual": "omnisexual",
-    "omni": "omnisexual",
-    "pansexual": "pansexual",
-    "pan": "pansexual",
-    "pangender": "pangender",
-    "poly": "polysexual",
-    "polysexual": "polysexual",
-    "polyamory": "polyamory",
-    "polyamorous": "polyamory",
-    "transgender": "transgender",
-    "trans": "transgender",
-    "trigender": "trigender"
-}
-
-
-class PrideAvatar(Cog):
-    """Put an LGBT spin on your avatar!"""
-
-    def __init__(self, bot: Bot):
-        self.bot = bot
-
-    @staticmethod
-    def crop_avatar(avatar: Image) -> Image:
-        """This crops the avatar into a circle."""
-        mask = Image.new("L", avatar.size, 0)
-        draw = ImageDraw.Draw(mask)
-        draw.ellipse((0, 0) + avatar.size, fill=255)
-        avatar.putalpha(mask)
-        return avatar
-
-    @staticmethod
-    def crop_ring(ring: Image, px: int) -> Image:
-        """This crops the ring into a circle."""
-        mask = Image.new("L", ring.size, 0)
-        draw = ImageDraw.Draw(mask)
-        draw.ellipse((0, 0) + ring.size, fill=255)
-        draw.ellipse((px, px, 1024-px, 1024-px), fill=0)
-        ring.putalpha(mask)
-        return ring
-
-    @staticmethod
-    def process_options(option: str, pixels: int) -> Tuple[str, int, str]:
-        """Does some shared preprocessing for the prideavatar commands."""
-        return option.lower(), max(0, min(512, pixels)), OPTIONS.get(option)
-
-    async def process_image(self, ctx: Context, image_bytes: bytes, pixels: int, flag: str, option: str) -> None:
-        """Constructs the final image, embeds it, and sends it."""
-        try:
-            avatar = Image.open(BytesIO(image_bytes))
-        except UnidentifiedImageError:
-            return await ctx.send("Cannot identify image from provided URL")
-        avatar = avatar.convert("RGBA").resize((1024, 1024))
-
-        avatar = self.crop_avatar(avatar)
-
-        ring = Image.open(Path(f"bot/resources/pride/flags/{flag}.png")).resize((1024, 1024))
-        ring = ring.convert("RGBA")
-        ring = self.crop_ring(ring, pixels)
-
-        avatar.alpha_composite(ring, (0, 0))
-        bufferedio = BytesIO()
-        avatar.save(bufferedio, format="PNG")
-        bufferedio.seek(0)
-
-        file = discord.File(bufferedio, filename="pride_avatar.png")  # Creates file to be used in embed
-        embed = discord.Embed(
-            name="Your Lovely Pride Avatar",
-            description=f"Here is your lovely avatar, surrounded by\n a beautiful {option} flag. Enjoy :D"
-        )
-        embed.set_image(url="attachment://pride_avatar.png")
-        embed.set_footer(text=f"Made by {ctx.author.display_name}", icon_url=ctx.author.avatar_url)
-        await ctx.send(file=file, embed=embed)
-
-    @group(aliases=["avatarpride", "pridepfp", "prideprofile"], invoke_without_command=True)
-    async def prideavatar(self, ctx: Context, option: str = "lgbt", pixels: int = 64) -> None:
-        """
-        This surrounds an avatar with a border of a specified LGBT flag.
-
-        This defaults to the LGBT rainbow flag if none is given.
-        The amount of pixels can be given which determines the thickness of the flag border.
-        This has a maximum of 512px and defaults to a 64px border.
-        The full image is 1024x1024.
-        """
-        option, pixels, flag = self.process_options(option, pixels)
-        if flag is None:
-            return await ctx.send("I don't have that flag!")
-
-        async with ctx.typing():
-            image_bytes = await ctx.author.avatar_url.read()
-            await self.process_image(ctx, image_bytes, pixels, flag, option)
-
-    @prideavatar.command()
-    async def image(self, ctx: Context, url: str, option: str = "lgbt", pixels: int = 64) -> None:
-        """
-        This surrounds the image specified by the URL with a border of a specified LGBT flag.
-
-        This defaults to the LGBT rainbow flag if none is given.
-        The amount of pixels can be given which determines the thickness of the flag border.
-        This has a maximum of 512px and defaults to a 64px border.
-        The full image is 1024x1024.
-        """
-        option, pixels, flag = self.process_options(option, pixels)
-        if flag is None:
-            return await ctx.send("I don't have that flag!")
-
-        async with ctx.typing():
-            async with aiohttp.ClientSession() as session:
-                try:
-                    response = await session.get(url)
-                except aiohttp.client_exceptions.ClientConnectorError:
-                    return await ctx.send("Cannot connect to provided URL!")
-                except aiohttp.client_exceptions.InvalidURL:
-                    return await ctx.send("Invalid URL!")
-                if response.status != 200:
-                    return await ctx.send("Bad response from provided URL!")
-                image_bytes = await response.read()
-                await self.process_image(ctx, image_bytes, pixels, flag, option)
-
-    @prideavatar.command()
-    async def flags(self, ctx: Context) -> None:
-        """This lists the flags that can be used with the prideavatar command."""
-        choices = sorted(set(OPTIONS.values()))
-        options = "• " + "\n• ".join(choices)
-        embed = discord.Embed(
-            title="I have the following flags:",
-            description=options,
-            colour=Colours.soft_red
-        )
-
-        await ctx.send(embed=embed)
-
-
-def setup(bot: Bot) -> None:
-    """Cog load."""
-    bot.add_cog(PrideAvatar(bot))
diff --git a/bot/group.py b/bot/group.py
new file mode 100644
index 00000000..a7bc59b7
--- /dev/null
+++ b/bot/group.py
@@ -0,0 +1,18 @@
+from discord.ext import commands
+
+
+class Group(commands.Group):
+    """
+    A `discord.ext.commands.Group` subclass which supports root aliases.
+
+    A `root_aliases` keyword argument is added, which is a sequence of alias names that will act as
+    top-level groups rather than being aliases of the command's group. It's stored as an attribute
+    also named `root_aliases`.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.root_aliases = kwargs.get("root_aliases", [])
+
+        if not isinstance(self.root_aliases, (list, tuple)):
+            raise TypeError("Root aliases of a group must be a list or a tuple of strings.")
diff --git a/bot/resources/pride/gender_options.json b/bot/resources/pride/gender_options.json
new file mode 100644
index 00000000..062742fb
--- /dev/null
+++ b/bot/resources/pride/gender_options.json
@@ -0,0 +1,41 @@
+{
+    "agender": "agender",
+    "androgyne": "androgyne",
+    "androgynous": "androgyne",
+    "aromantic": "aromantic",
+    "aro": "aromantic",
+    "ace": "asexual",
+    "asexual": "asexual",
+    "bigender": "bigender",
+    "bisexual": "bisexual",
+    "bi": "bisexual",
+    "demiboy": "demiboy",
+    "demigirl": "demigirl",
+    "demi": "demisexual",
+    "demisexual": "demisexual",
+    "gay": "gay",
+    "lgbt": "gay",
+    "queer": "gay",
+    "homosexual": "gay",
+    "fluid": "genderfluid",
+    "genderfluid": "genderfluid",
+    "genderqueer": "genderqueer",
+    "intersex": "intersex",
+    "lesbian": "lesbian",
+    "non-binary": "nonbinary",
+    "enby": "nonbinary",
+    "nb": "nonbinary",
+    "nonbinary": "nonbinary",
+    "omnisexual": "omnisexual",
+    "omni": "omnisexual",
+    "pansexual": "pansexual",
+    "pan": "pansexual",
+    "pangender": "pangender",
+    "poly": "polysexual",
+    "polysexual": "polysexual",
+    "polyamory": "polyamory",
+    "polyamorous": "polyamory",
+    "transgender": "transgender",
+    "trans": "transgender",
+    "trigender": "trigender"
+}
diff --git a/bot/utils/exceptions.py b/bot/utils/exceptions.py
index 2b1c1b31..9e080759 100644
--- a/bot/utils/exceptions.py
+++ b/bot/utils/exceptions.py
@@ -1,4 +1,4 @@
 class UserNotPlayingError(Exception):
-    """Will raised when user try to use game commands when not playing."""
+    """Raised when users try to use game commands when they are not playing."""
 
     pass
diff --git a/bot/utils/helpers.py b/bot/utils/helpers.py
new file mode 100644
index 00000000..74c2ccd0
--- /dev/null
+++ b/bot/utils/helpers.py
@@ -0,0 +1,8 @@
+import re
+
+
+def suppress_links(message: str) -> str:
+    """Accepts a message that may contain links, suppresses them, and returns them."""
+    for link in set(re.findall(r"https?://[^\s]+", message, re.IGNORECASE)):
+        message = message.replace(link, f"<{link}>")
+    return message