Update backup/backup.py

there have been no changes to downloader that break this since 3.5.0's release. however, 3.5.6 will be breaking most likely

.docs/.overrides/main.html.disabled

@@ -1,5 +0,0 @@
-{% extends "base.html" %}
-
-{% block announce %}
-  Put an announcement here.
-{% endblock %}

.docs/aurora/configuration.md

@@ -1,204 +1,88 @@
 # Configuration
 
-## auroraset
+/// admonition | Work in progress
- - Usage: `[p]auroraset`
+    type: warning
- - Aliases: `moderationset, modset, moderationsettings, aurorasettings, and auroraconfig`
+This page is still a work in progress.
+///
 
-Manage moderation commands.
+## aurora
 
-### auroraset ignorebots
+- Usage: `[p]aurora`
- - Usage: `[p]auroraset ignorebots`
+- Aliases: `moderation and mod`
+
+Settings and miscellaneous commands for Aurora.
+
+### aurora import
+
+- Usage: `[p]aurora import`
+- Restricted to: `ADMIN`
+- Checks: `server_only`
+
+Import moderation history from other bots.
+
+#### aurora import aurora
+
+- Usage: `[p]aurora import aurora`
 - Restricted to: `ADMIN`
 
-Toggle if the cog should ignore other bots' moderations.
+Import moderation history from another bot using Aurora.
 
-### auroraset user
+#### aurora import galacticbot
- - Usage: `[p]auroraset user`
 
-Manage configurations for user configuration options.
+- Usage: `[p]aurora import galacticbot`
-
-#### auroraset user history
- - Usage: `[p]auroraset user history`
-
-Manage configuration for the /history command.
-
-##### auroraset user history inline
- - Usage: `[p]auroraset user history inline`
-
-Manage configuration for the /history command's inline argument.
-
-###### auroraset user history inline toggle
- - Usage: `[p]auroraset user history inline toggle <enabled>`
-
-Enable the /history command's inline argument by default.
-
-##### auroraset user history inline pagesize
- - Usage: `[p]auroraset user history inline pagesize <pagesize>`
-
-Set the amount of cases to display per page.
-
-#### auroraset user history pagesize
- - Usage: `[p]auroraset user history pagesize <pagesize>`
-
-Set the amount of cases to display per page.
-
-#### auroraset user history ephemeral
- - Usage: `[p]auroraset user history ephemeral <enabled>`
- - Aliases: `hidden and hide`
-
-Toggle if the /history command should be ephemeral.
-
-### auroraset user autoevidence
- - Usage: `[p]auroraset user autoevidence <enabled>`
-
-Toggle if the evidenceformat codeblock should be sent automatically.
-
-## auroraset server
- - Usage: `[p]auroraset server`
 - Restricted to: `ADMIN`
 
-Manage default configurations for user configuration options, per server.
+Import moderation history from GalacticBot.
 
-### auroraset server history
+### aurora settings
- - Usage: `[p]auroraset server history`
+
+- Usage: `[p]aurora settings`
+- Aliases: `config, options, and set`
+
+Configure Aurora's settings.
+
+#### aurora settings server
+
+- Usage: `[p]aurora settings server`
 - Restricted to: `ADMIN`
+- Aliases: `server`
+- Checks: `server_only`
 
-Manage configuration for the /history command.
+Manage Aurora's server settings.
 
-#### auroraset server history inline
+#### aurora settings overrides
- - Usage: `[p]auroraset server history inline`
+
+- Usage: `[p]aurora settings overrides`
+- Aliases: `override and user`
+
+Manage Aurora's user overriddable settings.
+
+#### aurora settings addrole
+
+- Usage: `[p]aurora settings addrole`
 - Restricted to: `ADMIN`
+- Aliases: `removerole`
+- Checks: `server_only`
 
-Manage configuration for the /history command's inline argument.
+Manage the addrole whitelist.  
+Roles added to this list are also applied to `/removerole`.
 
-##### auroraset server history inline pagesize
+#### aurora settings immunity
- - Usage: `[p]auroraset server history inline pagesize <pagesize>`
+
+- Usage: `[p]aurora settings immunity`
 - Restricted to: `ADMIN`
+- Checks: `server_only`
 
-Set the amount of cases to display per page.
+Manage the immunity whitelist.
 
-##### auroraset server history inline toggle
+### aurora timedelta
- - Usage: `[p]auroraset server history inline toggle <enabled>`
- - Restricted to: `ADMIN`
 
-Enable the /history command's inline argument by default.
+- Usage: `[p]aurora timedelta <duration>`
+- Aliases: `tdc, td, and timedeltaconvert`
 
-#### auroraset server history ephemeral
+This command converts a duration to a [`timedelta`](https://docs.python.org/3/library/datetime.html#datetime.timedelta) Python object.
- - Usage: `[p]auroraset server history ephemeral <enabled>`
- - Restricted to: `ADMIN`
- - Aliases: `hidden and hide`
 
-Toggle if the /history command should be ephemeral.
+**Example usage**  
-
+`[p]timedelta 1 day 15hr 82 minutes 52s`  
-#### auroraset server history pagesize
+**Output**  
- - Usage: `[p]auroraset server history pagesize <pagesize>`
+`1 day, 16:22:52`
- - Restricted to: `ADMIN`
-
-Set the amount of cases to display per page.
-
-### auroraset server autoevidence
- - Usage: `[p]auroraset server autoevidence <enabled>`
-
-Toggle if the evidenceformat codeblock should be sent automatically.
-
-## auroraset showmoderator
- - Usage: `[p]auroraset showmoderator`
- - Restricted to: `ADMIN`
-
-Toggle if the cog should show the moderator in the case embed when dming a user.
-
-## auroraset immunity
- - Usage: `[p]auroraset immunity`
- - Restricted to: `ADMIN`
-
-Manage configuration for immune roles.
-
-### auroraset immunity add
- - Usage: `[p]auroraset immunity add <role>`
- - Restricted to: `ADMIN`
-
-Add a role to the immune roles list.
-
-### auroraset immunity remove
- - Usage: `[p]auroraset immunity remove <role>`
- - Restricted to: `ADMIN`
-
-Remove a role from the immune roles list.
-
-### auroraset immunity list
- - Usage: `[p]auroraset immunity list`
- - Restricted to: `ADMIN`
-
-List all immune roles.
-
-## auroraset permissions
- - Usage: `[p]auroraset permissions`
- - Restricted to: `ADMIN`
-
-Toggle whether the bot will check for discord permissions.
-
-## auroraset logchannel
- - Usage: `[p]auroraset logchannel [channel=None]`
- - Restricted to: `ADMIN`
-
-Set a channel to log infractions to.
-
-## auroraset import
- - Usage: `[p]auroraset import`
- - Restricted to: `ADMIN`
-
-Import moderations from other bots.
-
-### auroraset import galacticbot
- - Usage: `[p]auroraset import galacticbot`
- - Restricted to: `ADMIN`
-
-Import moderations from GalacticBot.
-
-### auroraset import aurora
- - Usage: `[p]auroraset import aurora`
- - Restricted to: `ADMIN`
-
-Import moderations from another bot using Aurora.
-
-## auroraset dm
- - Usage: `[p]auroraset dm`
- - Restricted to: `ADMIN`
-
-Toggle automatically messaging moderated users.<br/><br/>This option can be overridden by specifying the `silent` argument in any moderation command.
-
-## auroraset list
- - Usage: `[p]auroraset list`
- - Aliases: `view and show`
-
-List all moderation settings.
-
-## auroraset blacklist
- - Usage: `[p]auroraset blacklist`
- - Restricted to: `ADMIN`
-
-Manage configuration for the /blacklist command.
-
-### auroraset blacklist list
- - Usage: `[p]auroraset blacklist list`
- - Restricted to: `ADMIN`
-
-List all blacklist types.
-
-### auroraset blacklist remove
- - Usage: `[p]auroraset blacklist remove <role>`
- - Restricted to: `ADMIN`
-
-Remove a role's blacklist type.
-
-### auroraset blacklist add
- - Usage: `[p]auroraset blacklist add <role> <duration>`
- - Restricted to: `ADMIN`
-
-Add a role to the blacklist.
-
-# timedeltaconvert
- - Usage: `[p]timedeltaconvert <duration>`
- - Aliases: `tdc`
-
-This command converts a duration to a [`timedelta`](https://docs.python.org/3/library/datetime.html#datetime.timedelta) Python object.<br/><br/>**Example usage**<br/>`[p]timedeltaconvert 1 day 15hr 82 minutes 52s`<br/>**Output**<br/>`1 day, 16:22:52`

.docs/aurora/index.md

@@ -10,7 +10,7 @@ Aurora is a fully-featured moderation system. It is heavily inspired by Galactic
 ## Installation
 
 ```bash
-[p]repo add seacogs https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs
+[p]repo add seacogs https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs
 [p]cog install seacogs aurora
 [p]cog load aurora
 ```

.docs/backup.md

@@ -0,0 +1,33 @@
+# Backup
+
+Backup allows you to export a JSON list of all of your installed repositories and cogs, then reimport them and automatically reinstall/reload the cogs.
+
+## Installation
+
+```bash
+[p]repo add seacogs https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs
+[p]cog install seacogs backup
+[p]cog load backup
+```
+
+## Version Compatibility
+
+As of commit [1edb08a](https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs/commit/1edb08a1271f12098ca0bed11a735f7162cedd14), the Backup cog no longer supports Red versions older than 3.5.6. If you want to use the cog on an earlier version (3.5.0 - 3.5.5), install the cog pinned to this commit: `43464db6a7c51bc69282b1ae3dc507a4aae851de`.
+
+```bash
+[p]cog installversion sea-cogs 43464db6a7c51bc69282b1ae3dc507a4aae851de backup
+```
+
+## Commands
+
+### backup export
+
+- Usage: `[p]backup export`
+
+Exports a JSON list of all of your added repositories, and their installed cogs.
+
+### backup import
+
+- Usage: `[p]backup import`
+
+Reinstalls repositories and cogs from a valid export. Requires the JSON export to be attached to the invoking message as an attachment. Ignores itself and PyLav cogs, due to possible conflicts with Docker images.

.docs/bible.md

@@ -0,0 +1,36 @@
+# Bible
+
+Bible allows you to get a specific (or random) Bible verse from the [API.Bible](https://scripture.api.bible/) API.  
+This cog does require an api key to work.
+
+## Installation
+
+```bash
+[p]repo add seacogs https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs
+[p]cog install seacogs bible
+[p]cog load bible
+```
+
+## Setup
+
+This cog requires an [API.Bible](https://scripture.api.bible/) API key to function. You can sign up for an account [here](https://scripture.api.bible/signup). This will also generate your first API key for you.
+
+Then, you can use `[p]set api` to set the API key. Make sure your formatting matches the screenshot below.  
+![image](img/bible/set-api.png)
+
+## Commands
+
+### bible passage
+ - Usage: `[p]bible passage <book> <passage>`
+ - Aliases: `verse`
+
+Get a Bible passage.
+
+Example usage:  
+`[p]bible passage Genesis 1:1`  
+`[p]bible passage John 3:16-3:17`
+
+### bible random
+ - Usage: `[p]bible random`
+
+Get a random Bible verse.

.docs/nerdify.md

@@ -5,7 +5,7 @@ Nerdify allows you to nerdify other people's text.
 ## Installation
 
 ```bash
-[p]repo add seacogs https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs
+[p]repo add seacogs https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs
 [p]cog install seacogs nerdify
 [p]cog load nerdify
 ```
@@ -19,9 +19,3 @@ Nerdify allows you to nerdify other people's text.
 
 Nerdify the replied to message, previous message, or your own text.  
 If `[text]` is not provided, the bot will try to nerdify either the previous message or the replied to message, if the invocation message is a reply.
-
-## Method Reference
-
-::: nerdify.nerdify.Nerdify.nerdify_text
-
-::: nerdify.nerdify.Nerdify.type_message

.docs/pterodactyl/configuration.md

@@ -0,0 +1,199 @@
+# Configuration
+
+This page will go over all of the configuration options for the Pterodactyl cog.  
+All of the commands below can be accessed through `[p]pterodactyl config`.
+
+## `api`
+
+This option determines which [PlayerDB](https://playerdb.co/) endpoint the cog will use to retrieve player avatars.  
+This is only used for webhook avatars in the chat integration system. You should probably leave this as default.
+
+Default value: `minecraft`
+
+## `chat`
+
+### `channel`
+
+This option determines what channel chat messages will be sent to. If this is unset, the chat integration won't work.
+**Make sure the bot has permissions to speak in this channel!**
+
+Default value: `None`
+
+### `command`
+
+This option determines what command will be sent to the server whenever a message is sent in the configured chat channel. The JSON format Minecraft uses for this is very janky sometimes, if you need help with changing the command, you can join my [Discord server](https://discord.gg/eMUMe77Yb8).
+
+Available placeholders:
+
+- `.$C` - replaced with hex color of the author's top colored role
+- `.$D` - replaced with the author's discriminator (will usually be 0, you shouldn't use this)
+- `.$I` - replaced with the author's ID
+- `.$M` - replaced with message content
+- `.$N` - replaced with author's display name (or guild nickname, if set)
+- `.$U` - replaced with the author's username (NOT display name, you should usually use `.$N`)
+- `.$V` - replaced with the configured invite link
+
+Default value:
+
+```json
+tellraw @a ["",{"text":".$N ","color":".$C","insertion":"<@.$I>","hoverEvent":{"action":"show_text","contents":"Shift click to mention this user inside Discord"}},{"text":"(DISCORD):","color":"blue","clickEvent":{"action":"open_url","value":".$V"},"hoverEvent":{"action":"show_text","contents":"Click to join the Discord Server"}},{"text":" .$M","color":"white"}]
+```
+
+## `console`
+
+### `channel`
+
+/// admonition | Only give access to the console channel to people you trust!
+    type: danger
+If a user account has access to the console channel, they can execute ***any*** command on your server, including some power actions.
+They will also be able to see potentially sensitive information, such as player IPs, if [IP Masking](configuration.md#ip) is disabled.
+///
+
+This option determines what channel console logs will be sent to. If this is unset, the console integration won't work.  
+**Make sure the bot has permissions to speak in this channel!**  
+Server status changes, Discord --> Minecraft chat messages, and command executions will all be logged here.
+
+/// admonition
+    type: info
+Please note that, in order to avoid Discord ratelimits, logs will not be posted when the server status is one of the following:
+
+- `starting`
+- `stopping`
+
+This is to prevent the console channel from flooding and getting backed up by Discord's message ratelimits.
+///
+
+Default value: `None`
+
+### `commands`
+
+/// admonition | This has no effect on the `[p]pterodactyl command` text command, or the matching slash command.
+    type: danger
+If you want to disable the ability to execute commands on the server through Discord, use the following commands:
+`[p]pterodactyl config console commands False` - this command
+`[p]command disable pterodactyl command` - disables the text command that lets you execute commands on the server
+`[p]slash disable pterodactyl` - due to how slash commands are laid out, this is the only way to disable the ability to execute commands on the server
+`[p]slash sync` - apply above slash command change
+///
+
+This option determines if commands sent to the console channel will be sent to the Pterodactyl console.
+
+Default value: `False`
+
+## `invite`
+
+This option determines what url the chat command will substitute in for the Discord invite placeholder.
+
+Default value: `None`
+
+## `ip`
+
+This option determines whether or not IP's will be redacted when posted in chat or to the console channel.
+
+Default value: `True`
+
+## `messages`
+
+### `join`
+
+This option determines what the description in embeds will be when a user joins the server. Has no effect if embeds aren't used.
+
+Default value: `Welcome to the server! 👋`
+
+### `leave`
+
+This option determines what the description in embeds will be when a user leaves the server. Has no effect if embeds aren't used.
+
+Default value: `Goodbye! 👋`
+
+### `shutdown`
+
+This option determines what the bot will send in the chat channel when the server stops.
+
+Default value: `Server stopped!`
+
+### `startup`
+
+This option determines what the bot will send in the chat channel when the server is started.
+
+Default value: `Server started!`
+
+## `regex`
+
+If you're not running on recent versions of Paper, which this cog was developed against, or you're otherwise changing for format of chat messages, you'll need to add custom regex through the `[p]pterodactyl config regex` command. Same thing applies if any other type of message isn't being detected. I recomend using ChatGPT or something similar for this, or if you need help, you can join my [Discord server](https://discord.gg/eMUMe77Yb8).  
+See [Regex Examples](regex.md) for default values.
+
+### `blacklist`
+
+This group of commands allows you to add regex patterns that will be ignored by the console logger. The intended use for this is if you're getting ratelimited by messages that flood the console after the server sets its status to `running` but before it actually finishes starting.
+
+### `achievement`
+
+This regex pattern is used to detect advacnements/challenges. The default should work for most Minecraft servers.
+
+### `chat`
+
+This regex pattern is used to detect chat messages. You will probably have to change this if you're using any plugins or mods that use custom chat formatting, like EssentialsX Chat or Styled Chat.
+
+### `join`
+
+This regex pattern is used to detect whenever a user joins the server. You shouldn't usually need to change this.
+
+### `leave`
+
+This regex pattern is used to detect whenever a user leaves the server. You shouldn't usually need to change this.
+
+### `server`
+
+This regex pattern is used to detect whenever a server message is sent. You will have to change this if you aren't running on Paper, most likely.
+
+## `serverid`
+
+This option determines which server's websocket to connect to. See [Getting Started](getting-started.md#getting-server-information) for more information on this.
+
+Default value: `None`
+
+## `topic`
+
+### `host`
+
+This option determines the hostname of your server that will be used to retrieve server information.
+
+### `port`
+
+This option determines the port of your server that will be used to retrieve server information.
+
+Default value: `25565`
+
+### `text`
+
+This option determines what the channel topic will be set to.
+
+Available placeholders:
+
+- `.$H` - replaced with the server's hostname
+- `.$O` - replaced with the server's port
+
+Available with a Minecraft server:
+
+- `.$I` - replaced with the server's ip address
+- `.$M` - replaced with maximum player count
+- `.$P` - replaced with current online player count
+- `.$V` - replaced with the server's current version
+- `.$D` - replaced with the server's description / message of the day
+
+Default value:
+
+```
+Server IP: .$H\nServer Players: .$P/.$M
+```
+
+## `url`
+
+This option determines what panel the cog will send requests to. See [Getting Started](getting-started.md#getting-server-information) for more information on this.
+
+Default value: `None`
+
+## `view`
+
+Lists all of the configuration options offered by the cog.

.docs/pterodactyl/getting-started.md

@@ -0,0 +1,104 @@
+# Getting Started
+
+This page will go over the steps required to get started with the Pterodactyl cog.
+
+/// admonition | Screenshots may be visually distinct
+    type: info
+For the purpose of this guide, I'll be using [Bloom Host's](https://bloom.host/) [Pterodactyl fork](https://mc.bloom.host/).  
+The steps should be basically identical for other panels, but screenshots will look visually different.  
+If in doubt, contact your host's support.
+///
+
+## Installing the cog
+
+This project is a [cog](https://discordpy.readthedocs.io/en/stable/ext/commands/cogs.html) made for use with *specifically* instances of [Red-DiscordBot](https://github.com/Cog-Creators/Red-DiscordBot).  
+See the [Red documentation](https://docs.discord.red/en/stable/install_guides/index.html) for information on how to run an instance of Red. Once you've got it running, come back here.
+
+/// admonition | `[p]` is your bot's prefix
+    type: tip
+///
+
+Now, load the Downloader cog:
+
+```
+[p]load downloader
+```
+
+The Downloader cog allows you to add Git repositories to your bot in order to download cogs from them.  
+Now, use Downloader to add my repository to your bot:
+
+```
+[p]repo add sea-cogs https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs
+```
+
+Now, install the Pterodactyl cog:
+
+```
+[p]cog install sea-cogs pterodactyl
+[p]load pterodactyl
+```
+
+## Creating a sub-user
+
+This is **optional**, but highly recommended, for security reasons.
+
+Navigate to your `Users` page, and click the `New User` button.  
+Type in an email address, and scroll down to the `Control` header.  
+Click the checkmark on that header to select all of the permissions contained under the header.  
+Now, scroll back up to the top of the prompt and press `Invite User`.
+
+![image](../img/pterodactyl/setup/1.png)
+![image](../img/pterodactyl/setup/2.png)
+
+Now, you'll need to check the email you just entered into the subusers page, and create an account. I won't cover this, as it'll change depending on what host you're using.
+
+## Getting an API Key
+
+**Log out of your primary account, and switch to the sub-user you just created.**
+
+Navigate to your sub-user account's `API Credentials` page.
+
+![image](../img/pterodactyl/setup/3.png)
+
+Create a new API key.
+
+![image](../img/pterodactyl/setup/4.png)
+
+You don't have to specify an allowed IP if you don't want to, but I recommend it. If you chose to, you'll need to retrieve your bot's IP address. You can do this through SSH or through a cog like [AAA3A's IP cog](https://github.com/AAA3A-AAA3A/AAA3A-cogs).
+
+![image](../img/pterodactyl/setup/5.png)
+
+Now, use the `[p]set api` command on your bot to add the API key.  
+The format is as follows:
+
+```
+# Service: pterodactyl
+# Keys and Tokens: api_key ptlc_...
+```
+
+![image](../img/pterodactyl/setup/6.png)
+
+## Getting server information
+
+There's some other information that the Pterodactyl cog needs to function.
+
+First, get the base url for your panel. This does not include any extra information, like server ids, or whatnot. In my case, I'm using `https://mc.bloom.host/`.
+
+![image](../img/pterodactyl/setup/7.png)
+
+Use the `[p]pterodactyl config url` command to set the URL the cog will use.  
+In my case, I'd use `-pterodactyl config url https://mc.bloom.host/`.
+
+![image](../img/pterodactyl/setup/8.png)
+
+Now, we need to get the id of your server.  Navigate to the `Settings` page in your panel.
+
+![image](../img/pterodactyl/setup/9.png)
+
+Use the `[p]pterodactyl config serverid` command to add the server id to the bot.
+In my case, I'd use `-pterodactyl config serverid ad712016-df3d-47a5-b1df-6b71baf50340`.
+
+![image](../img/pterodactyl/setup/10.png)
+
+Once you've done all of this, you should see a connection message in the bot's logs. Now, we need to configure some other things.  
+See the [Configuration](configuration.md) page for more information.

.docs/pterodactyl/index.md

@@ -0,0 +1,16 @@
+# Pterodactyl
+
+/// admonition | This project is in active development
+    type: warning
+These docs are not complete yet, and there is a lot still to do.
+///
+
+Pterodactyl allows for connecting to a Pterodactyl server through websockets. It is intended primarily for use with Minecraft servers, as it allows for version & server platform-agnostic Discord integration, including console logging and two-way chat bridging.
+
+## Installation
+
+```bash
+[p]repo add seacogs https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs
+[p]cog install seacogs pterodactyl
+[p]cog load aurora
+```

.docs/pterodactyl/installing-red.md

@@ -0,0 +1,74 @@
+# Installing Red
+
+This guide will explain how to create an instance of [Red-DiscordBot]() (referred to as 'Red') on a Pterodactyl panel.
+
+Running the bot on Pterodactyl is not required to use the Pterodactyl cog. If you already have a working instance of Red, you should look at [Getting Started](getting-started.md).
+
+/// admonition | Caveats
+    type: warning
+There are a few caveats to running an instance of Red on Pterodactyl.
+
+- You will not receive any support from the Red developers.
+- The built-in Audio cog will not work.
+- Depending on your host, you might have to request a [`tmpfs` size increase](https://github.com/ign-gg/Pterodactyl-Eggs/tree/master/bots/discord/redbot#additional-requirements).
+
+If these are unacceptable to you, you should [install Red normally](https://docs.discord.red/en/stable/install_guides/index.html).
+///
+
+/// admonition | Requirements
+    type: info
+- A Discord bot token (see [Creating a bot account](https://docs.discord.red/en/stable/bot_application_guide.html))
+- A panel host with the [Red-DiscordBot Pterodactyl egg](https://github.com/ign-gg/Pterodactyl-Eggs/tree/master/bots/discord/redbot)
+- A panel with support for server splitting, like [Bloom.host](https://bloom.host/)'s DuckPanel.
+///
+
+## Creating a Server Split
+
+1. Navigate to your host's server split option.
+2. Select `Discord Bots` in the `Server Category` dropdown
+3. Select `Red` in the `Server Type` dropdown
+4. Allocate 1gb of RAM to Red. You can get away with less, but for the purposes of this guide we'll be using 1gb.
+5. Allocate 5gb of storage space to Red.
+6. Click the `Split Server` button. The installation process will take a few minutes, once it's done, continue to the next section.
+
+![server-split-img](../img/pterodactyl/installing-red/1.png)
+
+## Configuring Startup Variables
+
+1. Navigate to the `Startup` page of your new server split.
+2. Enter in your bot token.
+3. If you want to change the default prefix that the bot will respond to, do so here.
+4. If you want to change the owner of the bot, you can do so here. This defaults to the owner of the application the bot user is from.
+
+![server-startup-img](../img/pterodactyl/installing-red/2.png)
+
+## Inviting the Bot
+
+1. Navigate to the `Console` page of your server split.
+2. Click the `Start` button.
+3. Click the Invite URL in your console, once the bot starts.
+
+![console-img](../img/pterodactyl/installing-red/3.png)
+
+## Initial Setup
+
+Red is quite a large bot, so I'll focus on the specifics of getting the bot working with my Pterodactyl cog specifically.
+
+/// admonition | `[p]` is your bot's prefix
+    type: tip
+///
+
+1. Load the `Downloader` cog.
+```bash
+[p]load downloader
+```
+2. Add my repository to the bot
+```bash
+[p]repo add sea-cogs https://www.coastalcommits.com/SeaswimmerTheFsh/SeaCogs
+```
+3. Install and load the Pterodactyl cog
+```bash
+[p]cog install sea-cogs pterodactyl
+[p]load pterodactyl
+```
+4. Follow the instructions given in [Getting Started](getting-started.md)

.docs/pterodactyl/regex.md

@@ -0,0 +1,65 @@
+# Regex Examples
+
+## 1.20.4 - Paper (Default)
+
+### Achievements
+
+```re
+^\[\d{2}:\d{2}:\d{2} INFO\]: (.*) has (made the advancement|completed the challenge) \[(.*)\]$
+```
+
+### Chat
+
+```re
+^\[\d{2}:\d{2}:\d{2}\sINFO\]: (?!\[(?:Server|Rcon)\])(?:<|\[)(\w+)(?:>|\]) (.*)
+```
+
+### Join
+
+```re
+^\[\d{2}:\d{2}:\d{2} INFO\]: ([^<\n]+) joined the game$
+```
+
+### Leave
+
+```re
+^\[\d{2}:\d{2}:\d{2} INFO\]: ([^<\n]+) left the game$
+```
+
+### Server
+
+```re
+^\[\d{2}:\d{2}:\d{2} INFO\]:(?: \[Not Secure\])? \[(?:Server|Rcon)\] (.*)
+```
+
+## 1.20.1 - Forge
+
+### Achievements
+
+```re
+^\[\d{2}:\d{2}:\d{2}\] \[Server thread\/INFO\] \[minecraft\/MinecraftServer\]: (.*) has (made the advancement|completed the challenge) \[(.*)\]$
+```
+
+### Chat
+
+```re
+^\[\d{2}:\d{2}:\d{2}\] \[Server thread\/INFO\] \[minecraft\/MinecraftServer\]: (?!\[(?:Server|Rcon)\])(?:<|\[)(\w+)(?:>|\]) (.*)
+```
+
+### Join
+
+```re
+^\[\d{2}:\d{2}:\d{2}\] \[Server thread\/INFO\] \[minecraft\/MinecraftServer\]: ([^<\n]+) joined the game$
+```
+
+### Leave
+
+```re
+^\[\d{2}:\d{2}:\d{2}\] \[Server thread\/INFO\] \[minecraft\/MinecraftServer\]: ([^<\n]+) left the game$
+```
+
+### Server
+
+```re
+^\[\d{2}:\d{2}:\d{2}\] \[Server thread\/INFO\] \[minecraft\/MinecraftServer\]: \[(?:Server|Rcon)\] (.*)
+```

.docs/updatechecker.md

@@ -1,22 +0,0 @@
-# UpdateChecker
-
-/// admonition | This project is not ready for production use
-    type: danger
-The UpdateChecker cog is currently in an unfinished state, until it is completed please use [NeuroAssassin's UpdateChecker cog](https://github.com/NeuroAssassin/Toxic-Cogs) instead.
-///
-
-UpdateChecker will tell when there is an update available for a repository you have added for your bot, and, depending on settings, will auto update or will just notify you.
-
-This is a fork of [NeuroAssassin's UpdateChecker cog](https://github.com/NeuroAssassin/Toxic-Cogs).  
-Additional features include support for Gitea/Forgejo RSS feeds, instead of just GitHub. (1)
-{ .annotate }
-
-1. ⚠️ Not yet implemented.
-
-## Installation
-
-```bash
-[p]repo add seacogs-updatechecker https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs updatechecker
-[p]cog install seacogs-updatechecker updatechecker
-[p]cog load updatechecker
-```

.forgejo/workflows/config/.pylintrc

@@ -17,4 +17,5 @@
     import-outside-toplevel,
     import-self,
     relative-beyond-top-level,
+    too-many-instance-attributes,
     duplicate-code

.forgejo/workflows/workflow.yaml

@@ -6,9 +6,9 @@ on:
   pull_request:
 
 jobs:
-  Lint Code (Pylint):
+  Lint Code (Ruff & Pylint):
     runs-on: docker
-    container: coastalcommits.com/seaswimmerthefsh/actionscontainers-seacogs:latest
+    container: www.coastalcommits.com/seaswimmerthefsh/actionscontainers-seacogs:latest
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -16,12 +16,16 @@ jobs:
       - name: Install dependencies
         run: poetry install --with dev --no-root
 
+      - name: Analysing code with Ruff
+        run: ./.venv/bin/ruff check $(git ls-files '*.py')
+        continue-on-error: true
+
       - name: Analysing code with Pylint
-        run: pylint --rcfile .forgejo/workflows/config/.pylintrc $(git ls-files '*.py')
+        run: ./.venv/bin/pylint --rcfile=.forgejo/workflows/config/.pylintrc $(git ls-files '*.py')
 
   Build Documentation (MkDocs):
     runs-on: docker
-    container: coastalcommits.com/seaswimmerthefsh/actionscontainers-seacogs:latest
+    container: www.coastalcommits.com/seaswimmerthefsh/actionscontainers-seacogs:latest
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -38,8 +42,7 @@ jobs:
         run: |
           export SITE_URL="https://$CI_ACTION_REF_NAME_SLUG.seacogs.coastalcommits.com"
           export EDIT_URI="src/branch/$CI_ACTION_REF_NAME/.docs"
-          mkdocs build -v
+          ./.venv/bin/mkdocs build -v
-        continue-on-error: true
 
       - name: Deploy documentation
         run: |
@@ -63,4 +66,3 @@ jobs:
           echo "${GREEN}https://$CI_ACTION_REF_NAME_SLUG.seacogs.coastalcommits.com/"
         env:
           GITEA_TOKEN: ${{ secrets.COASTALCOMMITSTOKEN }}
-        continue-on-error: true

.gitignore

@@ -1,3 +1,4 @@
 .cache
 .vscode
 site
+.venv

README.md

@@ -1,8 +1,8 @@
 # SeaCogs
 
 [![Discord](https://img.shields.io/discord/1070058354925383681?logo=discord&color=%235661f6)](https://discord.gg/eMUMe77Yb8)
-[![Read the Docs](https://img.shields.io/readthedocs/seacogs?logo=readthedocs)](https://seacogs.readthedocs.io/en/latest)
+[![Documentation](https://img.shields.io/badge/docs-CoastalCommits%20Pages-3e83fd?logo=materialformkdocs)](https://seacogs.coastalcommits.com)
-![Static Badge](https://img.shields.io/badge/python-3.10%20%7C%203.11-%233776ab?logo=python)
+![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11-%233776ab?logo=python)
 
 My assorted cogs for Red-DiscordBot.
 

antipolls/__init__.py

@@ -0,0 +1,5 @@
+from .antipolls import AntiPolls
+
+
+async def setup(bot):
+    await bot.add_cog(AntiPolls(bot))

antipolls/antipolls.py

@@ -0,0 +1,180 @@
+#   _____                         _
+#  / ____|                       (_)
+# | (___   ___  __ _ _____      ___ _ __ ___  _ __ ___   ___ _ __
+#  \___ \ / _ \/ _` / __\ \ /\ / / | '_ ` _ \| '_ ` _ \ / _ \ '__|
+#  ____) |  __/ (_| \__ \\ V  V /| | | | | | | | | | | |  __/ |
+# |_____/ \___|\__,_|___/ \_/\_/ |_|_| |_| |_|_| |_| |_|\___|_|
+
+import discord
+from red_commons.logging import getLogger
+from redbot.core import commands
+from redbot.core.bot import Config, Red
+from redbot.core.utils.chat_formatting import humanize_list
+
+
+class AntiPolls(commands.Cog):
+    """AntiPolls deletes messages that contain polls, with a configurable per-guild role and channel whitelist and support for default Discord permissions (Manage Messages)."""
+
+    __author__ = ["SeaswimmerTheFsh"]
+    __version__ = "1.0.0"
+    __documentation__ = "https://seacogs.coastalcommits.com/antipolls/"
+
+    def __init__(self, bot: Red):
+        super().__init__()
+        self.bot = bot
+        self.logger = getLogger("red.SeaCogs.AntiPolls")
+        self.config = Config.get_conf(self, identifier=23517395243, force_registration=True)
+        self.config.register_guild(
+            role_whitelist=[],
+            channel_whitelist=[],
+            manage_messages=True,
+        )
+        if not self.bot.intents.message_content:
+            self.logger.error("Message Content intent is not enabled, cog will not load.")
+            raise RuntimeError("This cog requires the Message Content intent to function. To prevent potentially destructive behavior, the cog will not load without the intent enabled.")
+
+    def format_help_for_context(self, ctx: commands.Context) -> str:
+        pre_processed = super().format_help_for_context(ctx) or ""
+        n = "\n" if "\n\n" not in pre_processed else ""
+        text = [
+            f"{pre_processed}{n}",
+            f"Cog Version: **{self.__version__}**",
+            f"Author: {humanize_list(self.__author__)}",
+            f"Documentation: {self.__documentation__}",
+        ]
+        return "\n".join(text)
+
+    async def red_delete_data_for_user(self, **kwargs): # pylint: disable=unused-argument
+        """Nothing to delete."""
+        return
+
+    @commands.Cog.listener('on_message')
+    async def polls_listener(self, message: discord.Message) -> None:
+        if message.guild is None:
+            return self.logger.verbose("Message in direct messages ignored")
+
+        if message.author.bot:
+            return self.logger.verbose("Message from bot ignored")
+
+        if await self.bot.cog_disabled_in_guild(self, message.guild):
+            return self.logger.verbose("Message ignored, cog is disabled in guild %s", message.guild.id)
+
+        guild_config = await self.config.guild(message.guild).all()
+
+        if guild_config['manage_messages'] is True and message.author.guild_permissions.manage_messages:
+            return self.logger.verbose("Message from user with Manage Messages permission ignored")
+
+        if message.channel.id in guild_config['channel_whitelist']:
+            return self.logger.verbose("Message in whitelisted channel %s ignored", message.channel.id)
+
+        if any(role.id in guild_config['role_whitelist'] for role in message.author.roles):
+            return self.logger.verbose("Message from whitelisted role %s ignored", message.author.roles)
+
+        if not message.content and not message.embeds and not message.attachments and not message.stickers:
+            self.logger.trace("Message %s is a poll, attempting to delete", message.id)
+
+            try:
+                await message.delete()
+            except discord.HTTPException as e:
+                return self.logger.error("Failed to delete message: %s", e)
+
+            return self.logger.trace("Deleted poll message %s", message.id)
+        self.logger.verbose("Message %s is not a poll, ignoring", message.id)
+
+    @commands.group(name="antipolls", aliases=["ap"])
+    @commands.guild_only()
+    @commands.admin_or_permissions(manage_guild=True)
+    async def antipolls(self, ctx: commands.Context) -> None:
+        """Manage AntiPolls settings."""
+
+    @antipolls.group(name="roles")
+    async def antipolls_roles(self, ctx: commands.Context) -> None:
+        """Manage role whitelist."""
+
+    @antipolls_roles.command(name="add")
+    async def antipolls_roles_add(self, ctx: commands.Context, *roles: discord.Role) -> None:
+        """Add roles to the whitelist."""
+        async with self.config.guild(ctx.guild).role_whitelist() as role_whitelist:
+            role_whitelist: list
+            failed: list[discord.Role] = []
+            for role in roles:
+                if role.id in role_whitelist:
+                    failed.append(role)
+                    continue
+                role_whitelist.append(role.id)
+        await ctx.tick()
+        if failed:
+            await ctx.send(f"The following roles were already in the whitelist: {humanize_list([role.mention for role in failed])}", delete_after=10)
+
+    @antipolls_roles.command(name="remove")
+    async def antipolls_roles_remove(self, ctx: commands.Context, *roles: discord.Role) -> None:
+        """Remove roles from the whitelist."""
+        async with self.config.guild(ctx.guild).role_whitelist() as role_whitelist:
+            role_whitelist: list
+            failed: list[discord.Role] = []
+            for role in roles:
+                if role.id not in role_whitelist:
+                    failed.append(role)
+                    continue
+                role_whitelist.remove(role.id)
+        await ctx.tick()
+        if failed:
+            await ctx.send(f"The following roles were not in the whitelist: {humanize_list([role.mention for role in failed])}", delete_after=10)
+
+    @antipolls_roles.command(name="list")
+    async def antipolls_roles_list(self, ctx: commands.Context) -> None:
+        """List roles in the whitelist."""
+        role_whitelist = await self.config.guild(ctx.guild).role_whitelist()
+        if not role_whitelist:
+            return await ctx.send("No roles in the whitelist.")
+        roles = [ctx.guild.get_role(role) for role in role_whitelist]
+        await ctx.send(humanize_list([role.mention for role in roles]))
+
+    @antipolls.group(name="channels")
+    async def antipolls_channels(self, ctx: commands.Context) -> None:
+        """Manage channel whitelist."""
+
+    @antipolls_channels.command(name="add")
+    async def antipolls_channels_add(self, ctx: commands.Context, *channels: discord.TextChannel) -> None:
+        """Add channels to the whitelist."""
+        async with self.config.guild(ctx.guild).channel_whitelist() as channel_whitelist:
+            channel_whitelist: list
+            failed: list[discord.TextChannel] = []
+            for channel in channels:
+                if channel.id in channel_whitelist:
+                    failed.append(channel)
+                    continue
+                channel_whitelist.append(channel.id)
+        await ctx.tick()
+        if failed:
+            await ctx.send(f"The following channels were already in the whitelist: {humanize_list([channel.mention for channel in failed])}", delete_after=10)
+
+    @antipolls_channels.command(name="remove")
+    async def antipolls_channels_remove(self, ctx: commands.Context, *channels: discord.TextChannel) -> None:
+        """Remove channels from the whitelist."""
+        async with self.config.guild(ctx.guild).channel_whitelist() as channel_whitelist:
+            channel_whitelist: list
+            failed: list[discord.TextChannel] = []
+            for channel in channels:
+                if channel.id not in channel_whitelist:
+                    failed.append(channel)
+                    continue
+                channel_whitelist.remove(channel.id)
+        await ctx.tick()
+        if failed:
+            await ctx.send(f"The following channels were not in the whitelist: {humanize_list([channel.mention for channel in failed])}", delete_after=10)
+
+    @antipolls_channels.command(name="list")
+    async def antipolls_channels_list(self, ctx: commands.Context) -> None:
+        """List channels in the whitelist."""
+        channel_whitelist = await self.config.guild(ctx.guild).channel_whitelist()
+        if not channel_whitelist:
+            return await ctx.send("No channels in the whitelist.")
+        channels = [ctx.guild.get_channel(channel) for channel in channel_whitelist]
+        await ctx.send(humanize_list([channel.mention for channel in channels]))
+
+    @antipolls.command(name="managemessages")
+    async def antipolls_managemessages(self, ctx: commands.Context, enabled: bool) -> None:
+        """Toggle Manage Messages permission check."""
+        await self.config.guild(ctx.guild).manage_messages.set(enabled)
+        await ctx.tick()

antipolls/info.json

@@ -0,0 +1,17 @@
+{
+  "author" : ["SeaswimmerTheFsh (seasw.)"],
+  "install_msg" : "Thank you for installing AntiPolls!\nYou can find the source code of this cog [here](https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs).",
+  "name" : "AntiPolls",
+  "short" : "AntiPolls deletes messages that contain polls.",
+  "description" : "AntiPolls deletes messages that contain polls, with a configurable per-guild role and channel whitelist and support for default Discord permissions (Manage Messages).",
+  "end_user_data_statement" : "This cog does not store any user data.",
+  "hidden": false,
+  "disabled": false,
+  "min_bot_version": "3.5.0",
+  "min_python_version": [3, 10, 0],
+  "tags": [
+      "automod",
+      "automoderation",
+      "polls"
+  ]
+}

aurora/importers/aurora.py

@@ -1,3 +1,4 @@
+# pylint: disable=duplicate-code
 import json
 from datetime import timedelta
 from typing import Dict
@@ -40,7 +41,7 @@ class ImportAuroraView(ui.View):
         await interaction.edit_original_response(content="Importing moderations...")
 
         file = await self.ctx.message.attachments[0].read()
-        data: [dict] = sorted(json.loads(file), key=lambda x: x["moderation_id"])
+        data: list[dict] = sorted(json.loads(file), key=lambda x: x["moderation_id"])
 
         user_mod_types = ["NOTE", "WARN", "MUTE", "UNMUTE", "KICK", "BAN", "UNBAN"]
 
@@ -68,10 +69,8 @@ class ImportAuroraView(ui.View):
                 metadata = {}
             else:
                 metadata: Dict[str, any] = json.loads(case["metadata"])
-            if not metadata.get('imported_from'):
+            if not metadata.get("imported_from"):
-                metadata.update({
+                metadata.update({"imported_from": "Aurora"})
-                    'imported_from': 'Aurora'
-                })
 
             if case["duration"] != "NULL":
                 hours, minutes, seconds = map(int, case["duration"].split(":"))
@@ -101,7 +100,9 @@ class ImportAuroraView(ui.View):
         await interaction.edit_original_response(content="Import complete.")
         if failed_cases:
             await interaction.edit_original_response(
-                content="Import complete.\n" + warning("Failed to import the following cases:\n") + box(failed_cases)
+                content="Import complete.\n"
+                + warning("Failed to import the following cases:\n")
+                + box(failed_cases)
             )
 
     @ui.button(label="No", style=ButtonStyle.danger)

aurora/importers/galacticbot.py

@@ -1,3 +1,4 @@
+# pylint: disable=duplicate-code
 import json
 from datetime import timedelta
 
@@ -15,9 +16,13 @@ class ImportGalacticBotView(ui.View):
         self.message: Message = message
 
     @ui.button(label="Yes", style=ButtonStyle.success)
-    async def import_button_y(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+    async def import_button_y(
+        self, interaction: Interaction, button: ui.Button
+    ): # pylint: disable=unused-argument
         await self.message.delete()
-        await interaction.response.send_message("Deleting original table...", ephemeral=True)
+        await interaction.response.send_message(
+            "Deleting original table...", ephemeral=True
+        )
 
         database = connect()
         cursor = database.cursor()
@@ -35,94 +40,94 @@ class ImportGalacticBotView(ui.View):
         await interaction.edit_original_response(content="Importing moderations...")
 
         accepted_types = [
-            'NOTE',
+            "NOTE",
-            'WARN',
+            "WARN",
-            'MUTE',
+            "MUTE",
-            'UNMUTE',
+            "UNMUTE",
-            'KICK',
+            "KICK",
-            'SOFTBAN',
+            "SOFTBAN",
-            'BAN',
+            "BAN",
-            'UNBAN',
+            "UNBAN",
-            'SLOWMODE',
+            "SLOWMODE",
-            'LOCKDOWN'
+            "LOCKDOWN",
         ]
 
         file = await self.ctx.message.attachments[0].read()
-        data = sorted(json.loads(file), key=lambda x: x['case'])
+        data = sorted(json.loads(file), key=lambda x: x["case"])
 
         failed_cases = []
 
         for case in data:
-            if case['type'] not in accepted_types:
+            if case["type"] not in accepted_types:
                 continue
 
-            timestamp = round(case['timestamp'] / 1000)
+            timestamp = round(case["timestamp"] / 1000)
 
             try:
-                if case['duration'] is not None and float(case['duration']) != 0:
+                if case["duration"] is not None and float(case["duration"]) != 0:
-                    duration = timedelta(seconds=round(float(case['duration']) / 1000))
+                    duration = timedelta(seconds=round(float(case["duration"]) / 1000))
                 else:
-                    duration = 'NULL'
+                    duration = "NULL"
             except OverflowError:
-                failed_cases.append(case['case'])
+                failed_cases.append(case["case"])
                 continue
 
-            metadata = {
+            metadata = {"imported_from": "GalacticBot"}
-                'imported_from': 'GalacticBot'
-            }
 
-            if case['type'] == 'SLOWMODE':
+            if case["type"] == "SLOWMODE":
-                metadata['seconds'] = case['data']['seconds']
+                metadata["seconds"] = case["data"]["seconds"]
 
-            if case['resolved']:
+            if case["resolved"]:
                 resolved = 1
                 resolved_by = None
                 resolved_reason = None
                 resolved_timestamp = None
-                if case['changes']:
+                if case["changes"]:
-                    for change in case['changes']:
+                    for change in case["changes"]:
-                        if change['type'] == 'RESOLVE':
+                        if change["type"] == "RESOLVE":
-                            resolved_by = change['staff']
+                            resolved_by = change["staff"]
-                            resolved_reason = change['reason']
+                            resolved_reason = change["reason"]
-                            resolved_timestamp = round(change['timestamp'] / 1000)
+                            resolved_timestamp = round(change["timestamp"] / 1000)
                             break
                 if resolved_by is None:
-                    resolved_by = '?'
+                    resolved_by = "?"
                 if resolved_reason is None:
-                    resolved_reason = 'Could not get resolve reason during moderation import.'
+                    resolved_reason = (
+                        "Could not get resolve reason during moderation import."
+                    )
                 if resolved_timestamp is None:
                     resolved_timestamp = timestamp
                 changes = [
                     {
-                    'type': "ORIGINAL",
+                        "type": "ORIGINAL",
-                    'reason': case['reason'],
+                        "reason": case["reason"],
-                    'user_id': case['executor'],
+                        "user_id": case["executor"],
-                    'timestamp': timestamp
+                        "timestamp": timestamp,
                     },
                     {
-                    'type': "RESOLVE",
+                        "type": "RESOLVE",
-                    'reason': resolved_reason,
+                        "reason": resolved_reason,
-                    'user_id': resolved_by,
+                        "user_id": resolved_by,
-                    'timestamp': resolved_timestamp
+                        "timestamp": resolved_timestamp,
-                    }
+                    },
                 ]
             else:
                 resolved = 0
-                resolved_by = 'NULL'
+                resolved_by = "NULL"
-                resolved_reason = 'NULL'
+                resolved_reason = "NULL"
                 changes = []
 
-            if case['reason'] and case['reason'] != "N/A":
+            if case["reason"] and case["reason"] != "N/A":
-                reason = case['reason']
+                reason = case["reason"]
             else:
                 reason = "NULL"
 
             await mysql_log(
                 self.ctx.guild.id,
-                case['executor'],
+                case["executor"],
-                case['type'],
+                case["type"],
-                case['targetType'],
+                case["targetType"],
-                case['target'],
+                case["target"],
                 0,
                 duration,
                 reason,
@@ -132,15 +137,21 @@ class ImportGalacticBotView(ui.View):
                 resolved_reason=resolved_reason,
                 changes=changes,
                 metadata=metadata,
-                database=database
+                database=database,
             )
 
         await interaction.edit_original_response(content="Import complete.")
         if failed_cases:
-            await interaction.edit_original_response(content="Import complete.\n" + warning("Failed to import the following cases:\n") + box(failed_cases))
+            await interaction.edit_original_response(
+                content="Import complete.\n"
+                + warning("Failed to import the following cases:\n")
+                + box(failed_cases)
+            )
 
     @ui.button(label="No", style=ButtonStyle.danger)
-    async def import_button_n(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+    async def import_button_n(
+        self, interaction: Interaction, button: ui.Button
+    ): # pylint: disable=unused-argument
         await self.message.edit(content="Import cancelled.", view=None)
         await self.message.delete(10)
         await self.ctx.message.delete(10)

aurora/info.json

@@ -1,11 +1,27 @@
 {
-  "author" : ["SeaswimmerTheFsh"],
+  "author" : ["SeaswimmerTheFsh (seasw.)"],
-  "install_msg" : "Thank you for installing Aurora!\nYou can find the source code of this cog [here](https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs).",
+  "install_msg" : "Thank you for installing Aurora!\nMost of this cog's functionality requires enabling slash commands.\nYou can find the source code of this cog [here](https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs).",
   "name" : "Aurora",
   "short" : "A full replacement for Red's core Mod cogs.",
   "description" : "Aurora is a fully-featured moderation system. It is heavily inspired by GalacticBot, and is designed to be a more user-friendly alternative to Red's core Mod cogs. This cog stores all of its data in an SQLite database.",
   "end_user_data_statement" : "This cog stores the following information:\n- User IDs of accounts who moderate users or are moderated\n- Guild IDs of guilds with the cog enabled\n- Timestamps of moderations\n- Other information relating to moderations",
-  "requirements": ["humanize", "pytimeparse2"],
   "hidden": false,
-  "disabled": false
+  "disabled": false,
+  "min_bot_version": "3.5.0",
+  "min_python_version": [3, 10, 0],
+  "tags": [
+      "mod",
+      "moderate",
+      "moderation",
+      "warn",
+      "warning",
+      "mute",
+      "timeout",
+      "unmute",
+      "untimeout",
+      "kick",
+      "ban",
+      "unban",
+      "tempban"
+  ]
 }

aurora/menus/addrole.py

@@ -0,0 +1,43 @@
+from discord import ButtonStyle, Interaction, ui
+from redbot.core import commands
+from redbot.core.utils.chat_formatting import error
+
+from aurora.utilities.config import config
+from aurora.utilities.factory import addrole_embed
+
+
+class Addrole(ui.View):
+    def __init__(self, ctx: commands.Context):
+        super().__init__()
+        self.ctx = ctx
+
+    @ui.select(cls=ui.RoleSelect, placeholder="Select a role", min_values=0, max_values=25)
+    async def addrole_select(self, interaction: Interaction, select: ui.RoleSelect):
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message(error("You must have the manage guild permission to add roles to the addrole whitelist."), ephemeral=True)
+            return
+        await interaction.response.defer()
+        async with config.guild(self.ctx.guild).addrole_whitelist() as addrole_whitelist:
+            addrole_whitelist: list # type hint
+            for value in select.values:
+                if value.id in addrole_whitelist:
+                    addrole_whitelist.remove(value.id)
+                else:
+                    addrole_whitelist.append(value.id)
+        await interaction.message.edit(embed=await addrole_embed(self.ctx))
+
+    @ui.button(label="Clear", style=ButtonStyle.red, row=1)
+    async def clear(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message(error("You must have the manage guild permission to clear the guild's addrole whitelist."), ephemeral=True)
+            return
+        await interaction.response.defer()
+        await config.guild(self.ctx.guild).addrole_whitelist.clear()
+        await interaction.message.edit(embed=await addrole_embed(self.ctx))
+
+    @ui.button(label="Close", style=ButtonStyle.gray)
+    async def close(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message(error("You can't do that!"), ephemeral=True)
+            return
+        await interaction.message.delete()

aurora/menus/guild.py

@@ -0,0 +1,135 @@
+from discord import ButtonStyle, Interaction, ui
+from redbot.core import commands
+
+from aurora.utilities.config import config
+from aurora.utilities.factory import guild_embed
+from aurora.utilities.utils import create_pagesize_options
+
+
+class Guild(ui.View):
+    def __init__(self, ctx: commands.Context):
+        super().__init__()
+        self.ctx = ctx
+
+    @ui.button(label="Show Moderator", style=ButtonStyle.green, row=0)
+    async def show_moderator(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).show_moderator
+        await config.guild(interaction.guild).show_moderator.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="Use Discord Permissions", style=ButtonStyle.green, row=0)
+    async def use_discord_permissions(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).use_discord_permissions()
+        await config.guild(interaction.guild).use_discord_permissions.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="Respect Hierarchy", style=ButtonStyle.green, row=0)
+    async def respect_heirarchy(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).respect_hierarchy()
+        await config.guild(interaction.guild).respect_hierarchy.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="Ignore Modlog", style=ButtonStyle.green, row=0)
+    async def ignore_modlog(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).ignore_modlog()
+        await config.guild(interaction.guild).ignore_modlog.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="Ignore Other Bots", style=ButtonStyle.green, row=0)
+    async def ignore_other_bots(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).ignore_other_bots()
+        await config.guild(interaction.guild).ignore_other_bots.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="DM Users", style=ButtonStyle.green, row=1)
+    async def dm_users(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).dm_users()
+        await config.guild(interaction.guild).dm_users.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="Auto Evidence Format", style=ButtonStyle.green, row=1)
+    async def auto_evidenceformat(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).auto_evidenceformat()
+        await config.guild(interaction.guild).auto_evidenceformat.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="Ephemeral", style=ButtonStyle.green, row=1)
+    async def ephemeral(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).history_ephemeral()
+        await config.guild(interaction.guild).history_ephemeral.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.button(label="History Inline", style=ButtonStyle.green, row=1)
+    async def inline(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.guild(interaction.guild).history_inline()
+        await config.guild(interaction.guild).history_inline.set(not current_setting)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.select(placeholder="History Pagesize", options=create_pagesize_options(), row=2)
+    async def pagesize(self, interaction: Interaction, select: ui.Select,):
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        if select.values[0] == "default":
+            await config.guild(interaction.guild).history_pagesize.clear()
+        else:
+            await config.guild(interaction.guild).history_pagesize.set(int(select.values[0]))
+        await interaction.response.defer()
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.select(placeholder="History Inline Pagesize", options=create_pagesize_options(), row=3)
+    async def inline_pagesize(self, interaction: Interaction, select: ui.Select,):
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        if select.values[0] == "default":
+            await config.guild(interaction.guild).history_inline_pagesize.clear()
+        else:
+            await config.guild(interaction.guild).history_inline_pagesize.set(int(select.values[0]))
+        await interaction.response.defer()
+        await interaction.message.edit(embed=await guild_embed(self.ctx))
+
+    @ui.select(placeholder="Log Channel", cls=ui.ChannelSelect, row=4)
+    async def log_channel(self, interaction: Interaction, select: ui.ChannelSelect):
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message("You must have the manage guild permission to change this setting.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        await config.guild(interaction.guild).log_channel.set(select.values[0].id)
+        await interaction.message.edit(embed=await guild_embed(self.ctx))

aurora/menus/immune.py

@@ -0,0 +1,43 @@
+from discord import ButtonStyle, Interaction, ui
+from redbot.core import commands
+from redbot.core.utils.chat_formatting import error
+
+from aurora.utilities.config import config
+from aurora.utilities.factory import immune_embed
+
+
+class Immune(ui.View):
+    def __init__(self, ctx: commands.Context):
+        super().__init__()
+        self.ctx = ctx
+
+    @ui.select(cls=ui.RoleSelect, placeholder="Select a role", min_values=0, max_values=25)
+    async def immune_select(self, interaction: Interaction, select: ui.RoleSelect):
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message(error("You must have the manage guild permission to add immune roles."), ephemeral=True)
+            return
+        await interaction.response.defer()
+        async with config.guild(self.ctx.guild).immune_roles() as immune_roles:
+            immune_roles: list # type hint
+            for value in select.values:
+                if value.id in immune_roles:
+                    immune_roles.remove(value.id)
+                else:
+                    immune_roles.append(value.id)
+        await interaction.message.edit(embed=await immune_embed(self.ctx))
+
+    @ui.button(label="Clear", style=ButtonStyle.red, row=1)
+    async def clear(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message(error("You must have the manage guild permission to clear the guild's immune roles."), ephemeral=True)
+            return
+        await interaction.response.defer()
+        await config.guild(self.ctx.guild).immune_roles.clear()
+        await interaction.message.edit(embed=await immune_embed(self.ctx))
+
+    @ui.button(label="Close", style=ButtonStyle.gray)
+    async def close(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if not interaction.user.guild_permissions.manage_guild and not interaction.user.guild_permissions.administrator:
+            await interaction.response.send_message(error("You can't do that!"), ephemeral=True)
+            return
+        await interaction.message.delete()

aurora/menus/overrides.py

@@ -0,0 +1,81 @@
+from discord import ButtonStyle, Interaction, ui
+from redbot.core import commands
+
+from aurora.utilities.config import config
+from aurora.utilities.factory import overrides_embed
+from aurora.utilities.utils import create_pagesize_options
+
+
+class Overrides(ui.View):
+    def __init__(self, ctx: commands.Context):
+        super().__init__()
+        self.ctx = ctx
+
+    @ui.button(label="Auto Evidence Format", style=ButtonStyle.green, row=0)
+    async def auto_evidenceformat(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if self.ctx.author != interaction.user:
+            await interaction.response.send_message("You cannot change this setting for other users.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.user(self.ctx.author).auto_evidenceformat()
+        if current_setting is False:
+            await config.user(self.ctx.author).auto_evidenceformat.clear()
+        elif current_setting is None:
+            await config.user(self.ctx.author).auto_evidenceformat.set(True)
+        else:
+            await config.user(self.ctx.author).auto_evidenceformat.set(False)
+        await interaction.message.edit(embed=await overrides_embed(self.ctx))
+
+    @ui.button(label="Ephemeral", style=ButtonStyle.green, row=0)
+    async def ephemeral(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if self.ctx.author != interaction.user:
+            await interaction.response.send_message("You cannot change this setting for other users.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.user(self.ctx.author).history_ephemeral()
+        if current_setting is False:
+            await config.user(self.ctx.author).history_ephemeral.clear()
+        elif current_setting is None:
+            await config.user(self.ctx.author).history_ephemeral.set(True)
+        else:
+            await config.user(self.ctx.author).history_ephemeral.set(False)
+        await interaction.message.edit(embed=await overrides_embed(self.ctx))
+
+    @ui.button(label="Inline", style=ButtonStyle.green, row=0)
+    async def inline(self, interaction: Interaction, button: ui.Button): # pylint: disable=unused-argument
+        if self.ctx.author != interaction.user:
+            await interaction.response.send_message("You cannot change this setting for other users.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        current_setting = await config.user(self.ctx.author).history_inline()
+        if current_setting is False:
+            await config.user(self.ctx.author).history_inline.clear()
+        elif current_setting is None:
+            await config.user(self.ctx.author).history_inline.set(True)
+        else:
+            await config.user(self.ctx.author).history_inline.set(False)
+        await interaction.message.edit(embed=await overrides_embed(self.ctx))
+
+    @ui.select(placeholder="Inline Pagesize", options=create_pagesize_options(), row=1)
+    async def inline_pagesize(self, interaction: Interaction, select: ui.Select,):
+        if self.ctx.author != interaction.user:
+            await interaction.response.send_message("You cannot change this setting for other users.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        if select.values[0] == "default":
+            await config.user(self.ctx.author).history_inline_pagesize.clear()
+        else:
+            await config.user(self.ctx.author).history_inline_pagesize.set(int(select.values[0]))
+        await interaction.message.edit(embed=await overrides_embed(self.ctx))
+
+    @ui.select(placeholder="Pagesize", options=create_pagesize_options(), row=2)
+    async def pagesize(self, interaction: Interaction, select: ui.Select,):
+        if self.ctx.author != interaction.user:
+            await interaction.response.send_message("You cannot change this setting for other users.", ephemeral=True)
+            return
+        await interaction.response.defer()
+        if select.values[0] == "default":
+            await config.user(self.ctx.author).history_pagesize.clear()
+        else:
+            await config.user(self.ctx.author).history_pagesize.set(int(select.values[0]))
+        await interaction.message.edit(embed=await overrides_embed(self.ctx))

aurora/utilities/config.py

@@ -2,10 +2,12 @@ from redbot.core import Config
 
 config: Config = Config.get_conf(None, identifier=481923957134912, cog_name="Aurora")
 
+
 def register_config(config_obj: Config):
     config_obj.register_guild(
         show_moderator=True,
         use_discord_permissions=True,
+        respect_hierarchy=True,
         ignore_modlog=True,
         ignore_other_bots=True,
         dm_users=True,
@@ -16,12 +18,12 @@ def register_config(config_obj: Config):
         history_pagesize=5,
         history_inline_pagesize=6,
         auto_evidenceformat=False,
-        blacklist_roles = []
+        addrole_whitelist=[],
     )
     config_obj.register_user(
         history_ephemeral=None,
         history_inline=None,
         history_pagesize=None,
         history_inline_pagesize=None,
-        auto_evidenceformat = None
+        auto_evidenceformat=None,
     )

aurora/utilities/database.py

@@ -1,21 +1,23 @@
 # pylint: disable=cyclic-import
-
 import json
-import time
 import sqlite3
+import time
 from datetime import datetime, timedelta
 
 from discord import Guild
 from redbot.core import data_manager
 
 from .logger import logger
-from .utils import generate_dict, get_next_case_number, convert_timedelta_to_str
+from .utils import (convert_timedelta_to_str, generate_dict,
+                    get_next_case_number)
 
 
 def connect() -> sqlite3.Connection:
     """Connects to the SQLite database, and returns a connection object."""
     try:
-        connection = sqlite3.connect(database=data_manager.cog_data_path(raw_name='Aurora') / 'aurora.db')
+        connection = sqlite3.connect(
+            database=data_manager.cog_data_path(raw_name="Aurora") / "aurora.db"
+        )
         return connection
 
     except sqlite3.OperationalError as e:
@@ -85,8 +87,8 @@ async def create_guild_table(guild: Guild):
             "NULL",
             "NULL",
             0,
-            json.dumps([]), # pylint: disable=dangerous-default-value
+            json.dumps([]),
-            json.dumps({}), # pylint: disable=dangerous-default-value
+            json.dumps({}),
         )
         cursor.execute(insert_query, insert_values)
 
@@ -102,7 +104,6 @@ async def create_guild_table(guild: Guild):
     database.close()
 
 
-# pylint: disable=dangerous-default-value
 async def mysql_log(
     guild_id: str,
     author_id: str,
@@ -118,8 +119,8 @@ async def mysql_log(
     resolved_by: str = None,
     resolved_reason: str = None,
     expired: bool = None,
-    changes: list = [],
+    changes: list = None,
-    metadata: dict = {},
+    metadata: dict = None,
 ) -> int:
     if not timestamp:
         timestamp = int(time.time())
@@ -169,8 +170,8 @@ async def mysql_log(
         resolved_by,
         resolved_reason,
         expired,
-        json.dumps(changes),
+        json.dumps(changes if changes else []),
-        json.dumps(metadata),
+        json.dumps(metadata if metadata else {}),
     )
     cursor.execute(sql, val)
 

aurora/utilities/factory.py

@@ -1,17 +1,29 @@
 # pylint: disable=cyclic-import
-
-from typing import Union
 from datetime import datetime, timedelta
+from typing import Union
 
-import humanize
+from discord import (Color, Embed, Guild, Interaction, InteractionMessage,
-from discord import Color, Embed, Guild, Interaction, InteractionMessage, User, Member
+                     Member, Role, User)
-from redbot.core.utils.chat_formatting import box
+from redbot.core import commands
+from redbot.core.utils.chat_formatting import (bold, box, error,
+                                               humanize_timedelta, warning)
 
-from .config import config
+from aurora.utilities.config import config
-from .utils import fetch_channel_dict, fetch_user_dict, get_next_case_number
+from aurora.utilities.utils import (fetch_channel_dict, fetch_user_dict,
+                                    get_bool_emoji, get_next_case_number,
+                                    get_pagesize_str)
 
 
-async def message_factory(color: Color, guild: Guild, reason: str, moderation_type: str, moderator: Union[Member, User] = None, duration: timedelta = None, response: InteractionMessage = None) -> Embed:
+async def message_factory(
+    color: Color,
+    guild: Guild,
+    reason: str,
+    moderation_type: str,
+    moderator: Union[Member, User] = None,
+    duration: timedelta = None,
+    response: InteractionMessage = None,
+    role: Role = None,
+) -> Embed:
     """This function creates a message from set parameters, meant for contacting the moderated user.
 
     Args:
@@ -22,42 +34,66 @@ async def message_factory(color: Color, guild: Guild, reason: str, moderation_ty
         moderator (Union[Member, User], optional): The moderator who performed the moderation. Defaults to None.
         duration (timedelta, optional): The duration of the moderation. Defaults to None.
         response (InteractionMessage, optional): The response message. Defaults to None.
+        role (Role, optional): The role that was added or removed. Defaults to None.
+
 
     Returns:
         embed: The message embed.
     """
-    if response is not None and not moderation_type in ["kicked", "banned", "tempbanned", "unbanned"]:
+    if response is not None and moderation_type not in [
+        "kicked",
+        "banned",
+        "tempbanned",
+        "unbanned",
+    ]:
         guild_name = f"[{guild.name}]({response.jump_url})"
     else:
         guild_name = guild.name
 
     if moderation_type in ["tempbanned", "muted"] and duration:
-        embed_duration = f" for {humanize.precisedelta(duration)}"
+        embed_duration = f" for {humanize_timedelta(timedelta=duration)}"
     else:
         embed_duration = ""
 
     if moderation_type == "note":
         embed_desc = "received a"
+    elif moderation_type == "addrole":
+        embed_desc = f"received the {role.name} role"
+    elif moderation_type == "removerole":
+        embed_desc = f"lost the {role.name} role"
     else:
         embed_desc = "been"
 
-    embed = Embed(title=str.title(moderation_type), description=f"You have {embed_desc} {moderation_type}{embed_duration} in {guild_name}.", color=color, timestamp=datetime.now())
+    embed = Embed(
+        title=str.title(moderation_type),
+        description=f"You have {embed_desc} {moderation_type}{embed_duration} in {guild_name}.",
+        color=color,
+        timestamp=datetime.now(),
+    )
 
     if await config.guild(guild).show_moderator() and moderator is not None:
-        embed.add_field(name='Moderator', value=f"`{moderator.name} ({moderator.id})`", inline=False)
+        embed.add_field(
+            name="Moderator", value=f"`{moderator.name} ({moderator.id})`", inline=False
+        )
 
-    embed.add_field(name='Reason', value=f"`{reason}`", inline=False)
+    embed.add_field(name="Reason", value=f"`{reason}`", inline=False)
 
     if guild.icon.url is not None:
         embed.set_author(name=guild.name, icon_url=guild.icon.url)
     else:
         embed.set_author(name=guild.name)
 
-    embed.set_footer(text=f"Case #{await get_next_case_number(guild.id):,}", icon_url="https://cdn.discordapp.com/attachments/1070822161389994054/1159469476773904414/arrow-right-circle-icon-512x512-2p1e2aaw.png?ex=65312319&is=651eae19&hm=3cebdd28e805c13a79ec48ef87c32ca532ffa6b9ede2e48d0cf8e5e81f3a6818&")
+    embed.set_footer(
+        text=f"Case #{await get_next_case_number(guild.id):,}",
+        icon_url="https://cdn.discordapp.com/attachments/1070822161389994054/1159469476773904414/arrow-right-circle-icon-512x512-2p1e2aaw.png?ex=65312319&is=651eae19&hm=3cebdd28e805c13a79ec48ef87c32ca532ffa6b9ede2e48d0cf8e5e81f3a6818&",
+    )
 
     return embed
 
-async def log_factory(interaction: Interaction, case_dict: dict, resolved: bool = False) -> Embed:
+
+async def log_factory(
+    interaction: Interaction, case_dict: dict, resolved: bool = False
+) -> Embed:
     """This function creates a log embed from set parameters, meant for moderation logging.
 
     Args:
@@ -66,57 +102,115 @@ async def log_factory(interaction: Interaction, case_dict: dict, resolved: bool
         resolved (bool, optional): Whether the case is resolved or not. Defaults to False.
     """
     if resolved:
-        if case_dict['target_type'] == 'USER':
+        if case_dict["target_type"] == "USER":
-            target_user = await fetch_user_dict(interaction, case_dict['target_id'])
+            target_user = await fetch_user_dict(interaction.client, case_dict["target_id"])
-            target_name = f"`{target_user['name']}`" if target_user['discriminator'] == "0" else f"`{target_user['name']}#{target_user['discriminator']}`"
+            target_name = (
-        elif case_dict['target_type'] == 'CHANNEL':
+                f"`{target_user['name']}`"
-            target_user = await fetch_channel_dict(interaction, case_dict['target_id'])
+                if target_user["discriminator"] == "0"
-            if target_user['mention']:
+                else f"`{target_user['name']}#{target_user['discriminator']}`"
+            )
+        elif case_dict["target_type"] == "CHANNEL":
+            target_user = await fetch_channel_dict(interaction.guild, case_dict["target_id"])
+            if target_user["mention"]:
                 target_name = f"{target_user['mention']}"
             else:
                 target_name = f"`{target_user['name']}`"
 
-        moderator_user = await fetch_user_dict(interaction, case_dict['moderator_id'])
+        moderator_user = await fetch_user_dict(interaction.client, case_dict["moderator_id"])
-        moderator_name = f"`{moderator_user['name']}`" if moderator_user['discriminator'] == "0" else f"`{moderator_user['name']}#{moderator_user['discriminator']}`"
+        moderator_name = (
+            f"`{moderator_user['name']}`"
+            if moderator_user["discriminator"] == "0"
+            else f"`{moderator_user['name']}#{moderator_user['discriminator']}`"
+        )
 
-        embed = Embed(title=f"📕 Case #{case_dict['moderation_id']:,} Resolved", color=await interaction.client.get_embed_color(interaction.channel))
+        embed = Embed(
+            title=f"📕 Case #{case_dict['moderation_id']:,} Resolved",
+            color=await interaction.client.get_embed_color(interaction.channel),
+        )
 
         embed.description = f"**Type:** {str.title(case_dict['moderation_type'])}\n**Target:** {target_name} ({target_user['id']})\n**Moderator:** {moderator_name} ({moderator_user['id']})\n**Timestamp:** <t:{case_dict['timestamp']}> | <t:{case_dict['timestamp']}:R>"
 
-        if case_dict['duration'] != 'NULL':
+        if case_dict["duration"] != "NULL":
-            td = timedelta(**{unit: int(val) for unit, val in zip(["hours", "minutes", "seconds"], case_dict["duration"].split(":"))})
+            td = timedelta(
-            duration_embed = f"{humanize.precisedelta(td)} | <t:{case_dict['end_timestamp']}:R>" if case_dict["expired"] == '0' else str(humanize.precisedelta(td))
+                **{
-            embed.description = embed.description + f"\n**Duration:** {duration_embed}\n**Expired:** {bool(case_dict['expired'])}"
+                    unit: int(val)
+                    for unit, val in zip(
+                        ["hours", "minutes", "seconds"],
+                        case_dict["duration"].split(":"),
+                    )
+                }
+            )
+            duration_embed = (
+                f"{humanize_timedelta(timedelta=td)} | <t:{case_dict['end_timestamp']}:R>"
+                if case_dict["expired"] == "0"
+                else str(humanize_timedelta(timedelta=td))
+            )
+            embed.description = (
+                embed.description
+                + f"\n**Duration:** {duration_embed}\n**Expired:** {bool(case_dict['expired'])}"
+            )
 
-        embed.add_field(name='Reason', value=box(case_dict['reason']), inline=False)
+        embed.add_field(name="Reason", value=box(case_dict["reason"]), inline=False)
 
-        resolved_user = await fetch_user_dict(interaction, case_dict['resolved_by'])
+        resolved_user = await fetch_user_dict(interaction.client, case_dict["resolved_by"])
-        resolved_name = resolved_user['name'] if resolved_user['discriminator'] == "0" else f"{resolved_user['name']}#{resolved_user['discriminator']}"
+        resolved_name = (
-        embed.add_field(name='Resolve Reason', value=f"Resolved by `{resolved_name}` ({resolved_user['id']}) for:\n" + box(case_dict['resolve_reason']), inline=False)
+            resolved_user["name"]
+            if resolved_user["discriminator"] == "0"
+            else f"{resolved_user['name']}#{resolved_user['discriminator']}"
+        )
+        embed.add_field(
+            name="Resolve Reason",
+            value=f"Resolved by `{resolved_name}` ({resolved_user['id']}) for:\n"
+            + box(case_dict["resolve_reason"]),
+            inline=False,
+        )
     else:
-        if case_dict['target_type'] == 'USER':
+        if case_dict["target_type"] == "USER":
-            target_user = await fetch_user_dict(interaction, case_dict['target_id'])
+            target_user = await fetch_user_dict(interaction.client, case_dict["target_id"])
-            target_name = f"`{target_user['name']}`" if target_user['discriminator'] == "0" else f"`{target_user['name']}#{target_user['discriminator']}`"
+            target_name = (
-        elif case_dict['target_type'] == 'CHANNEL':
+                f"`{target_user['name']}`"
-            target_user = await fetch_channel_dict(interaction, case_dict['target_id'])
+                if target_user["discriminator"] == "0"
-            if target_user['mention']:
+                else f"`{target_user['name']}#{target_user['discriminator']}`"
-                target_name = target_user['mention']
+            )
+        elif case_dict["target_type"] == "CHANNEL":
+            target_user = await fetch_channel_dict(interaction.guild, case_dict["target_id"])
+            if target_user["mention"]:
+                target_name = target_user["mention"]
             else:
                 target_name = f"`{target_user['name']}`"
 
-        moderator_user = await fetch_user_dict(interaction, case_dict['moderator_id'])
+        moderator_user = await fetch_user_dict(interaction.client, case_dict["moderator_id"])
-        moderator_name = f"`{moderator_user['name']}`" if moderator_user['discriminator'] == "0" else f"`{moderator_user['name']}#{moderator_user['discriminator']}`"
+        moderator_name = (
+            f"`{moderator_user['name']}`"
+            if moderator_user["discriminator"] == "0"
+            else f"`{moderator_user['name']}#{moderator_user['discriminator']}`"
+        )
 
-        embed = Embed(title=f"📕 Case #{case_dict['moderation_id']:,}", color=await interaction.client.get_embed_color(interaction.channel))
+        embed = Embed(
+            title=f"📕 Case #{case_dict['moderation_id']:,}",
+            color=await interaction.client.get_embed_color(interaction.channel),
+        )
         embed.description = f"**Type:** {str.title(case_dict['moderation_type'])}\n**Target:** {target_name} ({target_user['id']})\n**Moderator:** {moderator_name} ({moderator_user['id']})\n**Timestamp:** <t:{case_dict['timestamp']}> | <t:{case_dict['timestamp']}:R>"
 
-        if case_dict['duration'] != 'NULL':
+        if case_dict["duration"] != "NULL":
-            td = timedelta(**{unit: int(val) for unit, val in zip(["hours", "minutes", "seconds"], case_dict["duration"].split(":"))})
+            td = timedelta(
-            embed.description = embed.description + f"\n**Duration:** {humanize.precisedelta(td)} | <t:{case_dict['end_timestamp']}:R>"
+                **{
+                    unit: int(val)
+                    for unit, val in zip(
+                        ["hours", "minutes", "seconds"],
+                        case_dict["duration"].split(":"),
+                    )
+                }
+            )
+            embed.description = (
+                embed.description
+                + f"\n**Duration:** {humanize_timedelta(timedelta=td)} | <t:{case_dict['end_timestamp']}:R>"
+            )
 
-        embed.add_field(name='Reason', value=box(case_dict['reason']), inline=False)
+        embed.add_field(name="Reason", value=box(case_dict["reason"]), inline=False)
     return embed
 
+
 async def case_factory(interaction: Interaction, case_dict: dict) -> Embed:
     """This function creates a case embed from set parameters.
 
@@ -124,42 +218,79 @@ async def case_factory(interaction: Interaction, case_dict: dict) -> Embed:
         interaction (Interaction): The interaction object.
         case_dict (dict): The case dictionary.
     """
-    if case_dict['target_type'] == 'USER':
+    if case_dict["target_type"] == "USER":
-        target_user = await fetch_user_dict(interaction, case_dict['target_id'])
+        target_user = await fetch_user_dict(interaction.client, case_dict["target_id"])
-        target_name = f"`{target_user['name']}`" if target_user['discriminator'] == "0" else f"`{target_user['name']}#{target_user['discriminator']}`"
+        target_name = (
-    elif case_dict['target_type'] == 'CHANNEL':
+            f"`{target_user['name']}`"
-        target_user = await fetch_channel_dict(interaction, case_dict['target_id'])
+            if target_user["discriminator"] == "0"
-        if target_user['mention']:
+            else f"`{target_user['name']}#{target_user['discriminator']}`"
+        )
+    elif case_dict["target_type"] == "CHANNEL":
+        target_user = await fetch_channel_dict(interaction.guild, case_dict["target_id"])
+        if target_user["mention"]:
             target_name = f"{target_user['mention']}"
         else:
             target_name = f"`{target_user['name']}`"
 
-    moderator_user = await fetch_user_dict(interaction, case_dict['moderator_id'])
+    moderator_user = await fetch_user_dict(interaction.client, case_dict["moderator_id"])
-    moderator_name = f"`{moderator_user['name']}`" if moderator_user['discriminator'] == "0" else f"`{moderator_user['name']}#{moderator_user['discriminator']}`"
+    moderator_name = (
+        f"`{moderator_user['name']}`"
+        if moderator_user["discriminator"] == "0"
+        else f"`{moderator_user['name']}#{moderator_user['discriminator']}`"
+    )
 
-    embed = Embed(title=f"📕 Case #{case_dict['moderation_id']:,}", color=await interaction.client.get_embed_color(interaction.channel))
+    embed = Embed(
+        title=f"📕 Case #{case_dict['moderation_id']:,}",
+        color=await interaction.client.get_embed_color(interaction.channel),
+    )
     embed.description = f"**Type:** {str.title(case_dict['moderation_type'])}\n**Target:** {target_name} ({target_user['id']})\n**Moderator:** {moderator_name} ({moderator_user['id']})\n**Resolved:** {bool(case_dict['resolved'])}\n**Timestamp:** <t:{case_dict['timestamp']}> | <t:{case_dict['timestamp']}:R>"
 
-    if case_dict['duration'] != 'NULL':
+    if case_dict["duration"] != "NULL":
-        td = timedelta(**{unit: int(val) for unit, val in zip(["hours", "minutes", "seconds"], case_dict["duration"].split(":"))})
+        td = timedelta(
-        duration_embed = f"{humanize.precisedelta(td)} | <t:{case_dict['end_timestamp']}:R>" if bool(case_dict['expired']) is False else str(humanize.precisedelta(td))
+            **{
+                unit: int(val)
+                for unit, val in zip(
+                    ["hours", "minutes", "seconds"], case_dict["duration"].split(":")
+                )
+            }
+        )
+        duration_embed = (
+            f"{humanize_timedelta(timedelta=td)} | <t:{case_dict['end_timestamp']}:R>"
+            if bool(case_dict["expired"]) is False
+            else str(humanize_timedelta(timedelta=td))
+        )
         embed.description += f"\n**Duration:** {duration_embed}\n**Expired:** {bool(case_dict['expired'])}"
 
-    embed.description += f"\n**Changes:** {len(case_dict['changes']) - 1}" if case_dict['changes'] else "\n**Changes:** 0"
+    embed.description += (
+        f"\n**Changes:** {len(case_dict['changes']) - 1}"
+        if case_dict["changes"]
+        else "\n**Changes:** 0"
+    )
 
-    if case_dict['metadata']:
+    if case_dict["metadata"]:
-        if case_dict['metadata']['imported_from']:
+        if case_dict["metadata"]["imported_from"]:
-            embed.description += f"\n**Imported From:** {case_dict['metadata']['imported_from']}"
+            embed.description += (
+                f"\n**Imported From:** {case_dict['metadata']['imported_from']}"
+            )
 
-    embed.add_field(name='Reason', value=box(case_dict['reason']), inline=False)
+    embed.add_field(name="Reason", value=box(case_dict["reason"]), inline=False)
 
-    if case_dict['resolved'] == 1:
+    if case_dict["resolved"] == 1:
-        resolved_user = await fetch_user_dict(interaction, case_dict['resolved_by'])
+        resolved_user = await fetch_user_dict(interaction.client, case_dict["resolved_by"])
-        resolved_name = f"`{resolved_user['name']}`" if resolved_user['discriminator'] == "0" else f"`{resolved_user['name']}#{resolved_user['discriminator']}`"
+        resolved_name = (
-        embed.add_field(name='Resolve Reason', value=f"Resolved by {resolved_name} ({resolved_user['id']}) for:\n{box(case_dict['resolve_reason'])}", inline=False)
+            f"`{resolved_user['name']}`"
+            if resolved_user["discriminator"] == "0"
+            else f"`{resolved_user['name']}#{resolved_user['discriminator']}`"
+        )
+        embed.add_field(
+            name="Resolve Reason",
+            value=f"Resolved by {resolved_name} ({resolved_user['id']}) for:\n{box(case_dict['resolve_reason'])}",
+            inline=False,
+        )
 
     return embed
 
+
 async def changes_factory(interaction: Interaction, case_dict: dict) -> Embed:
     """This function creates a changes embed from set parameters.
 
@@ -167,34 +298,56 @@ async def changes_factory(interaction: Interaction, case_dict: dict) -> Embed:
         interaction (Interaction): The interaction object.
         case_dict (dict): The case dictionary.
     """
-    embed = Embed(title=f"📕 Case #{case_dict['moderation_id']:,} Changes", color=await interaction.client.get_embed_color(interaction.channel))
+    embed = Embed(
+        title=f"📕 Case #{case_dict['moderation_id']:,} Changes",
+        color=await interaction.client.get_embed_color(interaction.channel),
+    )
 
     memory_dict = {}
 
-    if case_dict['changes']:
+    if case_dict["changes"]:
-        for change in case_dict['changes']:
+        for change in case_dict["changes"]:
-            if change['user_id'] not in memory_dict:
+            if change["user_id"] not in memory_dict:
-                memory_dict[str(change['user_id'])] = await fetch_user_dict(interaction, change['user_id'])
+                memory_dict[str(change["user_id"])] = await fetch_user_dict(
+                    interaction.client, change["user_id"]
+                )
 
-            user = memory_dict[str(change['user_id'])]
+            user = memory_dict[str(change["user_id"])]
-            name = user['name'] if user['discriminator'] == "0" else f"{user['name']}#{user['discriminator']}"
+            name = (
+                user["name"]
+                if user["discriminator"] == "0"
+                else f"{user['name']}#{user['discriminator']}"
+            )
 
             timestamp = f"<t:{change['timestamp']}> | <t:{change['timestamp']}:R>"
 
-            if change['type'] == 'ORIGINAL':
+            if change["type"] == "ORIGINAL":
-                embed.add_field(name='Original', value=f"**User:** `{name}` ({user['id']})\n**Reason:** {change['reason']}\n**Timestamp:** {timestamp}", inline=False)
+                embed.add_field(
+                    name="Original",
+                    value=f"**User:** `{name}` ({user['id']})\n**Reason:** {change['reason']}\n**Timestamp:** {timestamp}",
+                    inline=False,
+                )
 
-            elif change['type'] == 'EDIT':
+            elif change["type"] == "EDIT":
-                embed.add_field(name='Edit', value=f"**User:** `{name}` ({user['id']})\n**Reason:** {change['reason']}\n**Timestamp:** {timestamp}", inline=False)
+                embed.add_field(
+                    name="Edit",
+                    value=f"**User:** `{name}` ({user['id']})\n**Reason:** {change['reason']}\n**Timestamp:** {timestamp}",
+                    inline=False,
+                )
 
-            elif change['type'] == 'RESOLVE':
+            elif change["type"] == "RESOLVE":
-                embed.add_field(name='Resolve', value=f"**User:** `{name}` ({user['id']})\n**Reason:** {change['reason']}\n**Timestamp:** {timestamp}", inline=False)
+                embed.add_field(
+                    name="Resolve",
+                    value=f"**User:** `{name}` ({user['id']})\n**Reason:** {change['reason']}\n**Timestamp:** {timestamp}",
+                    inline=False,
+                )
 
     else:
         embed.description = "*No changes have been made to this case.* 🙁"
 
     return embed
 
+
 async def evidenceformat_factory(interaction: Interaction, case_dict: dict) -> str:
     """This function creates a codeblock in evidence format from set parameters.
 
@@ -202,24 +355,261 @@ async def evidenceformat_factory(interaction: Interaction, case_dict: dict) -> s
         interaction (Interaction): The interaction object.
         case_dict (dict): The case dictionary.
     """
-    if case_dict['target_type'] == 'USER':
+    if case_dict["target_type"] == "USER":
-        target_user = await fetch_user_dict(interaction, case_dict['target_id'])
+        target_user = await fetch_user_dict(interaction.client, case_dict["target_id"])
-        target_name = target_user['name'] if target_user['discriminator'] == "0" else f"{target_user['name']}#{target_user['discriminator']}"
+        target_name = (
+            target_user["name"]
+            if target_user["discriminator"] == "0"
+            else f"{target_user['name']}#{target_user['discriminator']}"
+        )
 
-    elif case_dict['target_type'] == 'CHANNEL':
+    elif case_dict["target_type"] == "CHANNEL":
-        target_user = await fetch_channel_dict(interaction, case_dict['target_id'])
+        target_user = await fetch_channel_dict(interaction.guild, case_dict["target_id"])
-        target_name = target_user['name']
+        target_name = target_user["name"]
 
-    moderator_user = await fetch_user_dict(interaction, case_dict['moderator_id'])
+    moderator_user = await fetch_user_dict(interaction.client, case_dict["moderator_id"])
-    moderator_name = moderator_user['name'] if moderator_user['discriminator'] == "0" else f"{moderator_user['name']}#{moderator_user['discriminator']}"
+    moderator_name = (
+        moderator_user["name"]
+        if moderator_user["discriminator"] == "0"
+        else f"{moderator_user['name']}#{moderator_user['discriminator']}"
+    )
 
     content = f"Case: {case_dict['moderation_id']:,} ({str.title(case_dict['moderation_type'])})\nTarget: {target_name} ({target_user['id']})\nModerator: {moderator_name} ({moderator_user['id']})"
 
-    if case_dict['duration'] != 'NULL':
+    if case_dict["duration"] != "NULL":
-        hours, minutes, seconds = map(int, case_dict['duration'].split(':'))
+        hours, minutes, seconds = map(int, case_dict["duration"].split(":"))
         td = timedelta(hours=hours, minutes=minutes, seconds=seconds)
-        content += f"\nDuration: {humanize.precisedelta(td)}"
+        content += f"\nDuration: {humanize_timedelta(timedelta=td)}"
 
     content += f"\nReason: {case_dict['reason']}"
 
-    return box(content, 'prolog')
+    return box(content, "prolog")
+
+
+########################################################################################################################
+### Configuration Embeds                                                                                               #
+########################################################################################################################
+
+
+async def _config(ctx: commands.Context) -> Embed:
+    """Generates the core embed for configuration menus to use."""
+    e = Embed(title="Aurora Configuration Menu", color=await ctx.embed_color())
+    e.set_thumbnail(url=ctx.bot.user.display_avatar.url)
+    return e
+
+
+async def overrides_embed(ctx: commands.Context) -> Embed:
+    """Generates a configuration menu embed for a user's overrides."""
+
+    override_settings = {
+        "ephemeral": await config.user(ctx.author).history_ephemeral(),
+        "inline": await config.user(ctx.author).history_inline(),
+        "inline_pagesize": await config.user(ctx.author).history_inline_pagesize(),
+        "pagesize": await config.user(ctx.author).history_pagesize(),
+        "auto_evidenceformat": await config.user(ctx.author).auto_evidenceformat(),
+    }
+
+    override_str = [
+        "- "
+        + bold("Auto Evidence Format: ")
+        + get_bool_emoji(override_settings["auto_evidenceformat"]),
+        "- " + bold("Ephemeral: ") + get_bool_emoji(override_settings["ephemeral"]),
+        "- " + bold("History Inline: ") + get_bool_emoji(override_settings["inline"]),
+        "- "
+        + bold("History Inline Pagesize: ")
+        + get_pagesize_str(override_settings["inline_pagesize"]),
+        "- "
+        + bold("History Pagesize: ")
+        + get_pagesize_str(override_settings["pagesize"]),
+    ]
+    override_str = "\n".join(override_str)
+
+    e = await _config(ctx)
+    e.title += ": User Overrides"
+    e.description = (
+        """
+    Use the buttons below to manage your user overrides.
+    These settings will override the relevant guild settings.\n
+    """
+        + override_str
+    )
+    return e
+
+
+async def guild_embed(ctx: commands.Context) -> Embed:
+    """Generates a configuration menu field value for a guild's settings."""
+
+    guild_settings = {
+        "show_moderator": await config.guild(ctx.guild).show_moderator(),
+        "use_discord_permissions": await config.guild(
+            ctx.guild
+        ).use_discord_permissions(),
+        "ignore_modlog": await config.guild(ctx.guild).ignore_modlog(),
+        "ignore_other_bots": await config.guild(ctx.guild).ignore_other_bots(),
+        "dm_users": await config.guild(ctx.guild).dm_users(),
+        "log_channel": await config.guild(ctx.guild).log_channel(),
+        "history_ephemeral": await config.guild(ctx.guild).history_ephemeral(),
+        "history_inline": await config.guild(ctx.guild).history_inline(),
+        "history_pagesize": await config.guild(ctx.guild).history_pagesize(),
+        "history_inline_pagesize": await config.guild(
+            ctx.guild
+        ).history_inline_pagesize(),
+        "auto_evidenceformat": await config.guild(ctx.guild).auto_evidenceformat(),
+        "respect_hierarchy": await config.guild(ctx.guild).respect_hierarchy(),
+    }
+
+    channel = ctx.guild.get_channel(guild_settings["log_channel"])
+    if channel is None:
+        channel = warning("Not Set")
+    else:
+        channel = channel.mention
+
+    guild_str = [
+        "- "
+        + bold("Show Moderator: ")
+        + get_bool_emoji(guild_settings["show_moderator"]),
+        "- "
+        + bold("Use Discord Permissions: ")
+        + get_bool_emoji(guild_settings["use_discord_permissions"]),
+        "- "
+        + bold("Respect Hierarchy: ")
+        + get_bool_emoji(guild_settings["respect_hierarchy"]),
+        "- "
+        + bold("Ignore Modlog: ")
+        + get_bool_emoji(guild_settings["ignore_modlog"]),
+        "- "
+        + bold("Ignore Other Bots: ")
+        + get_bool_emoji(guild_settings["ignore_other_bots"]),
+        "- " + bold("DM Users: ") + get_bool_emoji(guild_settings["dm_users"]),
+        "- "
+        + bold("Auto Evidence Format: ")
+        + get_bool_emoji(guild_settings["auto_evidenceformat"]),
+        "- "
+        + bold("Ephemeral: ")
+        + get_bool_emoji(guild_settings["history_ephemeral"]),
+        "- "
+        + bold("History Inline: ")
+        + get_bool_emoji(guild_settings["history_inline"]),
+        "- "
+        + bold("History Pagesize: ")
+        + get_pagesize_str(guild_settings["history_pagesize"]),
+        "- "
+        + bold("History Inline Pagesize: ")
+        + get_pagesize_str(guild_settings["history_inline_pagesize"]),
+        "- " + bold("Log Channel: ") + channel,
+    ]
+    guild_str = "\n".join(guild_str)
+
+    e = await _config(ctx)
+    e.title += ": Server Configuration"
+    e.description = (
+        """
+    Use the buttons below to manage Aurora's server configuration.\n
+    """
+        + guild_str
+    )
+    return e
+
+
+async def addrole_embed(ctx: commands.Context) -> Embed:
+    """Generates a configuration menu field value for a guild's addrole whitelist."""
+
+    roles = []
+    async with config.guild(ctx.guild).addrole_whitelist() as whitelist:
+        for role in whitelist:
+            evalulated_role = ctx.guild.get_role(role) or error(f"`{role}` (Not Found)")
+            if isinstance(evalulated_role, Role):
+                roles.append({
+                    "id": evalulated_role.id,
+                    "mention": evalulated_role.mention,
+                    "position": evalulated_role.position
+                })
+            else:
+                roles.append({
+                    "id": role,
+                    "mention": error(f"`{role}` (Not Found)"),
+                    "position": 0
+                })
+
+    if roles:
+        roles = sorted(roles, key=lambda x: x["position"], reverse=True)
+        roles = [role["mention"] for role in roles]
+        whitelist_str = "\n".join(roles)
+    else:
+        whitelist_str = warning("No roles are on the addrole whitelist!")
+
+    e = await _config(ctx)
+    e.title += ": Addrole Whitelist"
+    e.description = (
+        "Use the select menu below to manage this guild's addrole whitelist."
+    )
+
+    if len(whitelist_str) > 4000 and len(whitelist_str) < 5000:
+        lines = whitelist_str.split("\n")
+        chunks = []
+        chunk = ""
+        for line in lines:
+            if len(chunk) + len(line) > 1024:
+                chunks.append(chunk)
+                chunk = line
+            else:
+                chunk += "\n" + line if chunk else line
+        chunks.append(chunk)
+
+        for chunk in chunks:
+            e.add_field(name="", value=chunk)
+    else:
+        e.description += "\n\n" + whitelist_str
+
+    return e
+
+
+async def immune_embed(ctx: commands.Context) -> Embed:
+    """Generates a configuration menu embed for a guild's immune roles."""
+
+    roles = []
+    async with config.guild(ctx.guild).immune_roles() as immune_roles:
+        for role in immune_roles:
+            evalulated_role = ctx.guild.get_role(role) or error(f"`{role}` (Not Found)")
+            if isinstance(evalulated_role, Role):
+                roles.append({
+                    "id": evalulated_role.id,
+                    "mention": evalulated_role.mention,
+                    "position": evalulated_role.position
+                })
+            else:
+                roles.append({
+                    "id": role,
+                    "mention": error(f"`{role}` (Not Found)"),
+                    "position": 0
+                })
+
+    if roles:
+        roles = sorted(roles, key=lambda x: x["position"], reverse=True)
+        roles = [role["mention"] for role in roles]
+        immune_str = "\n".join(roles)
+    else:
+        immune_str = warning("No roles are set as immune roles!")
+
+    e = await _config(ctx)
+    e.title += ": Immune Roles"
+    e.description = "Use the select menu below to manage this guild's immune roles."
+
+    if len(immune_str) > 4000 and len(immune_str) < 5000:
+        lines = immune_str.split("\n")
+        chunks = []
+        chunk = ""
+        for line in lines:
+            if len(chunk) + len(line) > 1024:
+                chunks.append(chunk)
+                chunk = line
+            else:
+                chunk += "\n" + line if chunk else line
+        chunks.append(chunk)
+
+        for chunk in chunks:
+            e.add_field(name="", value=chunk)
+    else:
+        e.description += "\n\n" + immune_str
+
+    return e

aurora/utilities/logger.py

@@ -1,3 +1,3 @@
-import logging
+from red_commons.logging import getLogger
 
-logger = logging.getLogger("red.sea.aurora")
+logger = getLogger("red.SeaCogs.Aurora")

aurora/utilities/utils.py

@@ -1,10 +1,11 @@
 # pylint: disable=cyclic-import
-
 import json
+from datetime import datetime
 from datetime import timedelta as td
-from typing import Union
+from typing import Optional, Union
 
-from discord import Guild, Interaction, Member, User
+from dateutil.relativedelta import relativedelta as rd
+from discord import Guild, Interaction, Member, SelectOption, User
 from discord.errors import Forbidden, NotFound
 from redbot.core import commands
 from redbot.core.utils.chat_formatting import error
@@ -17,7 +18,7 @@ def check_permissions(
     permissions: list,
     ctx: Union[commands.Context, Interaction] = None,
     guild: Guild = None,
-):
+) -> Union[bool, str]:
     """Checks if a user has a specific permission (or a list of permissions) in a channel."""
     if ctx:
         member = ctx.guild.get_member(user.id)
@@ -33,7 +34,7 @@ def check_permissions(
     for permission in permissions:
         if (
             not getattr(resolved_permissions, permission, False)
-            and not resolved_permissions.administrator is True
+            and resolved_permissions.administrator is not True
         ):
             return permission
 
@@ -42,11 +43,13 @@ def check_permissions(
 
 async def check_moddable(
     target: Union[User, Member], interaction: Interaction, permissions: list
-):
+) -> bool:
     """Checks if a moderator can moderate a target."""
     if check_permissions(interaction.client.user, permissions, guild=interaction.guild):
         await interaction.response.send_message(
-            error(f"I do not have the `{permissions}` permission, required for this action."),
+            error(
+                f"I do not have the `{permissions}` permission, required for this action."
+            ),
             ephemeral=True,
         )
         return False
@@ -54,7 +57,9 @@ async def check_moddable(
     if await config.guild(interaction.guild).use_discord_permissions() is True:
         if check_permissions(interaction.user, permissions, guild=interaction.guild):
             await interaction.response.send_message(
-                error(f"You do not have the `{permissions}` permission, required for this action."),
+                error(
+                    f"You do not have the `{permissions}` permission, required for this action."
+                ),
                 ephemeral=True,
             )
             return False
@@ -72,9 +77,11 @@ async def check_moddable(
         return False
 
     if isinstance(target, Member):
-        if interaction.user.top_role <= target.top_role:
+        if interaction.user.top_role <= target.top_role and await config.guild(interaction.guild).respect_hierarchy() is True:
             await interaction.response.send_message(
-                content=error("You cannot moderate members with a higher role than you!"),
+                content=error(
+                    "You cannot moderate members with a higher role than you!"
+                ),
                 ephemeral=True,
             )
             return False
@@ -84,7 +91,9 @@ async def check_moddable(
             <= target.top_role
         ):
             await interaction.response.send_message(
-                content=error("You cannot moderate members with a role higher than the bot!"),
+                content=error(
+                    "You cannot moderate members with a role higher than the bot!"
+                ),
                 ephemeral=True,
             )
             return False
@@ -116,8 +125,8 @@ async def get_next_case_number(guild_id: str, cursor = None) -> int:
     return (result[0] + 1) if result else 1
 
 
-def generate_dict(result):
+def generate_dict(result) -> dict:
-    case: dict = {
+    case = {
         "moderation_id": result[0],
         "timestamp": result[1],
         "moderation_type": result[2],
@@ -133,21 +142,21 @@ def generate_dict(result):
         "resolve_reason": result[12],
         "expired": result[13],
         "changes": json.loads(result[14]),
-        "metadata": json.loads(result[15])
+        "metadata": json.loads(result[15]),
     }
     return case
 
 
-async def fetch_user_dict(interaction: Interaction, user_id: str):
+async def fetch_user_dict(client: commands.Bot, user_id: str) -> dict:
     """This function returns a dictionary containing either user information or a standard deleted user template."""
     if user_id == "?":
         user_dict = {"id": "?", "name": "Unknown User", "discriminator": "0"}
 
     else:
         try:
-            user = interaction.client.get_user(user_id)
+            user = client.get_user(int(user_id))
             if user is None:
-                user = await interaction.client.fetch_user(user_id)
+                user = await client.fetch_user(int(user_id))
 
             user_dict = {
                 "id": user.id,
@@ -162,17 +171,22 @@ async def fetch_user_dict(interaction: Interaction, user_id: str):
                 "discriminator": "0",
             }
 
+
     return user_dict
 
 
-async def fetch_channel_dict(interaction: Interaction, channel_id: str):
+async def fetch_channel_dict(guild: Guild, channel_id: int) -> dict:
     """This function returns a dictionary containing either channel information or a standard deleted channel template."""
     try:
-        channel = interaction.guild.get_channel(channel_id)
+        channel = guild.get_channel(int(channel_id))
         if not channel:
-            channel = await interaction.guild.fetch_channel(channel_id)
+            channel = await guild.fetch_channel(channel_id)
 
-        channel_dict = {"id": channel.id, "name": channel.name, "mention": channel.mention}
+        channel_dict = {
+            "id": channel.id,
+            "name": channel.name,
+            "mention": channel.mention,
+        }
 
     except NotFound:
         channel_dict = {"id": channel_id, "name": "Deleted Channel", "mention": None}
@@ -180,9 +194,9 @@ async def fetch_channel_dict(interaction: Interaction, channel_id: str):
     return channel_dict
 
 
-async def fetch_role_dict(interaction: Interaction, role_id: str):
+async def fetch_role_dict(guild: Guild, role_id: int) -> dict:
     """This function returns a dictionary containing either role information or a standard deleted role template."""
-    role = interaction.guild.get_role(role_id)
+    role = guild.get_role(int(role_id))
     if not role:
         role_dict = {"id": role_id, "name": "Deleted Role"}
 
@@ -191,7 +205,7 @@ async def fetch_role_dict(interaction: Interaction, role_id: str):
     return role_dict
 
 
-async def log(interaction: Interaction, moderation_id: int, resolved: bool = False):
+async def log(interaction: Interaction, moderation_id: int, resolved: bool = False) -> None:
     """This function sends a message to the guild's configured logging channel when an infraction takes place."""
     from .database import fetch_case
     from .factory import log_factory
@@ -202,25 +216,31 @@ async def log(interaction: Interaction, moderation_id: int, resolved: bool = Fal
 
         case = await fetch_case(moderation_id, interaction.guild.id)
         if case:
-            embed = await log_factory(interaction=interaction, case_dict=case, resolved=resolved)
+            embed = await log_factory(
+                interaction=interaction, case_dict=case, resolved=resolved
+            )
             try:
                 await logging_channel.send(embed=embed)
             except Forbidden:
                 return
 
-async def send_evidenceformat(interaction: Interaction, case_dict: dict):
+
+async def send_evidenceformat(interaction: Interaction, case_dict: dict) -> None:
     """This function sends an ephemeral message to the moderator who took the moderation action, with a pre-made codeblock for use in the mod-evidence channel."""
     from .factory import evidenceformat_factory
 
-    send_evidence_bool = (await config.user(interaction.user).auto_evidenceformat()
+    send_evidence_bool = (
+        await config.user(interaction.user).auto_evidenceformat()
         or await config.guild(interaction.guild).auto_evidenceformat()
-        or False)
+        or False
+    )
     if send_evidence_bool is False:
         return
 
     content = await evidenceformat_factory(interaction=interaction, case_dict=case_dict)
     await interaction.followup.send(content=content, ephemeral=True)
 
+
 def convert_timedelta_to_str(timedelta: td) -> str:
     """This function converts a timedelta object to a string."""
     total_seconds = int(timedelta.total_seconds())
@@ -228,3 +248,46 @@ def convert_timedelta_to_str(timedelta: td) -> str:
     minutes = (total_seconds % 3600) // 60
     seconds = total_seconds % 60
     return f"{hours}:{minutes}:{seconds}"
+
+
+def get_bool_emoji(value: Optional[bool]) -> str:
+    """Returns a unicode emoji based on a boolean value."""
+    if value is True:
+        return "\N{WHITE HEAVY CHECK MARK}"
+    if value is False:
+        return "\N{NO ENTRY SIGN}"
+    return "\N{BLACK QUESTION MARK ORNAMENT}\N{VARIATION SELECTOR-16}"
+
+
+def get_pagesize_str(value: Union[int, None]) -> str:
+    """Returns a string based on a pagesize value."""
+    if value is None:
+        return "\N{BLACK QUESTION MARK ORNAMENT}\N{VARIATION SELECTOR-16}"
+    return str(value) + " cases per page"
+
+
+def create_pagesize_options() -> list[SelectOption]:
+    """Returns a list of SelectOptions for pagesize configuration."""
+    options = []
+    options.append(
+        SelectOption(
+            label="Default",
+            value="default",
+            description="Reset the pagesize to the default value.",
+        )
+    )
+    for i in range(1, 21):
+        options.append(
+            SelectOption(
+                label=str(i),
+                value=str(i),
+                description=f"Set the pagesize to {i}.",
+            )
+        )
+    return options
+
+def timedelta_from_relativedelta(relativedelta: rd) -> td:
+    """Converts a relativedelta object to a timedelta object."""
+    now = datetime.now()
+    then = now - relativedelta
+    return now - then

backup/__init__.py

@@ -0,0 +1,5 @@
+from .backup import Backup
+
+
+async def setup(bot):
+    await bot.add_cog(Backup(bot))

backup/backup.py

@@ -0,0 +1,142 @@
+#   _____                         _
+#  / ____|                       (_)
+# | (___   ___  __ _ _____      ___ _ __ ___  _ __ ___   ___ _ __
+#  \___ \ / _ \/ _` / __\ \ /\ / / | '_ ` _ \| '_ ` _ \ / _ \ '__|
+#  ____) |  __/ (_| \__ \\ V  V /| | | | | | | | | | | |  __/ |
+# |_____/ \___|\__,_|___/ \_/\_/ |_|_| |_| |_|_| |_| |_|\___|_|
+
+import contextlib
+import json
+import re
+
+from red_commons.logging import getLogger
+from redbot.cogs.downloader import errors
+from redbot.cogs.downloader.converters import InstalledCog
+from redbot.core import commands
+from redbot.core.bot import Red
+from redbot.core.utils.chat_formatting import error, humanize_list, text_to_file
+
+
+# pylint: disable=protected-access
+class Backup(commands.Cog):
+    """A utility to make reinstalling repositories and cogs after migrating the bot far easier."""
+
+    __author__ = ["SeaswimmerTheFsh"]
+    __version__ = "1.1.0"
+    __documentation__ = "https://seacogs.coastalcommits.com/backup/"
+
+    def __init__(self, bot: Red):
+        super().__init__()
+        self.bot = bot
+        self.logger = getLogger("red.SeaCogs.Backup")
+
+    def format_help_for_context(self, ctx: commands.Context) -> str:
+        pre_processed = super().format_help_for_context(ctx) or ""
+        n = "\n" if "\n\n" not in pre_processed else ""
+        text = [
+            f"{pre_processed}{n}",
+            f"Cog Version: **{self.__version__}**",
+            f"Author: {humanize_list(self.__author__)}",
+            f"Documentation: {self.__documentation__}",
+        ]
+        return "\n".join(text)
+
+    @commands.group(autohelp=True)
+    @commands.is_owner()
+    async def backup(self, ctx: commands.Context):
+        """Backup your installed cogs."""
+
+    @backup.command(name="export")
+    @commands.is_owner()
+    async def backup_export(self, ctx: commands.Context):
+        """Export your installed repositories and cogs to a file."""
+        downloader = ctx.bot.get_cog("Downloader")
+        if downloader is None:
+            await ctx.send(
+                error(
+                    f"You do not have the `Downloader` cog loaded. Please run `{ctx.prefix}load downloader` and try again."
+                )
+            )
+            return
+
+        all_repos = list(downloader._repo_manager.repos)
+
+        export_data = []
+
+        for repo in all_repos:
+            repo_dict = {
+                "name": repo.name,
+                "url": repo.url,
+                "branch": repo.branch,
+                "cogs": [],
+            }
+
+            cogs = await downloader.installed_cogs()
+
+            for cog in cogs:
+                if cog.repo_name == repo.name:
+                    cog_dict = {
+                        "name": cog.name,
+                        # "loaded": cog.name in ctx.bot.extensions.keys(),
+                        # this functionality was planned but never implemented due to Red limitations
+                        # and the possibility of restoration functionality being added to Core
+                        "pinned": cog.pinned,
+                        "commit": cog.commit,
+                    }
+                    repo_dict["cogs"].append(cog_dict)
+
+            export_data.append(repo_dict)
+
+        await ctx.send(
+            file=text_to_file(json.dumps(export_data, indent=4), "backup.json")
+        )
+
+    @backup.command(name="import")
+    @commands.is_owner()
+    async def backup_import(self, ctx: commands.Context):
+        """Import your installed repositories and cogs from an export file."""
+        export = None
+        if ctx.message.attachments:
+            try:
+                export = json.loads(await ctx.message.attachments[0].read())
+            except json.JSONDecodeError:
+                await ctx.send(error("Invalid JSON in message attachments."))
+        elif ctx.message.reference and hasattr(ctx.message.reference, 'resolved'):
+            if ctx.message.reference.resolved.attachments:
+                try:
+                    export = json.loads(await ctx.message.reference.resolved.attachments[0].read())
+                except json.JSONDecodeError:
+                    await ctx.send(error("Invalid JSON in referenced message attachments."))
+        if export is None:
+            await ctx.send(error("Please provide a valid JSON export file."))
+            return
+
+        downloader = ctx.bot.get_cog("Downloader")
+        if downloader is None:
+            await ctx.send(
+                error(
+                    f"You do not have the `Downloader` cog loaded. Please run `{ctx.prefix}load downloader` and try again."
+                )
+            )
+            return
+
+        all_repos = list(downloader._repo_manager.repos)
+
+        for repo in export:
+            if repo["name"] not in [r.name for r in all_repos]:
+                try:
+                    await downloader._repo_manager.add_repo(
+                        repo["url"], repo["name"], repo["branch"]
+                    )
+                except errors.ExistingGitRepo:
+                    pass
+
+            for cog in repo["cogs"]:
+                try:
+                    await downloader._cog_install_interface.install_cog(
+                        cog["name"], cog["commit"]
+                    )
+                except errors.CogNotFoundError:
+                    pass
+                except errors.DownloaderError:
+                    pass

backup/info.json

@@ -0,0 +1,19 @@
+{
+  "author" : ["SeaswimmerTheFsh (seasw.)"],
+  "install_msg" : "Thank you for installing Backup!\nYou can find the source code of this cog [here](https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs).",
+  "name" : "Backup",
+  "short" : "A utility to make reinstalling repositories and cogs after migrating the bot far easier.",
+  "description" : "A utility to make reinstalling repositories and cogs after migrating the bot far easier.",
+  "end_user_data_statement" : "This cog does not store end user data.",
+  "hidden": false,
+  "disabled": false,
+  "min_bot_version": "3.5.6",
+  "max_bot_version": "3.5.9",
+  "min_python_version": [3, 9, 0],
+  "tags": [
+    "utility",
+    "backup",
+    "restore",
+    "migration"
+  ]
+}

bible/__init__.py

@@ -0,0 +1,5 @@
+from .bible import Bible
+
+
+async def setup(bot):
+    await bot.add_cog(Bible(bot))

bible/bible.py

@@ -0,0 +1,324 @@
+#   _____                         _
+#  / ____|                       (_)
+# | (___   ___  __ _ _____      ___ _ __ ___  _ __ ___   ___ _ __
+#  \___ \ / _ \/ _` / __\ \ /\ / / | '_ ` _ \| '_ ` _ \ / _ \ '__|
+#  ____) |  __/ (_| \__ \\ V  V /| | | | | | | | | | | |  __/ |
+# |_____/ \___|\__,_|___/ \_/\_/ |_|_| |_| |_|_| |_| |_|\___|_|
+
+import random
+from io import BytesIO
+
+import aiohttp
+import numpy as np
+from discord import Colour, Embed, File
+from PIL import Image
+from red_commons.logging import getLogger
+from redbot.core import Config, commands, data_manager
+from redbot.core.bot import Red
+from redbot.core.utils.chat_formatting import error, humanize_list
+
+import bible.errors
+from bible.models import Version
+
+
+class Bible(commands.Cog):
+    """Retrieve Bible verses from the API.bible API."""
+
+    __author__ = ["SeaswimmerTheFsh"]
+    __version__ = "1.1.0"
+    __documentation__ = "https://seacogs.coastalcommits.com/bible/"
+
+    def __init__(self, bot: Red):
+        super().__init__()
+        self.bot = bot
+        self.session = aiohttp.ClientSession()
+        self.config = Config.get_conf(
+            self, identifier=481923957134912, force_registration=True
+        )
+        self.logger = getLogger("red.SeaCogs.Bible")
+        self.config.register_global(bible="de4e12af7f28f599-02")
+        self.config.register_user(bible=None)
+
+    def format_help_for_context(self, ctx: commands.Context) -> str:
+        pre_processed = super().format_help_for_context(ctx) or ""
+        n = "\n" if "\n\n" not in pre_processed else ""
+        text = [
+            f"{pre_processed}{n}",
+            f"Cog Version: **{self.__version__}**",
+            f"Author: {humanize_list(self.__author__)}",
+            f"Documentation: {self.__documentation__}",
+        ]
+        return "\n".join(text)
+
+    def get_icon(self, color: Colour) -> File:
+        """Get the docs.api.bible favicon with a given color."""
+        image_path = data_manager.bundled_data_path(self) / "api.bible-logo.png"
+        image = Image.open(image_path)
+        image = image.convert("RGBA")
+        data = np.array(image)
+        red, green, blue, alpha = data.T # pylint: disable=unused-variable
+        white_areas = (red == 255) & (blue == 255) & (green == 255)
+        data[..., :-1][white_areas.T] = color.to_rgb()
+        image = Image.fromarray(data)
+
+        with BytesIO() as image_binary:
+            image.save(image_binary, "PNG")
+            image_binary.seek(0)
+            return File(image_binary, filename="icon.png", description="API.Bible Icon")
+
+    async def translate_book_name(self, bible_id: str, book_name: str) -> str:
+        """Translate a book name to a book ID."""
+        book_name_list = [
+            w.lower() if w.lower() == "of" else w.title() for w in book_name.split()
+        ]
+        book_name = " ".join(book_name_list)
+        books = await self._get_books(bible_id)
+        for book in books:
+            if book_name in (book["abbreviation"], book["name"]):
+                return book["id"]
+        raise ValueError(error(f"Book {book_name} not found."))
+
+    async def get_version(self, bible_id: str) -> Version:
+        """Retrieve the version of the Bible being used."""
+        url = f"https://api.scripture.api.bible/v1/bibles/{bible_id}"
+        headers = await self.bot.get_shared_api_tokens("api.bible")
+
+        async with self.session.get(url, headers=headers) as response:
+            data = await response.json()
+            self.logger.debug(
+                "get_version executed with a response code of: %s",
+                response.status,
+            )
+            if response.status == 401:
+                raise bible.errors.Unauthorized()
+            if response.status == 403:
+                raise bible.errors.BibleAccessError()
+            if response.status == 503:
+                raise bible.errors.ServiceUnavailable()
+            return Version(
+                bible_id,
+                data["data"]["abbreviation"],
+                data["data"]["language"]["name"],
+                data["data"]["abbreviationLocal"],
+                data["data"]["language"]["nameLocal"],
+                data["data"]["description"],
+                data["data"]["descriptionLocal"],
+                data["data"]["copyright"],
+            )
+
+    async def _get_passage(
+        self,
+        ctx: commands.Context,
+        bible_id: str,
+        passage_id: str,
+        include_verse_numbers: bool,
+    ) -> dict:
+        """Get a Bible passage from the API.bible API."""
+        url = f"https://api.scripture.api.bible/v1/bibles/{bible_id}/passages/{passage_id}"
+        headers = await self.bot.get_shared_api_tokens("api.bible")
+        params = {
+            "fums-version": "3",
+            "content-type": "text",
+            "include-notes": "false",
+            "include-titles": "false",
+            "include-chapter-numbers": "false",
+            "include-verse-numbers": str(include_verse_numbers).lower(),
+            "include-verse-spans": "false",
+            "use-org-id": "false",
+        }
+
+        async with self.session.get(url, headers=headers, params=params) as response:
+            data = await response.json()
+            self.logger.debug(
+                "_get_passage executed with a response code of: %s",
+                response.status,
+            )
+            if response.status == 400:
+                raise bible.errors.InexplicableError()
+            if response.status == 401:
+                raise bible.errors.Unauthorized()
+            if response.status == 403:
+                raise bible.errors.BibleAccessError()
+            if response.status == 404:
+                raise bible.errors.NotFound()
+            if response.status == 503:
+                raise bible.errors.ServiceUnavailable()
+
+        fums_url = "https://fums.api.bible/f3"
+        fums_params = {
+            "t": data["meta"]["fumsToken"],
+            "dId": self.bot.user.id,
+            "sId": ctx.message.created_at.timestamp(),
+            "uId": hash(str(ctx.author.id)),
+        }
+
+        async with self.session.get(fums_url, params=fums_params) as response:
+            self.logger.debug(
+                "_get_passage FUMS executed with a response code of: %s\nDevice ID: %s\nSession ID: %s\nUser ID: %s (%s)",
+                response.status,
+                self.bot.user.id,
+                ctx.message.created_at.timestamp(),
+                hash(str(ctx.author.id)),
+                ctx.author.id,
+            )
+        return data["data"]
+
+    async def _get_books(self, bible_id: str) -> dict:
+        """Get the books of the Bible from the API.bible API."""
+        url = f"https://api.scripture.api.bible/v1/bibles/{bible_id}/books"
+        headers = await self.bot.get_shared_api_tokens("api.bible")
+
+        async with self.session.get(url, headers=headers) as response:
+            data = await response.json()
+            self.logger.debug(
+                "_get_books executed with a response code of: %s",
+                response.status,
+            )
+            if response.status == 401:
+                raise bible.errors.Unauthorized()
+            if response.status == 403:
+                raise bible.errors.BibleAccessError()
+            if response.status == 503:
+                raise bible.errors.ServiceUnavailable()
+            return data["data"]
+
+    async def _get_chapters(self, bible_id: str, book_id: str) -> dict:
+        """Get the chapters of a book from the API.bible API."""
+        url = f"https://api.scripture.api.bible/v1/bibles/{bible_id}/books/{book_id}/chapters"
+        headers = await self.bot.get_shared_api_tokens("api.bible")
+
+        async with self.session.get(url, headers=headers) as response:
+            data = await response.json()
+            self.logger.debug(
+                "_get_chapters executed with a response code of: %s",
+                response.status,
+            )
+            if response.status == 401:
+                raise bible.errors.Unauthorized()
+            if response.status == 403:
+                raise bible.errors.BibleAccessError()
+            if response.status == 503:
+                raise bible.errors.ServiceUnavailable()
+            return data["data"]
+
+    async def _get_verses(self, bible_id: str, book_id: str, chapter: int) -> dict:
+        """Get the verses of a chapter from the API.bible API."""
+        url = f"https://api.scripture.api.bible/v1/bibles/{bible_id}/chapters/{book_id}.{chapter}/verses"
+        headers = await self.bot.get_shared_api_tokens("api.bible")
+
+        async with self.session.get(url, headers=headers) as response:
+            data = await response.json()
+            self.logger.debug(
+                "_get_verses executed with a response code of: %s",
+                response.status,
+            )
+            if response.status == 401:
+                raise bible.errors.Unauthorized()
+            if response.status == 403:
+                raise bible.errors.BibleAccessError()
+            if response.status == 503:
+                raise bible.errors.ServiceUnavailable()
+            return data["data"]
+
+    @commands.group(autohelp=True)
+    async def bible(self, ctx: commands.Context):
+        """Retrieve Bible verses from the API.bible API."""
+
+    @bible.command(name="passage", aliases=["verse"])
+    async def bible_passage(self, ctx: commands.Context, book: str, passage: str):
+        """Get a Bible passage.
+
+        Example usage:
+            `[p]bible passage Genesis 1:1`
+            `[p]bible passage John 3:16-3:17`"""
+        bible_id = await self.config.bible()
+
+        try:
+            book_id = await self.translate_book_name(bible_id, book)
+        except ValueError as e:
+            await ctx.send(str(e))
+            return
+
+        try:
+            version = await self.get_version(bible_id)
+            if len(passage.split("-")) == 2:
+                from_verse, to_verse = passage.replace(":", ".").split("-")
+                if "." not in to_verse:
+                    to_verse = f"{from_verse.split('.')[0]}.{to_verse}"
+                passage = await self._get_passage(
+                    ctx, bible_id, f"{book_id}.{from_verse}-{book_id}.{to_verse}", True
+                )
+            else:
+                passage = await self._get_passage(
+                    ctx, bible_id, f"{book_id}.{passage.replace(':', '.')}", False
+                )
+        except (
+            bible.errors.BibleAccessError,
+            bible.errors.NotFound,
+            bible.errors.InexplicableError,
+            bible.errors.ServiceUnavailable,
+            bible.errors.Unauthorized,
+        ) as e:
+            await ctx.send(e.message)
+            return
+
+        if len(passage["content"]) > 4096:
+            await ctx.send("The passage is too long to send.")
+            return
+
+        if await ctx.embed_requested():
+            icon = self.get_icon(await ctx.embed_color())
+            embed = Embed(
+                title=f"{passage['reference']}",
+                description=passage["content"].replace("¶ ", ""),
+                color=await ctx.embed_color(),
+            )
+            embed.set_footer(
+                text=f"{ctx.prefix}bible passage - Powered by API.Bible - {version.abbreviationLocal} ({version.languageLocal}, {version.descriptionLocal})",
+                icon_url="attachment://icon.png"
+            )
+            await ctx.send(embed=embed, file=icon)
+        else:
+            await ctx.send(f"## {passage['reference']}\n{passage['content']}")
+
+    @bible.command(name="random")
+    async def bible_random(self, ctx: commands.Context):
+        """Get a random Bible verse."""
+        bible_id = await self.config.bible()
+
+        try:
+            version = await self.get_version(bible_id)
+            books = await self._get_books(bible_id)
+            book = random.choice(books)
+
+            chapters = await self._get_chapters(bible_id, book["id"])
+            chapter = random.choice(chapters)
+
+            verses = await self._get_verses(bible_id, book["id"], chapter["number"])
+            verse = random.choice(verses)["id"]
+
+            passage = await self._get_passage(ctx, bible_id, verse, False)
+        except (
+            bible.errors.BibleAccessError,
+            bible.errors.NotFound,
+            bible.errors.InexplicableError,
+            bible.errors.ServiceUnavailable,
+            bible.errors.Unauthorized,
+        ) as e:
+            await ctx.send(e.message)
+            return
+
+        if await ctx.embed_requested():
+            icon = self.get_icon(await ctx.embed_color())
+            embed = Embed(
+                title=f"{passage['reference']}",
+                description=passage["content"].replace("¶ ", ""),
+                color=await ctx.embed_color(),
+            )
+            embed.set_footer(
+                text=f"{ctx.prefix}bible random - Powered by API.Bible - {version.abbreviationLocal} ({version.languageLocal}, {version.descriptionLocal})",
+                icon_url="attachment://icon.png"
+            )
+            await ctx.send(embed=embed, file=icon)
+        else:
+            await ctx.send(f"## {passage['reference']}\n{passage['content']}")

bible/errors.py

@@ -0,0 +1,52 @@
+from redbot.core.utils.chat_formatting import error
+
+
+class BibleAccessError(Exception):
+    def __init__(
+        self,
+        message: str = error(
+            "The provided API key cannot retrieve sections from the configured Bible. Please report this to the bot owner."
+        ),
+    ):
+        super().__init__(message)
+        self.message = message
+
+
+class Unauthorized(Exception):
+    def __init__(
+        self,
+        message: str = error(
+            "The API key for API.Bible is missing or invalid. Please report this to the bot owner.\nIf you are the bot owner, please check the documentation [here](<https://seacogs.coastalcommits.com/bible/#setup>)."
+        ),
+    ):
+        super().__init__(message)
+        self.message = message
+
+
+class NotFound(Exception):
+    def __init__(
+        self,
+        message: str = error("The requested passage was not found."),
+    ):
+        super().__init__(message)
+        self.message = message
+
+
+class ServiceUnavailable(Exception):
+    def __init__(
+        self,
+        message: str = error("The API.Bible service is currently unavailable."),
+    ):
+        super().__init__(message)
+        self.message = message
+
+
+class InexplicableError(Exception):
+    def __init__(
+        self,
+        message: str = error(
+            "An inexplicable 'Bad Request' error occurred. This error happens occassionally with the API.Bible service. Please try again. If the error persists, please report this to the bot owner."
+        ),
+    ):
+        super().__init__(message)
+        self.message = message

bible/info.json

@@ -0,0 +1,18 @@
+{
+  "author" : ["SeaswimmerTheFsh (seasw.)"],
+  "install_msg" : "Thank you for installing Bible!\nThis cog requires setting an API key for API.Bible. Please read the [documentation](https://seacogs.coastalcommits.com/bible/#setup) for more information.\nYou can find the source code of this cog [here](https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs).",
+  "name" : "Bible",
+  "short" : "Retrieve Bible verses from API.Bible.",
+  "description" : "Retrieve Bible verses from the API.Bible API. This cog requires an API.Bible api key.",
+  "end_user_data_statement" : "This cog does not store end user data, however it does send the following data to the API.Bible API:\n- The bot user's ID\n- The timestamp of the invoking message\n- The hashed user id of the invoking user",
+  "hidden": false,
+  "disabled": false,
+  "min_bot_version": "3.5.0",
+  "min_python_version": [3, 10, 0],
+  "requirements": ["numpy", "pillow"],
+  "tags": [
+    "fun",
+    "utility",
+    "api"
+  ]
+}

bible/models.py

@@ -0,0 +1,26 @@
+class Version:
+    def __init__(
+        self,
+        bible_id,
+        abbreviation,
+        language,
+        abbreviationLocal,
+        languageLocal,
+        description,
+        descriptionLocal,
+        version_copyright,
+    ):
+        self.bible_id = bible_id
+        self.abbreviation = abbreviation
+        self.language = language
+        self.abbreviationLocal = abbreviationLocal
+        self.languageLocal = languageLocal
+        self.description = description
+        self.descriptionLocal = descriptionLocal
+        self.copyright = version_copyright
+
+    def __str__(self):
+        return self.abbreviationLocal
+
+    def __repr__(self):
+        return f'bible.models.Version("{self.bible_id}", "{self.abbreviation}", "{self.language}", "{self.abbreviationLocal}", "{self.languageLocal}", "{self.description}", "{self.descriptionLocal}", "{self.copyright}")'

mkdocs.yml

@@ -3,7 +3,7 @@ site_url: !ENV [SITE_URL, 'https://seacogs.coastalcommits.com']
 repo_name: CoastalCommits
 repo_url: https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs
 edit_uri: !ENV [EDIT_URI, 'src/branch/main/.docs']
-copyright: Copyright © 2024, SeaswimmerTheFsh
+copyright: Copyright © 2023-2024, SeaswimmerTheFsh
 docs_dir: .docs
 
 site_author: SeaswimmerTheFsh
@@ -16,13 +16,20 @@ nav:
     - Moderation Commands: aurora/moderation-commands.md
     - Case Commands: aurora/case-commands.md
     - Configuration: aurora/configuration.md
+  - Bible: bible.md
+  - Backup: backup.md
   - Nerdify: nerdify.md
-  - UpdateChecker: updatechecker.md
+  - Pterodactyl:
+    - pterodactyl/index.md
+    - Installing Red: pterodactyl/installing-red.md
+    - Getting Started: pterodactyl/getting-started.md
+    - Configuration: pterodactyl/configuration.md
+    - Regex Examples: pterodactyl/regex.md
 
 plugins:
   - git-authors
   - search
-  - social
+  #- social
   - git-revision-date-localized:
       enable_creation_date: true
       type: timeago
@@ -63,11 +70,10 @@ markdown_extensions:
 
 theme:
   name: material
-  custom_dir: ./.docs/.overrides
   palette:
     - media: '(prefers-color-scheme: light)'
       scheme: default
-      primary: cyan
+      primary: white
       accent: light blue
       toggle:
         icon: material/toggle-switch
@@ -75,7 +81,7 @@ theme:
 
     - media: '(prefers-color-scheme: dark)'
       scheme: slate
-      primary: cyan
+      primary: black
       accent: light blue
       toggle:
         icon: material/toggle-switch-off-outline
@@ -102,5 +108,7 @@ theme:
 
 watch:
   - ./aurora
+  - ./backup
+  - ./bible
   - ./nerdify
-  - ./updatechecker
+  - ./pterodactyl

nerdify/info.json

@@ -1,10 +1,17 @@
 {
-    "author" : ["SeaswimmerTheFsh"],
+  "author" : ["SeaswimmerTheFsh (seasw.)"],
   "install_msg" : "Thank you for installing Nerdify!\nYou can find the source code of this cog [here](https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs). Based off of PhasecoreX's [UwU](<https://github.com/PhasecoreX/PCXCogs/tree/master/uwu>) cog.",
   "name" : "Nerdify",
   "short" : "Nerdify your text!",
   "description" : "Nerdify your text!",
   "end_user_data_statement" : "This cog does not store end user data.",
   "hidden": false,
-    "disabled": false
+  "disabled": false,
+  "min_bot_version": "3.5.0",
+  "min_python_version": [3, 8, 0],
+  "tags": [
+      "fun",
+      "text",
+      "meme"
+  ]
 }

nerdify/nerdify.py

@@ -7,7 +7,7 @@
 
 import asyncio
 from contextlib import suppress
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 import discord
 from redbot.core import commands
@@ -17,14 +17,28 @@ from redbot.core.utils import chat_formatting, common_filters
 class Nerdify(commands.Cog):
     """Nerdify your text."""
 
-    __author__ = "SeaswimmerTheFsh"
+    __author__ = ["SeaswimmerTheFsh"]
-    __version__ = "1.3.2"
+    __version__ = "1.3.4"
+    __documentation__ = "https://seacogs.coastalcommits.com/nerdify/"
 
     def __init__(self, bot):
         self.bot = bot
 
+    def format_help_for_context(self, ctx: commands.Context) -> str:
+        pre_processed = super().format_help_for_context(ctx) or ""
+        n = "\n" if "\n\n" not in pre_processed else ""
+        text = [
+            f"{pre_processed}{n}",
+            f"Cog Version: **{self.__version__}**",
+            f"Author: {chat_formatting.humanize_list(self.__author__)}",
+            f"Documentation: {self.__documentation__}"
+        ]
+        return "\n".join(text)
+
     @commands.command(aliases=["nerd"])
-    async def nerdify(self, ctx: commands.Context, *, text: Optional[str] = None) -> None:
+    async def nerdify(
+        self, ctx: commands.Context, *, text: Optional[str] = None
+    ) -> None:
         """Nerdify the replied to message, previous message, or your own text."""
         if not text:
             if hasattr(ctx.message, "reference") and ctx.message.reference:
@@ -57,11 +71,11 @@ class Nerdify(commands.Cog):
 
         Returns:
             The converted text."""
-        return f"\"{text}\" 🤓"
+        return f'"{text}" 🤓'
 
     async def type_message(
         self, destination: discord.abc.Messageable, content: str, **kwargs: Any
-    ) -> discord.Message | None:
+    ) -> Union[discord.Message, None]:
         """Simulate typing and sending a message to a destination.
 
         Will send a typing indicator, wait a variable amount of time based on the length

pterodactyl/__init__.py

@@ -0,0 +1,5 @@
+from .pterodactyl import Pterodactyl
+
+
+async def setup(bot):
+    await bot.add_cog(Pterodactyl(bot))

pterodactyl/config.py

@@ -0,0 +1,30 @@
+from redbot.core import Config
+
+config: Config = Config.get_conf(None, identifier=457581387213637448123567, cog_name="Pterodactyl", force_registration=True)
+
+def register_config(config_obj: Config) -> None:
+    config_obj.register_global(
+        base_url=None,
+        server_id=None,
+        console_channel=None,
+        console_commands_enabled=False,
+        current_status='',
+        chat_regex=r"^\[\d{2}:\d{2}:\d{2}\sINFO\]: (?!\[(?:Server|Rcon)\])(?:<|\[)(\w+)(?:>|\]) (.*)",
+        server_regex=r"^\[\d{2}:\d{2}:\d{2} INFO\]:(?: \[Not Secure\])? \[(?:Server|Rcon)\] (.*)",
+        join_regex=r"^\[\d{2}:\d{2}:\d{2} INFO\]: ([^<\n]+) joined the game$",
+        leave_regex=r"^\[\d{2}:\d{2}:\d{2} INFO\]: ([^<\n]+) left the game$",
+        achievement_regex=r"^\[\d{2}:\d{2}:\d{2} INFO\]: (.*) has (made the advancement|completed the challenge) \[(.*)\]$",
+        chat_command='tellraw @a ["",{"text":".$N ","color":".$C","insertion":"<@.$I>","hoverEvent":{"action":"show_text","contents":"Shift click to mention this user inside Discord"}},{"text":"(DISCORD):","color":"blue","clickEvent":{"action":"open_url","value":".$V"},"hoverEvent":{"action":"show_text","contents":"Click to join the Discord Server"}},{"text":" .$M","color":"white"}]', # noqa: E501
+        topic='Server IP: .$H\nServer Players: .$P/.$M',
+        topic_hostname=None,
+        topic_port=25565,
+        api_endpoint="minecraft",
+        chat_channel=None,
+        startup_msg='Server started!',
+        shutdown_msg='Server stopped!',
+        join_msg='Welcome to the server! 👋',
+        leave_msg='Goodbye! 👋',
+        mask_ip=True,
+        invite=None,
+        regex_blacklist={},
+    )

pterodactyl/info.json

@@ -0,0 +1,19 @@
+{
+  "author" : ["SeaswimmerTheFsh (seasw.)"],
+  "install_msg" : "Thank you for installing Pterodactyl!\nYou can find the source code of this cog [here](https://coastalcommits.com/SeaswimmerTheFsh/SeaCogs).\nDocumentation can be found [here](https://seacogs.coastalcommits.com/pterodactyl ).",
+  "name" : "Pterodactyl",
+  "short" : "Interface with Pterodactyl through websockets.",
+  "description" : "Interface with Pterodactyl through websockets.",
+  "end_user_data_statement" : "This cog does not store end user data.",
+  "hidden": false,
+  "disabled": false,
+  "min_bot_version": "3.5.0",
+  "min_python_version": [3, 8, 0],
+  "requirements": ["git+https://github.com/SeaswimmerTheFsh/pydactyl", "websockets"],
+  "tags": [
+      "pterodactyl",
+      "minecraft",
+      "server",
+      "management"
+  ]
+}

pterodactyl/logger.py

@@ -0,0 +1,9 @@
+from red_commons import logging
+from red_commons.logging import getLogger
+
+logger = getLogger('red.SeaCogs.Pterodactyl')
+websocket_logger = getLogger('red.SeaCogs.Pterodactyl.websocket')
+if logger.level >= logging.VERBOSE:
+    websocket_logger.setLevel(logging.logging.INFO)
+elif logger.level < logging.VERBOSE:
+    websocket_logger.setLevel(logging.logging.DEBUG)

pterodactyl/mcsrvstatus.py

@@ -0,0 +1,10 @@
+import aiohttp
+
+
+async def get_status(host, port = 25565) -> tuple[bool, dict]:
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f'https://api.mcsrvstat.us/2/{host}:{port}') as response:
+            response = await response.json()
+            if response['online']:
+                return (True, response)
+            return (False, response)

pterodactyl/pterodactyl.py

@@ -0,0 +1,627 @@
+import asyncio
+import json
+from typing import Mapping, Optional, Tuple, Union
+
+import discord
+import websockets
+from discord.ext import tasks
+from pydactyl import PterodactylClient
+from redbot.core import app_commands, commands
+from redbot.core.app_commands import Choice
+from redbot.core.bot import Red
+from redbot.core.utils.chat_formatting import box, error, humanize_list
+from redbot.core.utils.views import ConfirmView
+
+from pterodactyl import mcsrvstatus
+from pterodactyl.config import config, register_config
+from pterodactyl.logger import logger
+
+
+class Pterodactyl(commands.Cog):
+    """Pterodactyl allows you to manage your Pterodactyl Panel from Discord."""
+
+    __author__ = ["SeaswimmerTheFsh"]
+    __version__ = "2.0.0"
+    __documentation__ = "https://seacogs.coastalcommits.com/pterodactyl/"
+
+    def __init__(self, bot: Red):
+        self.bot = bot
+        self.client: Optional[PterodactylClient] = None
+        self.task: Optional[asyncio.Task] = None
+        self.websocket: Optional[websockets.WebSocketClientProtocol] = None
+        self.retry_counter: int = 0
+        register_config(config)
+        self.task = self.get_task()
+        self.update_topic.start()
+
+    def format_help_for_context(self, ctx: commands.Context) -> str:
+        pre_processed = super().format_help_for_context(ctx) or ""
+        n = "\n" if "\n\n" not in pre_processed else ""
+        text = [
+            f"{pre_processed}{n}",
+            f"Cog Version: **{self.__version__}**",
+            f"Author: {humanize_list(self.__author__)}",
+            f"Documentation: {self.__documentation__}",
+        ]
+        return "\n".join(text)
+
+    async def cog_unload(self) -> None:
+        self.update_topic.cancel()
+        self.task.cancel()
+        self.retry_counter = 0
+        await self.client._session.close() # pylint: disable=protected-access
+
+    def get_task(self) -> asyncio.Task:
+        from pterodactyl.websocket import establish_websocket_connection
+        task = self.bot.loop.create_task(establish_websocket_connection(self), name="Pterodactyl Websocket Connection")
+        task.add_done_callback(self.error_callback)
+        return task
+
+    def error_callback(self, fut) -> None: #NOTE - Thanks flame442 and zephyrkul for helping me figure this out
+        try:
+            fut.result()
+        except asyncio.CancelledError:
+            logger.info("WebSocket task has been cancelled.")
+        except Exception as e: # pylint: disable=broad-exception-caught
+            logger.error("WebSocket task has failed: %s", e, exc_info=e)
+            self.task.cancel()
+            if self.retry_counter < 5:
+                self.retry_counter += 1
+                logger.info("Retrying in %s seconds...", 5 * self.retry_counter)
+                self.task = self.bot.loop.call_later(5 * self.retry_counter, self.get_task)
+            else:
+                logger.info("Retry limit reached. Stopping task.")
+
+    @tasks.loop(minutes=6)
+    async def update_topic(self):
+        await self.bot.wait_until_red_ready()
+        topic = await self.get_topic()
+        console = self.bot.get_channel(await config.console_channel())
+        chat = self.bot.get_channel(await config.chat_channel())
+        if console:
+            await console.edit(topic=topic)
+        if chat:
+            await chat.edit(topic=topic)
+
+    @commands.Cog.listener()
+    async def on_message_without_command(self, message: discord.Message) -> None:
+        if message.channel.id == await config.console_channel() and message.author.bot is False:
+            if await config.console_commands_enabled() is False:
+                await message.channel.send("Console commands are disabled.")
+                logger.debug("Received console command from %s, but console commands are disabled: %s", message.author.id, message.content)
+                return
+            logger.debug("Received console command from %s: %s", message.author.id, message.content)
+            await message.channel.send(f"Received console command from {message.author.id}: {message.content[:1900]}", allowed_mentions=discord.AllowedMentions.none())
+            try:
+                await self.websocket.send(json.dumps({"event": "send command", "args": [message.content]}))
+            except websockets.exceptions.ConnectionClosed as e:
+                logger.error("WebSocket connection closed: %s", e)
+                self.task.cancel()
+                self.retry_counter = 0
+                self.task = self.get_task()
+        if message.channel.id == await config.chat_channel() and message.author.bot is False:
+            logger.debug("Received chat message from %s: %s", message.author.id, message.content)
+            channel = self.bot.get_channel(await config.console_channel())
+            if channel:
+                await channel.send(f"Received chat message from {message.author.id}: {message.content[:1900]}", allowed_mentions=discord.AllowedMentions.none())
+            msg = json.dumps({"event": "send command", "args": [await self.get_chat_command(message)]})
+            logger.debug("Sending chat message to server:\n%s", msg)
+            try:
+                await self.websocket.send(msg)
+            except websockets.exceptions.ConnectionClosed as e:
+                logger.error("WebSocket connection closed: %s", e)
+                self.task.cancel()
+                self.retry_counter = 0
+                self.task = self.get_task()
+
+    async def get_topic(self) -> str:
+        topic: str = await config.topic()
+        placeholders = {
+            "H": await config.topic_hostname() or "unset",
+            "O": str(await config.topic_port()),
+        }
+        if await config.api_endpoint() == "minecraft":
+            status, response = await mcsrvstatus.get_status(await config.topic_hostname(), await config.topic_port())
+            if status:
+                placeholders.update({
+                    "I": response['ip'],
+                    "M": str(response['players']['max']),
+                    "P": str(response['players']['online']),
+                    "V": response['version'],
+                    "D": response['motd']['clean'][0] if response['motd']['clean'] else "unset",
+                })
+            else:
+                placeholders.update({
+                    "I": response['ip'],
+                    "M": "0",
+                    "P": "0",
+                    "V": "Server Offline",
+                    "D": "Server Offline",
+                })
+        for key, value in placeholders.items():
+            topic = topic.replace('.$' + key, value)
+        return topic
+
+    async def get_chat_command(self, message: discord.Message) -> str:
+        command: str = await config.chat_command()
+        placeholders = {
+            "C": str(message.author.color),
+            "D": message.author.discriminator,
+            "I": str(message.author.id),
+            "M": message.content.replace('"','').replace("\n", " "),
+            "N": message.author.display_name,
+            "U": message.author.name,
+            "V": await config.invite() or "use [p]pterodactyl config invite to change me",
+        }
+        for key, value in placeholders.items():
+            command = command.replace('.$' + key, value)
+        return command
+
+    async def get_player_list(self) -> Optional[Tuple[str, list]]:
+        if await config.api_endpoint() == "minecraft":
+            status, response = await mcsrvstatus.get_status(await config.topic_hostname(), await config.topic_port())
+            if status and 'list' in response['players']:
+                output_str = '\n'.join(response['players']['list'])
+                return output_str, response['players']['list']
+            return None
+
+    async def get_player_list_embed(self, ctx: Union[commands.Context, discord.Interaction]) -> Optional[discord.Embed]:
+        player_list = await self.get_player_list()
+        if player_list:
+            embed = discord.Embed(color=await self.bot.get_embed_color(ctx.channel), title="Players Online")
+            embed.description = player_list[0]
+            return embed
+        return None
+
+    async def power(self, ctx: Union[discord.Interaction, commands.Context], action: str, action_ing: str, warning: str = '') -> None:
+        if isinstance(ctx, discord.Interaction):
+            author = ctx.user
+        else:
+            author = ctx.author
+
+        current_status = await config.current_status()
+
+        if current_status == action_ing:
+            if isinstance(ctx, discord.Interaction):
+                return await ctx.response.send_message(f"Server is already {action_ing}.", ephemeral=True)
+            return await ctx.send(f"Server is already {action_ing}.")
+
+        if current_status in ["starting", "stopping"] and action != "kill":
+            if isinstance(ctx, discord.Interaction):
+                return await ctx.response.send_message("Another power action is already in progress.", ephemeral=True)
+            return await ctx.send("Another power action is already in progress.")
+
+        view = ConfirmView(author, disable_buttons=True)
+
+        if isinstance(ctx, discord.Interaction):
+            await ctx.response.send_message(f"{warning}Are you sure you want to {action} the server?", view=view)
+        else:
+            message = await ctx.send(f"{warning}Are you sure you want to {action} the server?", view=view)
+
+        await view.wait()
+
+        if view.result is True:
+            if isinstance(ctx, discord.Interaction):
+                await ctx.edit_original_response(content=f"Sending websocket command to {action} server...", view=None)
+            else:
+                await message.edit(content=f"Sending websocket command to {action} server...", view=None)
+
+            await self.websocket.send(json.dumps({"event": "set state", "args": [action]}))
+
+            if isinstance(ctx, discord.Interaction):
+                await ctx.edit_original_response(content=f"Server {action_ing}", view=None)
+            else:
+                await message.edit(content=f"Server {action_ing}", view=None)
+
+        else:
+            if isinstance(ctx, discord.Interaction):
+                await ctx.edit_original_response(content="Cancelled.", view=None)
+            else:
+                await message.edit(content="Cancelled.", view=None)
+
+    async def send_command(self, ctx: Union[discord.Interaction, commands.Context], command: str):
+        channel = self.bot.get_channel(await config.console_channel())
+        if isinstance(ctx, discord.Interaction):
+            if channel:
+                await channel.send(f"Received console command from {ctx.user.id}: {command[:1900]}", allowed_mentions=discord.AllowedMentions.none())
+            try:
+                await self.websocket.send(json.dumps({"event": "send command", "args": [command]}))
+                await ctx.response.send_message(f"Command sent to server. {box(command, 'json')}", ephemeral=True)
+            except websockets.exceptions.ConnectionClosed as e:
+                logger.error("WebSocket connection closed: %s", e)
+                await ctx.response.send_message(error("WebSocket connection closed."))
+                self.task.cancel()
+                self.retry_counter = 0
+                self.task = self.get_task()
+        else:
+            if channel:
+                await channel.send(f"Received console command from {ctx.author.id}: {command[:1900]}", allowed_mentions=discord.AllowedMentions.none())
+            try:
+                await self.websocket.send(json.dumps({"event": "send command", "args": [command]}))
+                await ctx.send(f"Command sent to server. {box(command, 'json')}")
+            except websockets.exceptions.ConnectionClosed as e:
+                logger.error("WebSocket connection closed: %s", e)
+                await ctx.send(error("WebSocket connection closed."))
+                self.task.cancel()
+                self.retry_counter = 0
+                self.task = self.get_task()
+
+    @commands.Cog.listener()
+    async def on_red_api_tokens_update(self, service_name: str, api_tokens: Mapping[str,str]): # pylint: disable=unused-argument
+        if service_name == "pterodactyl":
+            logger.info("Configuration value set: api_key\nRestarting task...")
+            self.task.cancel()
+            self.retry_counter = 0
+            self.task = self.get_task()
+
+    slash_pterodactyl = app_commands.Group(name="pterodactyl", description="Pterodactyl allows you to manage your Pterodactyl Panel from Discord.")
+
+    @slash_pterodactyl.command(name = "command", description = "Send a command to the server console.")
+    async def slash_pterodactyl_command(self, interaction: discord.Interaction, command: str) -> None:
+        """Send a command to the server console.
+
+        Parameters:
+        -----------
+        command: str
+            The command to send to the server."""
+        return await self.send_command(interaction, command)
+
+    @slash_pterodactyl.command(name = "players", description = "Retrieve a list of players on the server.")
+    async def slash_pterodactyl_players(self, interaction: discord.Interaction) -> None:
+        """Retrieve a list of players on the server."""
+        e = await self.get_player_list_embed(interaction)
+        if e:
+            await interaction.response.send_message(embed=e, ephemeral=True)
+        else:
+            await interaction.response.send_message("No players online.", ephemeral=True)
+
+    @slash_pterodactyl.command(name = "power", description = "Send power actions to the server.")
+    @app_commands.choices(action=[
+        Choice(name="Start", value="start"),
+        Choice(name="Stop", value="stop"),
+        Choice(name="Restart", value="restart"),
+        Choice(name="⚠️ Kill ⚠️", value="kill")
+    ])
+    async def slash_pterodactyl_power(self, interaction: discord.Interaction, action: app_commands.Choice[str]) -> None:
+        """Send power actions to the server.
+
+        Parameters:
+        -----------
+        action: app_commands.Choice[str]
+            The action to perform on the server."""
+        if action.value == "kill":
+            return await self.power(interaction, action.value, "stopping... (forcefully killed)", warning="**⚠️ Forcefully killing the server process can corrupt data in some cases. ⚠️**\n")
+        if action.value == "stop":
+            return await self.power(interaction, action.value, "stopping...")
+        return await self.power(interaction, action.value, f"{action.value}ing...")
+
+    @commands.group(autohelp = True, name = "pterodactyl", aliases = ["ptero"])
+    async def pterodactyl(self, ctx: commands.Context) -> None:
+        """Pterodactyl allows you to manage your Pterodactyl Panel from Discord."""
+
+    @pterodactyl.command(name = "players", aliases=["list", "online", "playerlist", "who"])
+    async def pterodactyl_players(self, ctx: commands.Context) -> None:
+        """Retrieve a list of players on the server."""
+        e = await self.get_player_list_embed(ctx)
+        if e:
+            await ctx.send(embed=e)
+        else:
+            await ctx.send("No players online.")
+
+    @pterodactyl.command(name = "command", aliases = ["cmd", "execute", "exec"])
+    @commands.admin()
+    async def pterodactyl_command(self, ctx: commands.Context, *, command: str) -> None:
+        """Send a command to the server console."""
+        return await self.send_command(ctx, command)
+
+    @pterodactyl.group(autohelp = True, name = "power")
+    @commands.admin()
+    async def pterodactyl_power(self, ctx: commands.Context) -> None:
+        """Send power actions to the server."""
+
+    @pterodactyl_power.command(name = "start")
+    async def pterodactyl_power_start(self, ctx: commands.Context) -> Optional[discord.Message]:
+        """Start the server."""
+        return await self.power(ctx, "start", "starting...")
+
+    @pterodactyl_power.command(name = "stop")
+    async def pterodactyl_power_stop(self, ctx: commands.Context) -> Optional[discord.Message]:
+        """Stop the server."""
+        return await self.power(ctx, "stop", "stopping...")
+
+    @pterodactyl_power.command(name = "restart")
+    async def pterodactyl_power_restart(self, ctx: commands.Context) -> Optional[discord.Message]:
+        """Restart the server."""
+        return await self.power(ctx, "restart", "restarting...")
+
+    @pterodactyl_power.command(name = "kill")
+    async def pterodactyl_power_kill(self, ctx: commands.Context) -> Optional[discord.Message]:
+        """Kill the server."""
+        return await self.power(ctx, "kill", "stopping... (forcefully killed)", warning="**⚠️ Forcefully killing the server process can corrupt data in some cases. ⚠️**\n")
+
+    @pterodactyl.group(autohelp = True, name = "config", aliases = ["settings", "set"])
+    @commands.is_owner()
+    async def pterodactyl_config(self, ctx: commands.Context) -> None:
+        """Configure Pterodactyl settings."""
+
+    @pterodactyl_config.command(name = "url")
+    async def pterodactyl_config_base_url(self, ctx: commands.Context, *, base_url: str) -> None:
+        """Set the base URL of your Pterodactyl Panel.
+
+        Please include the protocol (http/https).
+        Example: `https://panel.example.com`"""
+        await config.base_url.set(base_url)
+        await ctx.send(f"Base URL set to {base_url}")
+        logger.info("Configuration value set: base_url = %s\nRestarting task...", base_url)
+        self.task.cancel()
+        self.retry_counter = 0
+        self.task = self.get_task()
+
+    @pterodactyl_config.command(name = "serverid")
+    async def pterodactyl_config_server_id(self, ctx: commands.Context, *, server_id: str) -> None:
+        """Set the ID of your server."""
+        await config.server_id.set(server_id)
+        await ctx.send(f"Server ID set to {server_id}")
+        logger.info("Configuration value set: server_id = %s\nRestarting task...", server_id)
+        self.task.cancel()
+        self.retry_counter = 0
+        self.task = self.get_task()
+
+    @pterodactyl_config.group(name = "console")
+    async def pterodactyl_config_console(self, ctx: commands.Context):
+        """Configure console settings."""
+
+    @pterodactyl_config_console.command(name = "channel")
+    async def pterodactyl_config_console_channel(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
+        """Set the channel to send console output to."""
+        await config.console_channel.set(channel.id)
+        await ctx.send(f"Console channel set to {channel.mention}")
+
+    @pterodactyl_config_console.command(name = "commands")
+    async def pterodactyl_config_console_commands(self, ctx: commands.Context, enabled: bool) -> None:
+        """Enable or disable console commands."""
+        await config.console_commands_enabled.set(enabled)
+        await ctx.send(f"Console commands set to {enabled}")
+
+    @pterodactyl_config.command(name = "invite")
+    async def pterodactyl_config_invite(self, ctx: commands.Context, invite: str) -> None:
+        """Set the invite link for your server."""
+        await config.invite.set(invite)
+        await ctx.send(f"Invite link set to {invite}")
+
+    @pterodactyl_config.group(name = "topic")
+    async def pterodactyl_config_topic(self, ctx: commands.Context):
+        """Set the topic for the console and chat channels."""
+
+    @pterodactyl_config_topic.command(name = "host", aliases = ["hostname", "ip"])
+    async def pterodactyl_config_topic_host(self, ctx: commands.Context, host: str) -> None:
+        """Set the hostname or IP address of your server."""
+        await config.topic_hostname.set(host)
+        await ctx.send(f"Hostname/IP set to `{host}`")
+
+    @pterodactyl_config_topic.command(name = "port")
+    async def pterodactyl_config_topic_port(self, ctx: commands.Context, port: int) -> None:
+        """Set the port of your server."""
+        await config.topic_port.set(port)
+        await ctx.send(f"Port set to `{port}`")
+
+    @pterodactyl_config_topic.command(name = "text")
+    async def pterodactyl_config_topic_text(self, ctx: commands.Context, *, text: str) -> None:
+        """Set the text for the console and chat channels.
+
+        Available placeholders:
+        - `.$H` (hostname)
+        - `.$O` (port)
+        Available for Minecraft servers:
+        - `.$I` (ip)
+        - `.$M` (max players)
+        - `.$P` (players online)
+        - `.$V` (version)
+        - `.$D` (description / Message of the Day)"""
+        await config.topic.set(text)
+        await ctx.send(f"Topic set to:\n{box(text, 'yaml')}")
+
+    @pterodactyl_config.group(name = "chat")
+    async def pterodactyl_config_chat(self, ctx: commands.Context):
+        """Configure chat settings."""
+
+    @pterodactyl_config_chat.command(name = "channel")
+    async def pterodactyl_config_chat_channel(self, ctx: commands.Context, channel: discord.TextChannel) -> None:
+        """Set the channel to send chat output to."""
+        await config.chat_channel.set(channel.id)
+        await ctx.send(f"Chat channel set to {channel.mention}")
+
+    @pterodactyl_config_chat.command(name = "command")
+    async def pterodactyl_config_chat_command(self, ctx: commands.Context, *, command: str) -> None:
+        """Set the command that will be used to send messages from Discord.
+
+        Required placeholders: `.$U` (username), `.$M` (message), `.$C` (color)
+        See [documentation](https://seacogs.coastalcommits.com/pterodactyl/setup/#changing-the-tellraw-command) for more information."""
+        await config.chat_command.set(command)
+        await ctx.send(f"Chat command set to:\n{box(command, 'json')}")
+
+    @pterodactyl_config.group(name = "regex")
+    async def pterodactyl_config_regex(self, ctx: commands.Context) -> None:
+        """Set regex patterns."""
+
+    @pterodactyl_config_regex.command(name = "chat")
+    async def pterodactyl_config_regex_chat(self, ctx: commands.Context, *, regex: str) -> None:
+        """Set the regex pattern to match chat messages on the server.
+
+        See [documentation](https://seacogs.coastalcommits.com/pterodactyl/setup/#my-chat-messages-arent-detected) for more information."""
+        await config.chat_regex.set(regex)
+        await ctx.send(f"Chat regex set to:\n{box(regex, 'regex')}")
+
+    @pterodactyl_config_regex.command(name = "server")
+    async def pterodactyl_config_regex_server(self, ctx: commands.Context, *, regex: str) -> None:
+        """Set the regex pattern to match server messages on the server.
+
+        See [documentation](https://seacogs.coastalcommits.com/pterodactyl/setup/#my-chat-messages-arent-detected) for more information."""
+        await config.server_regex.set(regex)
+        await ctx.send(f"Server regex set to:\n{box(regex, 'regex')}")
+
+    @pterodactyl_config_regex.command(name = "join")
+    async def pterodactyl_config_regex_join(self, ctx: commands.Context, *, regex: str) -> None:
+        """Set the regex pattern to match join messages on the server.
+
+        See [documentation](https://seacogs.coastalcommits.com/pterodactyl/setup/#my-chat-messages-arent-detected) for more information."""
+        await config.join_regex.set(regex)
+        await ctx.send(f"Join regex set to:\n{box(regex, 'regex')}")
+
+    @pterodactyl_config_regex.command(name = "leave")
+    async def pterodactyl_config_regex_leave(self, ctx: commands.Context, *, regex: str) -> None:
+        """Set the regex pattern to match leave messages on the server.
+
+        See [documentation](https://seacogs.coastalcommits.com/pterodactyl/setup/#my-chat-messages-arent-detected) for more information."""
+        await config.leave_regex.set(regex)
+        await ctx.send(f"Leave regex set to:\n{box(regex, 'regex')}")
+
+    @pterodactyl_config_regex.command(name = "achievement")
+    async def pterodactyl_config_regex_achievement(self, ctx: commands.Context, *, regex: str) -> None:
+        """Set the regex pattern to match achievement messages on the server.
+
+        See [documentation](https://seacogs.coastalcommits.com/pterodactyl/setup/#my-chat-messages-arent-detected) for more information."""
+        await config.achievement_regex.set(regex)
+        await ctx.send(f"Achievement regex set to:\n{box(regex, 'regex')}")
+
+    @pterodactyl_config.group(name = "messages", aliases = ['msg', 'msgs', 'message'])
+    async def pterodactyl_config_messages(self, ctx: commands.Context):
+        """Configure message settings."""
+
+    @pterodactyl_config_messages.command(name = "startup")
+    async def pterodactyl_config_messages_startup(self, ctx: commands.Context, *, message: str) -> None:
+        """Set the message that will be sent when the server starts."""
+        await config.startup_msg.set(message)
+        await ctx.send(f"Startup message set to: {message}")
+
+    @pterodactyl_config_messages.command(name = "shutdown")
+    async def pterodactyl_config_messages_shutdown(self, ctx: commands.Context, *, message: str) -> None:
+        """Set the message that will be sent when the server stops."""
+        await config.shutdown_msg.set(message)
+        await ctx.send(f"Shutdown message set to: {message}")
+
+    @pterodactyl_config_messages.command(name = "join")
+    async def pterodactyl_config_messages_join(self, ctx: commands.Context, *, message: str) -> None:
+        """Set the message that will be sent when a user joins the server. This is only shown in embeds."""
+        await config.join_msg.set(message)
+        await ctx.send(f"Join message set to: {message}")
+
+    @pterodactyl_config_messages.command(name = "leave")
+    async def pterodactyl_config_messages_leave(self, ctx: commands.Context, *, message: str) -> None:
+        """Set the message that will be sent when a user leaves the server. This is only shown in embeds."""
+        await config.leave_msg.set(message)
+        await ctx.send(f"Leave message set to: {message}")
+
+    @pterodactyl_config.command(name = "ip")
+    async def pterodactyl_config_mask_ip(self, ctx: commands.Context, mask: bool) -> None:
+        """Mask the IP addresses of users in console messages."""
+        await config.mask_ip.set(mask)
+        await ctx.send(f"IP masking set to {mask}")
+
+    @pterodactyl_config.command(name = "api")
+    async def pterodactyl_config_api(self, ctx: commands.Context, endpoint: str) -> None:
+        """Set the API endpoint for retrieving user avatars.
+
+        This is only used for retrieving user avatars for webhook messages.
+        See [PlayerDB](https://playerdb.co/) for valid endpoints. Usually, you should leave this as default."""
+        await config.api_endpoint.set(endpoint)
+        await ctx.send(f"API endpoint set to {endpoint}")
+
+    @pterodactyl_config_regex.group(name = "blacklist", aliases = ['block', 'blocklist'],)
+    async def pterodactyl_config_regex_blacklist(self, ctx: commands.Context):
+        """Blacklist regex patterns."""
+
+    @pterodactyl_config_regex_blacklist.command(name = "add")
+    async def pterodactyl_config_regex_blacklist_add(self, ctx: commands.Context, name: str, *, regex: str) -> None:
+        """Add a regex pattern to the blacklist."""
+        async with config.regex_blacklist() as blacklist:
+            blacklist: dict
+            if name not in blacklist:
+                blacklist.update({name: regex})
+                await ctx.send(f"Added `{name}` to the regex blacklist.\n{box(regex, 're')}")
+            else:
+                view = ConfirmView(ctx.author, disable_buttons=True)
+                msg = await ctx.send(f"Name `{name}` already exists in the blacklist. Would you like to update it? Current value:\n{box(blacklist[name], 're')}", view=view)
+                await view.wait()
+                if view.result is True:
+                    blacklist.update({name: regex})
+                    await msg.edit(content=f"Updated `{name}` in the regex blacklist.\n{box(regex, 're')}")
+                else:
+                    await msg.edit(content="Cancelled.")
+
+    @pterodactyl_config_regex_blacklist.command(name = "remove")
+    async def pterodactyl_config_regex_blacklist_remove(self, ctx: commands.Context, name: str) -> None:
+        """Remove a regex pattern from the blacklist."""
+        async with config.regex_blacklist() as blacklist:
+            blacklist: dict
+            if name in blacklist:
+                view = ConfirmView(ctx.author, disable_buttons=True)
+                msg = await ctx.send(f"Are you sure you want to remove `{name}` from the regex blacklist?\n{box(blacklist[name], 're')}", view=view)
+                await view.wait()
+                if view.result is True:
+                    del blacklist[name]
+                    await msg.edit(content=f"Removed `{name}` from the regex blacklist.")
+                else:
+                    await msg.edit(content="Cancelled.")
+            else:
+                await ctx.send(f"Name `{name}` does not exist in the blacklist.")
+
+    @pterodactyl_config.command(name = 'view', aliases = ['show'])
+    async def pterodactyl_config_view(self, ctx: commands.Context) -> None:
+        """View the current configuration."""
+        base_url = await config.base_url()
+        server_id = await config.server_id()
+        console_channel = await config.console_channel()
+        console_commands_enabled = await config.console_commands_enabled()
+        chat_channel = await config.chat_channel()
+        chat_command = await config.chat_command()
+        chat_regex = await config.chat_regex()
+        server_regex = await config.server_regex()
+        join_regex = await config.join_regex()
+        leave_regex = await config.leave_regex()
+        achievement_regex = await config.achievement_regex()
+        startup_msg = await config.startup_msg()
+        shutdown_msg = await config.shutdown_msg()
+        join_msg = await config.join_msg()
+        leave_msg = await config.leave_msg()
+        mask_ip = await config.mask_ip()
+        api_endpoint = await config.api_endpoint()
+        invite = await config.invite()
+        regex_blacklist: dict = await config.regex_blacklist()
+        topic_text = await config.topic()
+        topic_hostname = await config.topic_hostname()
+        topic_port = await config.topic_port()
+        embed = discord.Embed(color = await ctx.embed_color(), title="Pterodactyl Configuration")
+        embed.description = f"""**Base URL:** {base_url}
+                       **Server ID:** `{server_id}`
+                       **Console Channel:** <#{console_channel}>
+                       **Console Commands:** {self.get_bool_str(console_commands_enabled)}
+                       **Chat Channel:** <#{chat_channel}>
+                       **Startup Message:** {startup_msg}
+                       **Shutdown Message:** {shutdown_msg}
+                       **Join Message:** {join_msg}
+                       **Leave Message:** {leave_msg}
+                       **Mask IP:** {self.get_bool_str(mask_ip)}
+                       **API Endpoint:** `{api_endpoint}`
+                       **Invite:** {invite}
+
+                        **Topic Hostname:** `{topic_hostname}`
+                        **Topic Port:** `{topic_port}`
+                        **Topic Text:** {box(topic_text, 'yaml')}
+
+                       **Chat Command:** {box(chat_command, 'json')}
+                       **Chat Regex:** {box(chat_regex, 're')}
+                       **Server Regex:** {box(server_regex, 're')}
+                       **Join Regex:** {box(join_regex, 're')}
+                       **Leave Regex:** {box(leave_regex, 're')}
+                       **Achievement Regex:** {box(achievement_regex, 're')}"""
+        await ctx.send(embed=embed)
+        if not len(regex_blacklist) == 0:
+            regex_blacklist_embed = discord.Embed(color = await ctx.embed_color(), title="Regex Blacklist")
+            for name, regex in regex_blacklist.items():
+                regex_blacklist_embed.add_field(name=name, value=box(regex, 're'), inline=False)
+            await ctx.send(embed=regex_blacklist_embed)
+
+    def get_bool_str(self, inp: bool) -> str:
+        """Return a string representation of a boolean."""
+        return "Enabled" if inp else "Disabled"

pterodactyl/websocket.py

@@ -0,0 +1,251 @@
+# pylint: disable=cyclic-import
+import json
+import re
+from typing import Optional, Union
+
+import aiohttp
+import discord
+import websockets
+from pydactyl import PterodactylClient
+from redbot.core.utils.chat_formatting import bold, pagify
+
+from pterodactyl.config import config
+from pterodactyl.logger import logger, websocket_logger
+from pterodactyl.pterodactyl import Pterodactyl
+
+
+async def establish_websocket_connection(coginstance: Pterodactyl) -> None:
+    await coginstance.bot.wait_until_red_ready()
+    base_url = await config.base_url()
+    base_url = base_url[:-1] if base_url.endswith('/') else base_url
+
+    logger.info("Establishing WebSocket connection")
+
+    websocket_credentials = await retrieve_websocket_credentials(coginstance)
+
+    async with websockets.connect(websocket_credentials['data']['socket'], origin=base_url, ping_timeout=60, logger=websocket_logger) as websocket:
+        logger.info("WebSocket connection established")
+
+        auth_message = json.dumps({"event": "auth", "args": [websocket_credentials['data']['token']]})
+        await websocket.send(auth_message)
+        logger.info("Authentication message sent")
+
+        coginstance.websocket = websocket
+
+        while True: # pylint: disable=too-many-nested-blocks
+            message = json.loads(await websocket.recv())
+            if message['event'] in ('token expiring', 'token expired'):
+                logger.info("Received token expiring/expired event. Refreshing token.")
+                websocket_credentials = await retrieve_websocket_credentials(coginstance)
+                auth_message = json.dumps({"event": "auth", "args": [websocket_credentials['data']['token']]})
+                await websocket.send(auth_message)
+                logger.info("Authentication message sent")
+
+            if message['event'] == 'auth success':
+                logger.info("WebSocket authentication successful")
+
+            if message['event'] == 'console output' and await config.console_channel() is not None:
+                regex_blacklist: dict = await config.regex_blacklist()
+                matches = [re.search(regex, message['args'][0]) for regex in regex_blacklist.values()]
+
+                if await config.current_status() in ('running', '') and not any(matches):
+                    content = remove_ansi_escape_codes(message['args'][0])
+                    if await config.mask_ip() is True:
+                        content = mask_ip(content)
+
+                    console_channel = coginstance.bot.get_channel(await config.console_channel())
+                    chat_channel = coginstance.bot.get_channel(await config.chat_channel())
+                    if console_channel is not None:
+                        if content.startswith('['):
+                            pagified_content = pagify(content, delims=[" ", "\n"])
+                            for page in pagified_content:
+                                await console_channel.send(content=page, allowed_mentions=discord.AllowedMentions.none())
+
+                    server_message = await check_if_server_message(content)
+                    if server_message:
+                        if chat_channel is not None:
+                            await chat_channel.send(server_message if len(server_message) < 2000 else server_message[:1997] + '...', allowed_mentions=discord.AllowedMentions.none())
+
+                    chat_message = await check_if_chat_message(content)
+                    if chat_message:
+                        info = await get_info(chat_message['username'])
+                        if info is not None:
+                            await send_chat_discord(coginstance, chat_message['username'], chat_message['message'], info['data']['player']['avatar'])
+                        else:
+                            await send_chat_discord(coginstance, chat_message['username'], chat_message['message'], 'https://seafsh.cc/u/j3AzqQ.png')
+
+                    join_message = await check_if_join_message(content)
+                    if join_message:
+                        if chat_channel is not None:
+                            if coginstance.bot.embed_requested(chat_channel):
+                                await chat_channel.send(embed=await generate_join_leave_embed(join_message, True))
+                            else:
+                                await chat_channel.send(f"{join_message} joined the game", allowed_mentions=discord.AllowedMentions.none())
+
+                    leave_message = await check_if_leave_message(content)
+                    if leave_message:
+                        if chat_channel is not None:
+                            if coginstance.bot.embed_requested(chat_channel):
+                                await chat_channel.send(embed=await generate_join_leave_embed(leave_message, False))
+                            else:
+                                await chat_channel.send(f"{leave_message} left the game", allowed_mentions=discord.AllowedMentions.none())
+
+                    achievement_message = await check_if_achievement_message(content)
+                    if achievement_message:
+                        if chat_channel is not None:
+                            if coginstance.bot.embed_requested(chat_channel):
+                                await chat_channel.send(embed=await generate_achievement_embed(achievement_message['username'], achievement_message['achievement'], achievement_message['challenge']))
+                            else:
+                                await chat_channel.send(f"{achievement_message['username']} has {'completed the challenge' if achievement_message['challenge'] else 'made the advancement'} {achievement_message['achievement']}")
+
+            if message['event'] == 'status':
+                old_status = await config.current_status()
+                current_status = message['args'][0]
+                if old_status != current_status:
+                    await config.current_status.set(current_status)
+                    if await config.console_channel() is not None:
+                        console = coginstance.bot.get_channel(await config.console_channel())
+                        if console is not None:
+                            await console.send(f"Server status changed! `{current_status}`")
+                    if await config.chat_channel() is not None:
+                        if current_status == 'running' and await config.startup_msg() is not None:
+                            chat = coginstance.bot.get_channel(await config.chat_channel())
+                            if chat is not None:
+                                await chat.send(await config.startup_msg())
+                        if current_status == 'stopping' and await config.shutdown_msg() is not None:
+                            chat = coginstance.bot.get_channel(await config.chat_channel())
+                            if chat is not None:
+                                await chat.send(await config.shutdown_msg())
+
+async def retrieve_websocket_credentials(coginstance: Pterodactyl) -> Optional[dict]:
+    pterodactyl_keys = await coginstance.bot.get_shared_api_tokens("pterodactyl")
+    api_key = pterodactyl_keys.get("api_key")
+    if api_key is None:
+        coginstance.task.cancel()
+        raise ValueError("Pterodactyl API key not set. Please set it using `[p]set api`.")
+    base_url = await config.base_url()
+    if base_url is None:
+        coginstance.task.cancel()
+        raise ValueError("Pterodactyl base URL not set. Please set it using `[p]pterodactyl config url`.")
+    server_id = await config.server_id()
+    if server_id is None:
+        coginstance.task.cancel()
+        raise ValueError("Pterodactyl server ID not set. Please set it using `[p]pterodactyl config serverid`.")
+
+    client = PterodactylClient(base_url, api_key).client
+    coginstance.client = client
+    websocket_credentials = client.servers.get_websocket(server_id)
+    logger.debug("""Websocket connection details retrieved:
+                        Socket: %s
+                        Token: %s...""",
+                        websocket_credentials['data']['socket'],
+                        websocket_credentials['data']['token'][:20]
+                    )
+    return websocket_credentials
+    #NOTE - The token is truncated to prevent it from being logged in its entirety, for security reasons
+
+def remove_ansi_escape_codes(text: str) -> str:
+    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+    #NOTE - https://chat.openai.com/share/d92f9acf-d776-4fd6-a53f-b14ac15dd540
+    return ansi_escape.sub('', text)
+
+async def check_if_server_message(text: str) -> Union[bool, str]:
+    regex = await config.server_regex()
+    match: Optional[re.Match[str]] = re.match(regex, text)
+    if match:
+        logger.debug("Message is a server message")
+        return match.group(1)
+    return False
+
+async def check_if_chat_message(text: str) -> Union[bool, dict]:
+    regex = await config.chat_regex()
+    match: Optional[re.Match[str]] = re.match(regex, text)
+    if match:
+        groups = {"username": match.group(1), "message": match.group(2)}
+        logger.debug("Message is a chat message\n%s", json.dumps(groups))
+        return groups
+    return False
+
+async def check_if_join_message(text: str) -> Union[bool, str]:
+    regex = await config.join_regex()
+    match: Optional[re.Match[str]] = re.match(regex, text)
+    if match:
+        logger.debug("Message is a join message")
+        return match.group(1)
+    return False
+
+async def check_if_leave_message(text: str) -> Union[bool, str]:
+    regex = await config.leave_regex()
+    match: Optional[re.Match[str]] = re.match(regex, text)
+    if match:
+        logger.debug("Message is a leave message")
+        return match.group(1)
+    return False
+
+async def check_if_achievement_message(text: str) -> Union[bool, dict]:
+    regex = await config.achievement_regex()
+    match: Optional[re.Match[str]] = re.match(regex, text)
+    if match:
+        groups = {"username": match.group(1), "achievement": match.group(3)}
+        if match.group(2) == "completed the challenge":
+            groups["challenge"] = True
+        else:
+            groups["challenge"] = False
+        logger.debug("Message is an achievement message")
+        return groups
+    return False
+
+async def get_info(username: str) -> Optional[dict]:
+    logger.debug("Retrieving player info for %s", username)
+    endpoint = await config.api_endpoint()
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"https://playerdb.co/api/player/{endpoint}/{username}") as response:
+            if response.status == 200:
+                logger.debug("Player info retrieved for %s", username)
+                return await response.json()
+            logger.error("Failed to retrieve player info for %s: %s", username, response.status)
+            return None
+
+async def send_chat_discord(coginstance: Pterodactyl, username: str, message: str, avatar_url: str) -> None:
+    logger.debug("Sending chat message to Discord")
+    channel = coginstance.bot.get_channel(await config.chat_channel())
+    if channel is not None:
+        webhooks = await channel.webhooks()
+        webhook = discord.utils.get(webhooks, name="Pterodactyl Chat")
+        if webhook is None:
+            webhook = await channel.create_webhook(name="Pterodactyl Chat")
+        await webhook.send(content=message, username=username, avatar_url=avatar_url, allowed_mentions=discord.AllowedMentions(everyone=False, roles=False, users=True))
+        logger.debug("Chat message sent to Discord")
+    else:
+        logger.warning("Chat channel not set. Skipping sending chat message to Discord")
+
+async def generate_join_leave_embed(username: str, join: bool) -> discord.Embed:
+    embed = discord.Embed()
+    embed.color = discord.Color.green() if join else discord.Color.red()
+    embed.description = await config.join_msg() if join else await config.leave_msg()
+    info = await get_info(username)
+    if info:
+        embed.set_author(name=username, icon_url=info['data']['player']['avatar'])
+    else:
+        embed.set_author(name=username, icon_url='https://seafsh.cc/u/j3AzqQ.png')
+    embed.timestamp = discord.utils.utcnow()
+    return embed
+
+async def generate_achievement_embed(username: str, achievement: str, challenge: bool) -> discord.Embed:
+    embed = discord.Embed()
+    embed.color = discord.Color.from_str('#a800a7') if challenge else discord.Color.from_str('#54fb54')
+    embed.description = f"{bold(username)} has {'completed the challenge' if challenge else 'made the advancement'} {bold(achievement)}"
+    info = await get_info(username)
+    if info:
+        embed.set_author(name=username, icon_url=info['data']['player']['avatar'])
+    else:
+        embed.set_author(name=username, icon_url='https://seafsh.cc/u/j3AzqQ.png')
+    embed.timestamp = discord.utils.utcnow()
+    return embed
+
+def mask_ip(string: str) -> str:
+    def check(match: re.Match[str]):
+        ip = match.group(0)
+        masked_ip = '.'.join(r'\*' * len(octet) for octet in ip.split('.'))
+        return masked_ip
+    return re.sub(r'\b(?:\d{1,3}\.){3}\d{1,3}\b', check, string)

pyproject.toml

@@ -5,19 +5,22 @@ description = "My assorted cogs for Red-DiscordBot."
 authors = ["SeaswimmerTheFsh"]
 license = "MPL 2"
 readme = "README.md"
+package-mode = false
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.12"
+python = ">=3.11,<3.12"
 Red-DiscordBot = "^3.5.5"
-pytimeparse2 = "^1.7.1"
+py-dactyl = "^2.0.4"
-humanize = "^4.8.0"
+websockets = "^12.0"
-feedparser = "^6.0.11"
+pillow = "^10.3.0"
+numpy = "^1.26.4"
 
 [tool.poetry.group.dev]
 optional = true
 
 [tool.poetry.group.dev.dependencies]
-pylint = "^2.17.5"
+ruff = "^0.3.1"
+pylint = "^3.1.0"
 
 [tool.poetry.group.docs]
 optional = true
@@ -33,3 +36,82 @@ mkdocs-redirects = "^1.2.1"
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 320
+indent-width = 4
+
+# Assume Python 3.11
+target-version = "py311"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["F", "W", "E", "C901"]
+ignore = ["C901"]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"

updatechecker/__init__.py

@@ -1,10 +0,0 @@
-from .updatechecker import UpdateChecker
-
-__red_end_user_data_statement__ = (
-    "This cog does not persistently store data or metadata about users."
-)
-
-
-async def setup(bot):
-    cog = UpdateChecker(bot)
-    await bot.add_cog(cog)

updatechecker/info.json

@@ -1,17 +0,0 @@
-{
-    "author": [
-        "SeaswimmerTheFsh", "Neuro Assassin"
-    ],
-    "install_msg": "Thank you for downloading this cog.",
-    "name": "updatechecker",
-    "short": "Notifies you when an update for a repo is available.",
-    "description": "This cog will tell when there is an update available for a repository you have added for your bot, and, depending on settings, will auto update or will just notify you.",
-    "tags": [
-        "tools"
-    ],
-    "requirements": [
-        "feedparser"
-    ],
-    "hidden": false,
-    "disabled": false
-}

updatechecker/updatechecker.py

@@ -1,460 +0,0 @@
-"""
-MIT License
-
-Copyright (c) 2018-Present NeuroAssassin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-"""
-
-# Huge thanks to Sinbad for allowing me to copy parts of his RSS cog
-# (https://github.com/mikeshardmind/SinbadCogs/tree/v3/rss), which I
-# used to grab the latest commits from repositories.
-
-# Also, the code I use for updating repos I took directly from Red,
-# and just took out the message interactions
-
-import asyncio
-import traceback
-from datetime import datetime
-from urllib.parse import urlparse
-
-import aiohttp
-import discord
-from discord.ext import tasks
-from redbot.cogs.downloader.repo_manager import Repo
-from redbot.core import Config, commands
-from redbot.core.utils.chat_formatting import box, humanize_list, inline
-
-import feedparser
-
-
-class UpdateChecker(commands.Cog):
-    """Get notices or auto-update cogs when an update is available for its repo"""
-
-    def __init__(self, bot):
-        self.bot = bot
-        self.session = aiohttp.ClientSession()
-        self.conf = Config.get_conf(self, identifier=473541068378341376)
-        default_global = {
-            "repos": {},
-            "auto": False,
-            "gochannel": 0,
-            "embed": True,
-            "whitelist": [],
-            "blacklist": [],
-        }
-        self.conf.register_global(**default_global)
-        self.task = self.bot.loop.create_task(self.bg_task())
-
-    async def cog_unload(self):
-        self.__unload()
-
-    def __unload(self):
-        self.task.cancel()
-        self.session.detach()
-
-    async def red_delete_data_for_user(self, **kwargs): # pylint: disable=unused-argument
-        """This cog does not store user data"""
-        return
-
-    @tasks.loop(minutes=1)
-    async def bg_task(self):
-        cog = self.bot.get_cog("Downloader")
-        if cog is not None:
-            data = await self.conf.all()
-            repos = data["repos"]
-            channel = data["gochannel"]
-            auto = data["auto"]
-            use_embed = data["embed"]
-            whitelist = data["whitelist"]
-            blacklist = data["blacklist"]
-            if channel:
-                channel = self.bot.get_channel(channel)
-                if channel is None:
-                    await self.bot.send_to_owners(
-                        "[Update Checker] It appears that I am no longer allowed to send messages to the designated update channel. "
-                        "From now on, it will DM you."
-                    )
-                    await self.conf.gochannel.set(0)
-                    send = self.bot.send_to_owners
-                else:
-                    use_embed = (
-                        use_embed and channel.permissions_for(channel.guild.me).embed_links
-                    )
-                    send = channel.send
-            else:
-                send = self.bot.send_to_owners
-
-            all_repos = cog._repo_manager.get_all_repo_names() # pylint: disable=protected-access
-            for repo in all_repos:
-                if not (repo in list(repos.keys())):
-                    repos[repo] = "--default--"
-            await self.conf.repos.set(repos)
-
-            saving_dict = {k: v for k, v in repos.items() if k in all_repos}
-            for repo_name, commit_saved in saving_dict.items():
-                repo = cog._repo_manager.get_repo(repo_name) # pylint: disable=protected-access
-                if not repo:
-                    continue
-                parsed_url = urlparse(repo.url)
-                if parsed_url.netloc == "github.com":
-                    url = repo.url + r"/commits/" + repo.branch + ".atom"
-                    response = await self.fetch_feed(url)
-                    try:
-                        commit = response.entries[0]["id"][33:]
-                        chash = "[" + commit + "](" + response.entries[0]["link"] + ")"
-                        cn = response.entries[0]["title"] + " - " + response.entries[0]["author"]
-                        image = response.entries[0]["media_thumbnail"][0]["url"].split("?")[0]
-                    except AttributeError:
-                        continue
-                else:
-                    url = repo.url + r"/rss/branch/" + repo.branch
-                    response = await self.fetch_feed(url)
-                    try:
-                        commit = response.entries[0]["id"][33:]
-                        chash = "[" + commit + "](" + response.entries[0]["link"] + ")"
-                        cn = response.entries[0]["title"] + " - " + response.entries[0]["author"]
-                        image = await self.fetch_gitea_thumbnail(parsed_url.scheme + "://" + parsed_url.netloc + "/api/v1/repos" + parsed_url.path)
-                    except AttributeError:
-                        continue
-                saving_dict[repo_name] = commit
-                if whitelist:
-                    if repo_name not in whitelist:
-                        continue
-                if repo_name in blacklist:
-                    continue
-                # CN is used here for backwards compatability, don't want people to get an
-                # update for each and every one of their cogs when updating this cog
-                if commit_saved not in (commit, cn, '--default--'):
-                    if use_embed:
-                        e = discord.Embed(
-                            title="Update Checker",
-                            description=f"Update available for repo: {repo.name}",
-                            timestamp=datetime.utcnow(),
-                            color=0x00FF00,
-                        )
-                        e.add_field(name="URL", value=repo.url)
-                        e.add_field(name="Branch", value=repo.branch)
-                        e.add_field(name="Commit", value=cn)
-                        e.add_field(name="Hash", value=chash)
-                        if image is not None:
-                            e.set_thumbnail(url=image)
-                    else:
-                        e = box(
-                            "[Update Checker]"
-                            f"    Repo: {repo.name}\n"
-                            f"     URL: {repo.url}\n"
-                            f"  Commit: {cn}\n"
-                            f"    Hash: {commit}\n"
-                            f"    Time: {datetime.utcnow()}",
-                            'css'
-                        )
-                    try:
-                        if use_embed:
-                            await send(embed=e)
-                        else:
-                            await send(e)
-                    except discord.Forbidden:
-                        # send_to_owners suppresses Forbidden, logging it to console.
-                        # As a result, this will only happen if a channel was set.
-                        await self.bot.send_to_owners(
-                            "[Update Checker] It appears that I am no longer allowed to send messages to the designated update channel. "
-                            "From now on, it will DM you."
-                        )
-                        if use_embed:
-                            await self.bot.send_to_owners(embed=e)
-                        else:
-                            await self.bot.send_to_owners(e)
-                        await self.conf.gochannel.set(0)
-                    # Was already inaccessible before I got here, so I'm just gonna leave it and look at it later -- Sea
-                    # try:
-                    #     await channel.send(
-                    #         f"[Update Checker] Update found for repo: {repo.name}.  Updating repos..."
-                    #     )
-                    # except AttributeError:
-                    #     owner = (await self.bot.application_info()).owner
-                    #     await owner.send(
-                    #         "[Update Checker] It appears that the channel for this cog has been deleted.  From now on, it will DM you."
-                    #     )
-                    #     channel = owner
-                    #     await self.conf.gochannel.set(0)
-                    # except discord.errors.Forbidden:
-                    #     owner = (await self.bot.application_info()).owner
-                    #     await owner.send(
-                    #         "[Update Checker] It appears that I am no longer allowed to send messages to the designated update channel.  From now on, it will DM you."
-                    #     )
-                    #     channel = owner
-                    #     await self.conf.gochannel.set(0)
-                    # # Just a copy of `[p]cog update`, but without using ctx things
-                    # try:
-                    #     installed_cogs = set(await cog.installed_cogs())
-                    #     updated = await cog._repo_manager.update_all_repos()
-                    #     updated_cogs = set(
-                    #         cog for repo in updated for cog in repo.available_cogs
-                    #     )
-                    #     installed_and_updated = updated_cogs & installed_cogs
-                    #     if installed_and_updated:
-                    #         await cog._reinstall_requirements(installed_and_updated)
-                    #         await cog._reinstall_cogs(installed_and_updated)
-                    #         await cog._reinstall_libraries(installed_and_updated)
-                    #         cognames = {c.name for c in installed_and_updated}
-                    #         message = humanize_list(tuple(map(inline, cognames)))
-                    # except Exception as error:
-                    #     exception_log = (
-                    #         "Exception while updating repos in Update Checker \n"
-                    #     )
-                    #     exception_log += "".join(
-                    #         traceback.format_exception(
-                    #             type(error), error, error.__traceback__
-                    #         )
-                    #     )
-                    #     try:
-                    #         await channel.send(
-                    #             f"[Update Checker]: Error while updating repos.\n\n{exception_log}"
-                    #         )
-                    #     except discord.errors.Forbidden:
-                    #         pass
-                    # else:
-                    #     try:
-                    #         await channel.send(
-                    #             f"[Update Checker]: Ran cog update.  Updated cogs: {message}"
-                    #         )
-                    #     except discord.errors.Forbidden:
-                    #         pass
-                await asyncio.sleep(1)
-            await self.conf.repos.set(saving_dict)
-
-    async def fetch_feed(self, url: str):
-        # Thank's to Sinbad's rss cog after which I copied this
-        timeout = aiohttp.client.ClientTimeout(total=15)
-        try:
-            async with self.session.get(url, timeout=timeout) as response:
-                data = await response.read()
-        except (aiohttp.ClientError, asyncio.TimeoutError):
-            return None
-
-        ret = feedparser.parse(data)
-        if ret.bozo:
-            return None
-        return ret
-
-    async def fetch_gitea_thumbnail(self, url: str) -> str:
-        timeout = aiohttp.client.ClientTimeout(total=15)
-        try:
-            async with self.session.get(url, timeout=timeout) as response:
-                data = await response.json()
-        except (aiohttp.ClientError, asyncio.TimeoutError):
-            return None
-
-        return data['avatar_url']
-
-    @commands.is_owner()
-    @commands.group(name="cogupdater", aliases=["cu"])
-    async def update(self, ctx: commands.Context):
-        """Group command for controlling the update checker cog."""
-
-    @commands.is_owner()
-    @update.command()
-    async def auto(self, ctx: commands.Context):
-        """Changes automatic cog updates to the opposite setting."""
-        # Was already inaccessible before I got here, so I'm just gonna leave it and look at it later -- Sea
-        # auto = await self.conf.auto()
-        # await self.conf.auto.set(not auto)
-        # status = "disabled" if auto else "enabled"
-        # await ctx.send(f"Auto cog updates are now {status}")
-        await ctx.send(
-            "This command is disabled for the time being.  Cog updates will not run automatically, however notifications will still send."
-        )
-
-    @commands.is_owner()
-    @update.command()
-    async def channel(self, ctx: commands.Context, channel: discord.TextChannel = None):
-        """
-        Sets a channel for update messages to go to.
-
-        If argument is not supplied, it will be sent to the default notifications channel(s) specified in `[p]set ownernotifications`.
-        By default, this goes to owner DMs.
-        """
-        if channel:
-            await self.conf.gochannel.set(channel.id)
-            await ctx.send(f"Update messages will now be sent to {channel.mention}")
-        else:
-            await self.conf.gochannel.set(0)
-            await ctx.send("Update messages will now be DMed to you.")
-
-    @commands.is_owner()
-    @update.command()
-    async def settings(self, ctx: commands.Context):
-        """See settings for the Update Checker cog.
-
-        Right now, this shows whether the bot updates cogs automatically and what channel logs are sent to.
-        """
-        auto = await self.conf.auto()
-        channel = await self.conf.gochannel()
-        embed = await self.conf.embed()
-        if embed:
-            e = discord.Embed(title="Update Checker Settings", color=0x00FF00)
-            e.add_field(name="Automatic Cog Updates", value=str(auto))
-            if channel == 0:
-                channel = "Direct Messages"
-            else:
-                channel = self.bot.get_channel(channel).name
-                if channel is None:
-                    channel = "Unknown"
-            e.add_field(name="Update Channel", value=channel)
-            await ctx.send(embed=e)
-        else:
-            if channel == 0:
-                channel = "Direct Messages"
-            else:
-                channel = self.bot.get_channel(channel).name
-                if channel is None:
-                    channel = "Unknown"
-            message = (
-                "```css\n"
-                "[Update Checker settings]"
-                "``````css\n"
-                f"[Automatic Cog Updates]: {str(auto)}\n"
-                f"       [Update Channel]: {channel}"
-                "```"
-            )
-            await ctx.send(message)
-
-    @commands.is_owner()
-    @update.command()
-    async def embed(self, ctx: commands.Context):
-        """Toggles whether to use embeds or colorful codeblock messages when sending an update."""
-        c = await self.conf.embed()
-        await self.conf.embed.set(not c)
-        word = "disabled" if c else "enabled"
-        await ctx.send(f"Embeds are now {word}")
-
-    @commands.is_owner()
-    @update.group(name="list")
-    async def whiteblacklist(self, ctx: commands.Context):
-        """Whitelist/blacklist certain repositories from which to receive updates."""
-        if ctx.invoked_subcommand is None:
-            data = await self.conf.all()
-            whitelist = data["whitelist"]
-            blacklist = data["blacklist"]
-            await ctx.send(
-                f"Whitelisted: {humanize_list(tuple(map(inline, whitelist or ['None'])))}\nBlacklisted: {humanize_list(tuple(map(inline, blacklist or ['None'])))}"
-            )
-
-    @whiteblacklist.group()
-    async def whitelist(self, ctx: commands.Context):
-        """Whitelist certain repos from which to receive updates."""
-
-    @whitelist.command(name="add")
-    async def whitelistadd(self, ctx: commands.Context, *repos: Repo):
-        """Add repos to the whitelist"""
-        data = await self.conf.whitelist()
-        ds = set(data)
-        ns = {r.name for r in repos}
-        ss = ds | ns
-        await self.conf.whitelist.set(list(ss))
-        await ctx.send(f"Whitelist update successful: {humanize_list(tuple(map(inline, ss)))}")
-
-    @whitelist.command(name="remove")
-    async def whitelistremove(self, ctx: commands.Context, *repos: Repo):
-        """Remove repos from the whitelist"""
-        data = await self.conf.whitelist()
-        ds = set(data)
-        ns = {r.name for r in repos}
-        ss = ds - ns
-        await self.conf.whitelist.set(list(ss))
-        await ctx.send(
-            f"Whitelist update successful: {humanize_list(tuple(map(inline, ss or ['None'])))}"
-        )
-
-    @whitelist.command(name="clear")
-    async def whitelistclear(self, ctx: commands.Context):
-        """Removes all repos from the whitelist"""
-        await self.conf.whitelist.set([])
-        await ctx.send("Whitelist update successful")
-
-    @whiteblacklist.group()
-    async def blacklist(self, ctx: commands.Context):
-        """Blacklist certain repos from which to receive updates."""
-
-    @blacklist.command(name="add")
-    async def blacklistadd(self, ctx: commands.Context, *repos: Repo):
-        """Add repos to the blacklist"""
-        data = await self.conf.blacklist()
-        ds = set(data)
-        ns = {r.name for r in repos}
-        ss = ds | ns
-        await self.conf.blacklist.set(list(ss))
-        await ctx.send(f"Backlist update successful: {humanize_list(tuple(map(inline, ss)))}")
-
-    @blacklist.command(name="remove")
-    async def blacklistremove(self, ctx: commands.Context, *repos: Repo):
-        """Remove repos from the blacklist"""
-        data = await self.conf.blacklist()
-        ds = set(data)
-        ns = {r.name for r in repos}
-        ss = ds - ns
-        await self.conf.blacklist.set(list(ss))
-        await ctx.send(
-            f"Blacklist update successful: {humanize_list(tuple(map(inline, ss or ['None'])))}"
-        )
-
-    @blacklist.command(name="clear")
-    async def blacklistclear(self, ctx: commands.Context):
-        """Removes all repos from the blacklist"""
-        await self.conf.blacklist.set([])
-        await ctx.send("Blacklist update successful")
-
-    @commands.is_owner()
-    @update.group(name="task")
-    async def _group_update_task(self, ctx: commands.Context):
-        """View the status of the task (the one checking for updates)."""
-
-    @_group_update_task.command()
-    async def status(self, ctx: commands.Context):
-        """Get the current status of the update task."""
-        message = "Task is currently "
-        cancelled = self.task.cancelled()
-        if cancelled:
-            message += "canceled."
-        else:
-            done = self.task.done()
-            if done:
-                message += "done."
-            else:
-                message += "running."
-        try:
-            self.task.exception()
-        except asyncio.exceptions.InvalidStateError:
-            message += "  No error has been encountered."
-        else:
-            message += f"  An error has been encountered.  Please run `{ctx.prefix}cogupdater task error` and report it to SeaswimmerTheFsh (seasw.) on the help server."
-        await ctx.send(message)
-
-    @_group_update_task.command()
-    async def error(self, ctx: commands.Context):
-        """Gets the latest error of the update task."""
-        try:
-            e = self.task.exception()
-        except asyncio.exceptions.InvalidStateError:
-            message = "No error has been encountered."
-        else:
-            ex = traceback.format_exception(type(e), e, e.__traceback__)
-            message = "An error has been encountered:" + box("".join(ex), "py")
-        await ctx.send(message)