diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index cf3ea84..5bb707e 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -14,32 +14,36 @@ body:
options:
- label: Did you read the error page and view the common errors?
required: true
+ - type: dropdown
+ id: location
+ attributes:
+ label: Bug Location
+ description: Where did this bug occur? If you select "Other", please specify in the Bug Description section.
+ options:
+ - While installing.
+ - While updating.
+ - While uninstalling.
+ - When running a command.
+ - When trying to run a command.
+ - When using a text command, such as ".about" or ".installer".
+ - When trying to turn on the bot.
+ - Other (please specify in the Bug Description section)
+ validations:
+ required: true
- type: textarea
id: description
attributes:
label: Bug Description
- description: Explain what the bug was and where it occurred.
+ description: Explain the bug and what happened before it appeared.
placeholder: Bug explanation...
validations:
required: true
- - type: dropdown
+ - type: textarea
id: version
attributes:
label: Version
- description: What version of DexScript is your bot using?
- options:
- - 0.1
- - 0.2
- - 0.2.1
- - 0.2.2
- - 0.3
- - 0.3.1
- - 0.4
- - 0.4.1
- - 0.4.2
- - 0.4.3
- - 0.4.3.1
- default: 10
+ description: Add your version number here. You can fetch it using the `.about` command.
+ placeholder: Version number...
validations:
required: true
- type: dropdown
diff --git a/.github/workflows/ruff.yml b/.github/workflows/ruff.yml
index b732972..11a2ade 100644
--- a/.github/workflows/ruff.yml
+++ b/.github/workflows/ruff.yml
@@ -5,4 +5,4 @@ jobs:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- - uses: astral-sh/ruff-action@v2
\ No newline at end of file
+ - uses: astral-sh/ruff-action@v3
\ No newline at end of file
diff --git a/DATAPOLICY.md b/DATAPOLICY.md
new file mode 100644
index 0000000..1ff136e
--- /dev/null
+++ b/DATAPOLICY.md
@@ -0,0 +1,20 @@
+# Data Policy
+
+**"We"** refers to the DexScript team, consisting of DotZZ (dot_zz on Discord). This policy explains how DexScript interacts with your application’s data and files.
+
+## Data Interaction
+
+We do not collect, store, or access any data from your application. DexScript only interacts with your application’s data for functionality, and we do not have access to your bot's data, nor do we operate DexScript's commands.
+
+## File Modifications
+
+During the DexScript installation process, DexScript will modify the following based on the Ballsdex version:
+
+- **2.22.0-** - `ballsdex/core/bot.py`.
+- **2.22.0+** - `config.yml`
+
+DexScript will add a single line of code to allow the DexScript extension to load when your application starts. This modification is solely for the purpose of running DexScript. You can view the code added by checking the `DexScript/github/installer.py` file in the official DexScript GitHub repository.
+
+## Contact Information
+
+For any questions, comments, or concerns regarding this data policy, please contact DotZZ on Discord (dot_zz).
diff --git a/DexScript/github/installer.py b/DexScript/github/installer.py
new file mode 100644
index 0000000..6f02e2f
--- /dev/null
+++ b/DexScript/github/installer.py
@@ -0,0 +1,382 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# OFFICIAL DEXSCRIPT INSTALLER #
+# #
+# This will install DexScript onto your bot. #
+# For additional information, read the wiki guide. #
+# An explanation of the code will be provided below. #
+# #
+# THIS CODE IS RAN VIA THE `EVAL` COMMAND. #
+
+
+import os
+import re
+import shutil
+from base64 import b64decode
+from dataclasses import dataclass
+from dataclasses import field as datafield
+from datetime import datetime
+from enum import Enum
+from io import StringIO
+from traceback import format_exc
+
+import discord
+import requests
+from ballsdex.settings import settings
+from discord.ext import commands
+
+UPDATING = os.path.isdir("ballsdex/packages/dexscript")
+
+
+class MigrationType(Enum):
+ APPEND = 1
+ REPLACE = 2
+
+
+@dataclass
+class InstallerConfig:
+ """
+ Configuration class for the installer.
+ """
+
+ github = ["Dotsian/DexScript", "dev"]
+ files = ["__init__.py", "cog.py", "commands.py", "parser.py", "utils.py"]
+ appearance = {
+ "logo": "https://raw.githubusercontent.com/Dotsian/DexScript/refs/heads/dev/assets/DexScriptLogo.png",
+ "logo_error": "https://raw.githubusercontent.com/Dotsian/DexScript/refs/heads/dev/assets/DexScriptLogoError.png",
+ "banner": "https://raw.githubusercontent.com/Dotsian/DexScript/refs/heads/dev/assets/DexScriptPromo.png",
+ }
+ install_migrations = [
+ (
+ "||await self.add_cog(Core(self))",
+ '||await self.load_extension("ballsdex.packages.dexscript")\n',
+ MigrationType.APPEND,
+ ),
+ (
+ '||await self.load_extension("ballsdex.core.dexscript")\n',
+ '||await self.load_extension("ballsdex.packages.dexscript")\n',
+ MigrationType.REPLACE,
+ ),
+ ]
+ uninstall_migrations = [
+ '||await self.load_extension("ballsdex.core.dexscript")\n',
+ '||await self.load_extension("ballsdex.packages.dexscript")\n',
+ ]
+ path = "ballsdex/packages/dexscript"
+
+
+@dataclass
+class Logger:
+ name: str
+ output: list = datafield(default_factory=list)
+
+ def log(self, content, level):
+ current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+ self.output.append(f"{current_time} [{self.name}] {level} - {content}")
+
+ def file(self, name: str):
+ return discord.File(StringIO("\n".join(self.output)), filename=name)
+
+
+config = InstallerConfig()
+logger = Logger("DEXSCRIPT-INSTALLER")
+
+
+class InstallerEmbed(discord.Embed):
+ def __init__(self, installer, embed_type="setup"):
+ super().__init__()
+
+ self.installer = installer
+
+ match embed_type:
+ case "setup":
+ self.setup()
+ case "error":
+ self.error()
+ case "installed":
+ self.installed()
+ case "uninstalled":
+ self.uninstalled()
+
+ def setup(self):
+ self.title = "DexScript Installation"
+ self.description = "Welcome to the DexScript installer!"
+ self.color = discord.Color.from_str("#03BAFC")
+ self.timestamp = datetime.now()
+
+ latest_version = self.installer.latest_version
+ current_version = self.installer.current_version
+
+ if UPDATING and latest_version and current_version and latest_version != current_version:
+ self.description += (
+ "\n\n**Your current DexScript package version is outdated.**\n"
+ f"The latest version of DexScript is version {latest_version}, "
+ f"while this DexScript instance is on version {current_version}."
+ )
+
+ self.set_image(url=config.appearance["banner"])
+
+ def error(self):
+ self.title = "DexScript ERROR"
+ self.description = (
+ "An error occured within DexScript's installation setup.\n"
+ "Please submit a bug report and attach the file provided."
+ )
+ self.color = discord.Color.red()
+ self.timestamp = datetime.now()
+
+ if logger.output != []:
+ self.description += f"\n```{logger.output[-1]}```"
+
+ self.installer.interface.attachments = [logger.file("DexScript.log")]
+
+ self.set_thumbnail(url=config.appearance["logo_error"])
+
+ def installed(self):
+ self.title = "DexScript Installed!"
+ self.description = (
+ "DexScript has been succesfully installed to your bot.\n"
+ f"Run the `{settings.prefix}about` command to view details about DexScript."
+ )
+ self.color = discord.Color.from_str("#03BAFC")
+ self.timestamp = datetime.now()
+
+ self.set_thumbnail(url=config.appearance["logo"])
+
+ def uninstalled(self):
+ self.title = "DexScript Uninstalled!"
+ self.description = "DexScript has been succesfully uninstalled from your bot."
+ self.color = discord.Color.from_str("#03BAFC")
+ self.timestamp = datetime.now()
+
+ self.set_thumbnail(url=config.appearance["logo"])
+
+
+class InstallerView(discord.ui.View):
+ def __init__(self, installer):
+ super().__init__()
+ self.installer = installer
+
+ @discord.ui.button(
+ style=discord.ButtonStyle.primary, label="Update" if UPDATING else "Install"
+ )
+ async def install_button(self, interaction: discord.Interaction, _: discord.ui.Button):
+ self.quit_button.disabled = True
+
+ await interaction.message.edit(**self.installer.interface.fields)
+
+ try:
+ await self.installer.install()
+ except Exception:
+ logger.log(format_exc(), "ERROR")
+
+ self.installer.interface.embed = InstallerEmbed(self.installer, "error")
+ else:
+ self.installer.interface.embed = InstallerEmbed(self.installer, "installed")
+
+ self.installer.interface.view = None
+
+ await interaction.message.edit(**self.installer.interface.fields)
+ await interaction.response.defer()
+
+ @discord.ui.button(style=discord.ButtonStyle.primary, label="Uninstall", disabled=not UPDATING)
+ async def uninstall_button(self, interaction: discord.Interaction, _: discord.ui.Button):
+ await self.installer.uninstall()
+
+ self.installer.interface.embed = InstallerEmbed(self.installer, "uninstalled")
+ self.installer.interface.view = None
+
+ await interaction.message.edit(**self.installer.interface.fields)
+ await interaction.response.defer()
+
+ @discord.ui.button(style=discord.ButtonStyle.red, label="Exit")
+ async def quit_button(self, interaction: discord.Interaction, _: discord.ui.Button):
+ self.install_button.disabled = True
+ self.uninstall_button.disabled = True
+ self.quit_button.disabled = True
+
+ await interaction.message.edit(**self.installer.interface.fields)
+ await interaction.response.defer()
+
+
+class InstallerGUI:
+ def __init__(self, installer):
+ self.loaded = False
+
+ self.installer = installer
+
+ self.embed = InstallerEmbed(installer)
+ self.view = InstallerView(installer)
+
+ self.attachments = []
+
+ @property
+ def fields(self):
+ fields = {"embed": self.embed, "view": self.view}
+
+ if self.attachments != []:
+ fields["attachments"] = self.attachments
+
+ return fields
+
+ async def reload(self):
+ if not self.loaded:
+ self.loaded = True
+
+ await ctx.send(**self.fields) # type: ignore
+ return
+
+ await ctx.message.edit(**self.fields) # type: ignore
+
+
+class Installer:
+ def __init__(self):
+ self.interface = InstallerGUI(self)
+
+ def add_package(self, package: str) -> bool:
+ with open("config.yml", "r") as file:
+ lines = file.readlines()
+
+ item = f" - {package}\n"
+
+ if "packages:\n" not in lines or item in lines:
+ return False
+
+ for i, line in enumerate(lines):
+ if line.rstrip().startswith("packages:"):
+ lines.insert(i + 1, item)
+ break
+
+ with open("config.yml", "w") as file:
+ file.writelines(lines)
+
+ return True
+
+ def uninstall_migrate(self):
+ with open("ballsdex/core/bot.py", "r") as read_file:
+ lines = read_file.readlines()
+
+ for index, line in enumerate(lines):
+ for migration in config.uninstall_migrations:
+ original = self.format_migration(migration)
+
+ if line != original:
+ continue
+
+ lines.pop(index)
+
+ with open("ballsdex/core/bot.py", "w") as write_file:
+ write_file.writelines(lines)
+
+ def install_migrate(self):
+ with open("ballsdex/core/bot.py", "r") as read_file:
+ lines = read_file.readlines()
+
+ for index, line in enumerate(lines):
+ for migration in config.install_migrations:
+ original = self.format_migration(migration[0])
+ new = self.format_migration(migration[1])
+
+ match migration[2]:
+ case MigrationType.REPLACE:
+ if line.rstrip() != original:
+ continue
+
+ lines[index] = new
+ case MigrationType.APPEND:
+ if line.rstrip() != original or new in lines:
+ continue
+
+ lines.insert(index + 1, new)
+
+ with open("ballsdex/core/bot.py", "w") as write_file:
+ write_file.writelines(lines)
+
+ async def install(self):
+ if os.path.isfile("ballsdex/core/dexscript.py"):
+ os.remove("ballsdex/core/dexscript.py")
+
+ link = f"https://api.github.com/repos/{config.github[0]}/contents/"
+
+ os.makedirs(config.path, exist_ok=True)
+
+ for file in config.files:
+ logger.log(f"Fetching {file} from '{link}/DexScript/package'", "INFO")
+
+ request = requests.get(f"{link}/DexScript/package/{file}", {"ref": config.github[1]})
+
+ if request.status_code != requests.codes.ok:
+ raise Exception(
+ f"Request to return {file} from '{link}/DexScript/package' "
+ f"resulted with error code {request.status_code}"
+ )
+
+ request = request.json()
+ content = b64decode(request["content"])
+
+ with open(f"{config.path}/{file}", "w") as opened_file:
+ opened_file.write(content.decode("UTF-8"))
+
+ logger.log(f"Installed {file} from '{link}/DexScript/package'", "INFO")
+
+ logger.log("Applying bot.py migrations", "INFO")
+
+ if self.add_package(config.path.replace("/", ".")) is False:
+ self.install_migrate()
+
+ logger.log("Loading DexScript extension", "INFO")
+
+ try:
+ await bot.reload_extension(config.path.replace("/", ".")) # type: ignore
+ except commands.ExtensionNotLoaded:
+ await bot.load_extension(config.path.replace("/", ".")) # type: ignore
+
+ logger.log("DexScript installation finished", "INFO")
+
+ async def uninstall(self):
+ if os.path.isfile("ballsdex/core/dexscript.py"):
+ os.remove("ballsdex/core/dexscript.py")
+
+ shutil.rmtree(config.path)
+
+ self.uninstall_migrate()
+
+ await bot.unload_extension(config.path.replace("/", ".")) # type: ignore
+
+ @staticmethod
+ def format_migration(line):
+ return line.replace(" ", "").replace("|", " ").replace("/n", "\n")
+
+ @property
+ def latest_version(self):
+ pyproject_request = requests.get(
+ "https://api.github.com/repos/Dotsian/DexScript/contents/pyproject.toml",
+ {"ref": config.github[1]},
+ )
+
+ if pyproject_request.status_code != requests.codes.ok:
+ return
+
+ toml_content = b64decode(pyproject_request.json()["content"]).decode("UTF-8")
+ new_version = re.search(r'version\s*=\s*"(.*?)"', toml_content)
+
+ if not new_version:
+ return
+
+ return new_version.group(1)
+
+ @property
+ def current_version(self):
+ if not os.path.isfile(f"{config.path}/cog.py"):
+ return
+
+ with open(f"{config.path}/cog.py", "r") as file:
+ old_version = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', file.read())
+
+ if not old_version:
+ return
+
+ return old_version.group(1)
+
+
+installer = Installer()
+await installer.interface.reload() # type: ignore
diff --git a/DexScript/github/migration.py b/DexScript/github/migration.py
new file mode 100644
index 0000000..10ad6a9
--- /dev/null
+++ b/DexScript/github/migration.py
@@ -0,0 +1,31 @@
+def repair_bot_file():
+ """
+ Repairs the `bot.py` file and removes extra newlines caused by an old DexScript installer.
+ """
+ new_lines = []
+
+ with open("ballsdex/core/bot.py", "r") as file:
+ if "import asyncio\n\n" not in file.read():
+ return
+
+ with open("ballsdex/core/bot.py", "r") as file:
+ last_was_newline = False
+
+ for line in file.readlines():
+ if last_was_newline is True:
+ last_was_newline = False
+ continue
+
+ if line.endswith("\n") and line != "\n" or line == "\n":
+ last_was_newline = True
+
+ new_lines.append(line)
+
+ with open("ballsdex/core/bot.py", "w") as file:
+ file.writelines(new_lines)
+
+
+# |-----------------------------------------------------------------------------------------|#
+
+
+repair_bot_file()
diff --git a/DexScript/package/__init__.py b/DexScript/package/__init__.py
new file mode 100644
index 0000000..e5f0369
--- /dev/null
+++ b/DexScript/package/__init__.py
@@ -0,0 +1,10 @@
+from typing import TYPE_CHECKING
+
+from .cog import DexScript
+
+if TYPE_CHECKING:
+ from ballsdex.core.bot import BallsDexBot
+
+
+async def setup(bot: "BallsDexBot"):
+ await bot.add_cog(DexScript(bot))
diff --git a/DexScript/package/cog.py b/DexScript/package/cog.py
new file mode 100644
index 0000000..044a265
--- /dev/null
+++ b/DexScript/package/cog.py
@@ -0,0 +1,168 @@
+import base64
+import re
+import traceback
+
+import discord
+import requests
+from ballsdex.settings import settings
+from discord.ext import commands
+
+from .parser import DexScriptParser
+from .utils import Utils, config
+
+__version__ = "0.5"
+
+
+class DexScript(commands.Cog):
+ """
+ DexScript commands
+ """
+
+ def __init__(self, bot):
+ self.bot = bot
+
+ @staticmethod
+ def check_version():
+ if not config.versioncheck:
+ return None
+
+ request = requests.get(
+ "https://api.github.com/repos/Dotsian/DexScript/contents/pyproject.toml",
+ {"ref": config.reference},
+ )
+
+ if request.status_code != requests.codes.ok:
+ return
+
+ toml_content = base64.b64decode(request.json()["content"]).decode()
+ new_version = re.search(r'version\s*=\s*"(.*?)"', toml_content).group(1)
+
+ if new_version != __version__:
+ return (
+ f"Your DexScript version ({__version__}) is outdated. "
+ f"Please update to version ({new_version}) "
+ f"by running `{settings.prefix}upgrade`"
+ )
+
+ return None
+
+ @commands.command()
+ @commands.is_owner()
+ async def run(self, ctx: commands.Context, *, code: str):
+ """
+ Executes DexScript code.
+
+ Parameters
+ ----------
+ code: str
+ The code you want to execute.
+ """
+ body = Utils.remove_code_markdown(code)
+
+ version_check = self.check_version()
+
+ if version_check:
+ await ctx.send(f"-# {version_check}")
+
+ dexscript_instance = DexScriptParser(ctx, self.bot)
+
+ try:
+ result = await dexscript_instance.execute(body)
+ except Exception as error:
+ full_error = traceback.format_exc() if config.debug else error
+
+ await ctx.send(f"```ERROR: {full_error}```")
+ return
+ else:
+ if result is not None:
+ await ctx.send(f"```ERROR: {result}```")
+ return
+
+ await ctx.message.add_reaction("✅")
+
+ @commands.command()
+ @commands.is_owner()
+ async def about(self, ctx: commands.Context):
+ """
+ Displays information about DexScript.
+ """
+ guide_link = "https://github.com/Dotsian/DexScript/wiki/Commands"
+ discord_link = "https://discord.gg/EhCxuNQfzt"
+
+ description = (
+ "DexScript is a set of commands for Ballsdex created by DotZZ "
+ "that expands on the standalone admin commands and substitutes for the admin panel. "
+ "It simplifies editing, adding, deleting, and displaying data for models such as "
+ "balls, regimes, specials, etc.\n\n"
+ f"Refer to the official [DexScript guide](<{guide_link}>) for information "
+ f"about DexScript's functionality\n"
+ f"To update or uninstall DexScript, run `{settings.prefix}installer`.\n\n"
+ "If you want to follow DexScript or require assistance, join the official "
+ f"[DexScript Discord server](<{discord_link}>)."
+ )
+
+ embed = discord.Embed(
+ title="DexScript - BETA",
+ description=description,
+ color=discord.Color.from_str("#03BAFC"),
+ )
+
+ version_check = "OUTDATED" if self.check_version() is not None else "LATEST"
+
+ embed.set_thumbnail(
+ url="https://raw.githubusercontent.com/Dotsian/DexScript/refs/heads/dev/assets/DexScriptLogo.png"
+ )
+ embed.set_footer(text=f"DexScript {__version__} ({version_check})")
+
+ await ctx.send(embed=embed)
+
+ @commands.command()
+ @commands.is_owner()
+ async def installer(self, ctx: commands.Context):
+ link = (
+ "https://api.github.com/repos/Dotsian/DexScript/contents/DexScript/github/installer.py"
+ )
+ request = requests.get(link, {"ref": config.reference})
+
+ match request.status_code:
+ case requests.codes.not_found:
+ await ctx.send(f"Could not find installer for the {config.reference} branch.")
+
+ case requests.codes.ok:
+ content = requests.get(link, {"ref": config.reference}).json()["content"]
+
+ await ctx.invoke(
+ self.bot.get_command("eval"), body=base64.b64decode(content).decode()
+ )
+
+ case _:
+ await ctx.send(f"Request raised error code `{request.status_code}`.")
+
+ @commands.command()
+ @commands.is_owner()
+ async def setting(self, ctx: commands.Context, setting: str, value: str | None = None):
+ """
+ Changes a setting based on the value provided.
+
+ Parameters
+ ----------
+ setting: str
+ The setting you want to toggle.
+ value: str | None
+ The value you want to set the setting to.
+ """
+ setting = setting.lower()
+
+ if setting not in vars(config):
+ await ctx.send(f"`{setting}` is not a valid setting.")
+ return
+
+ setting_value = vars(config)[setting]
+ new_value = value
+
+ if isinstance(setting_value, bool):
+ new_value = bool(value) if value else not setting_value
+
+ setattr(config, setting, new_value)
+
+ await ctx.send(f"`{setting}` has been set to `{new_value}`")
diff --git a/DexScript/package/commands.py b/DexScript/package/commands.py
new file mode 100644
index 0000000..830b07a
--- /dev/null
+++ b/DexScript/package/commands.py
@@ -0,0 +1,471 @@
+import asyncio
+import os
+import shutil
+from dataclasses import dataclass
+from dataclasses import field as datafield
+
+import discord
+
+from .utils import Types, Utils
+
+
+@dataclass
+class Shared:
+ """
+ Values that will be retained throughout the entire code execution.
+ """
+
+ attachments: list = datafield(default_factory=list)
+
+
+class DexCommand:
+ """
+ Default class for all dex commands.
+ """
+
+ def __init__(self, bot, shared):
+ self.bot = bot
+ self.shared = shared
+
+ def __loaded__(self):
+ pass
+
+ def attribute_error(self, model, attribute):
+ if model.value is None or hasattr(model.value(), attribute):
+ return
+
+ raise Exception(
+ f"'{attribute}' is not a valid {model.name} attribute\n"
+ f"Run `ATTRIBUTES > {model.name}` to see a list of "
+ "all attributes for that model"
+ )
+
+
+class Global(DexCommand):
+ """
+ Main methods for DexScript.
+ """
+
+ async def create(self, ctx, model, identifier):
+ """
+ Creates a model instance.
+
+ Documentation
+ -------------
+ CREATE > MODEL > IDENTIFIER
+ """
+ await Utils.create_model(model.value, identifier)
+ await ctx.send(f"Created `{identifier}` {model.name.lower()}")
+
+ async def delete(self, ctx, model, identifier):
+ """
+ Deletes a model instance.
+
+ Documentation
+ -------------
+ DELETE > MODEL > IDENTIFIER
+ """
+ model = await Utils.get_model(model, identifier)
+
+ await model.delete()
+
+ await ctx.send(f"Deleted `{identifier}` {model.name.lower()}")
+
+ async def update(self, ctx, model, identifier, attribute, value=None):
+ """
+ Updates a model instance's attribute. If value is None, it will check
+ for any attachments.
+
+ Documentation
+ -------------
+ UPDATE > MODEL > IDENTIFIER > ATTRIBUTE > VALUE(?)
+ """
+ attribute_name = attribute.name.lower()
+ new_value = None if value is None else value.value
+
+ returned_model = await Utils.get_model(model, identifier)
+ self.attribute_error(model, attribute_name)
+
+ image_fields = Utils.fetch_fields(
+ model.value,
+ lambda _, field_type: (
+ field_type.__class__.__name__ == "CharField" and field_type.max_length == 200
+ ),
+ )
+
+ if value is None and self.shared.attachments and attribute_name in image_fields:
+ image_path = await Utils.save_file(self.shared.attachments.pop(0))
+ new_value = f"/{image_path}"
+
+ if attribute.type == Types.MODEL:
+ attribute_name = f"{attribute.name.lower()}_id"
+ attribute_model = await Utils.get_model(attribute, value)
+ new_value = attribute_model.pk
+
+ setattr(returned_model, attribute_name, new_value)
+ await returned_model.save(update_fields=[attribute_name])
+
+ suffix = "" if value is None else f" to `{value.name}`"
+
+ await ctx.send(f"Updated `{identifier}'s` {attribute}{suffix}")
+
+ async def view(self, ctx, model, identifier, attribute=None):
+ """
+ Displays an attribute of a model instance. If `ATTRIBUTE` is left blank,
+ it will display every attribute of that model instance.
+
+ Documentation
+ -------------
+ VIEW > MODEL > IDENTIFIER > ATTRIBUTE(?)
+ """
+ returned_model = await Utils.get_model(model, identifier)
+
+ if attribute is None:
+ fields = {"content": "```"}
+
+ for key, value in vars(returned_model).items():
+ if key.startswith("_"):
+ continue
+
+ fields["content"] += f"{key}: {value}\n"
+
+ if isinstance(value, str) and Utils.is_image(value):
+ fields.setdefault("files", []).append(discord.File(Utils.image_path(value)))
+
+ fields["content"] += "```"
+ await ctx.send(**fields)
+ return
+
+ attribute_name = attribute.name.lower()
+ self.attribute_error(model, attribute_name)
+
+ new_attribute = getattr(returned_model, attribute_name)
+
+ if isinstance(new_attribute, str) and Utils.is_image(new_attribute):
+ await ctx.send(
+ f"```{new_attribute}```", file=discord.File(Utils.image_path(new_attribute))
+ )
+ return
+
+ if attribute.type == Types.MODEL:
+ new_attribute = await new_attribute.values_list(attribute.extra_data[0], flat=True)
+
+ await ctx.send(f"```{new_attribute}```")
+
+ async def attributes(self, ctx, model, filter=None):
+ """
+ Lists all changeable attributes of a model.
+
+ Documentation
+ -------------
+ ATTRIBUTES > MODEL > FILTER(?)
+ """
+ def filter_function(_, field_type):
+ if field_type == "BackwardFKRelation":
+ return False
+
+ if filter is None:
+ return True
+
+ match filter.value.lower():
+ case "null":
+ return field_type.null
+ case "valid":
+ return not field_type.null
+
+ return True
+
+ fields = [f"- {x.upper()}" for x in Utils.fetch_fields(model.value, filter_function)]
+ fields.insert(0, f"{model.name.upper()} ATTRIBUTES:\n")
+
+ await Utils.message_list(ctx, fields)
+
+
+class Filter(DexCommand):
+ """
+ Filter commands used for mass updating, deleting, and viewing models.
+ """
+
+ async def update(self, ctx, model, attribute, old_value, new_value, tortoise_operator=None):
+ """
+ Updates all instances of a model to the specified value where the specified attribute
+ meets the condition defined by the optional `TORTOISE_OPERATOR` argument
+ (e.g., greater than, equal to, etc.).
+
+ Documentation
+ -------------
+ FILTER > UPDATE > MODEL > ATTRIBUTE > OLD_VALUE > NEW_VALUE > TORTOISE_OPERATOR(?)
+ """
+ casing_name = attribute.name.lower()
+ self.attribute_error(model, casing_name)
+
+ if tortoise_operator is not None:
+ casing_name += f"__{tortoise_operator.name.lower()}"
+
+ value_old, value_new = old_value.value, new_value.value
+
+ if attribute.type == Types.MODEL:
+ value_old = await Utils.get_model(attribute, value_old)
+ value_new = await Utils.get_model(attribute, value_new)
+
+ await model.value.filter(**{casing_name: value_old}).update(**{casing_name: value_new})
+
+ await ctx.send(
+ f"Updated all `{model.name}` instances from a `{attribute}` "
+ f"value of `{old_value}` to `{new_value}`"
+ )
+
+ async def delete(self, ctx, model, attribute, value, tortoise_operator=None):
+ """
+ Deletes all instances of a model where the specified attribute meets the condition
+ defined by the optional `TORTOISE_OPERATOR` argument
+ (e.g., greater than, equal to, etc.).
+
+ Documentation
+ -------------
+ FILTER > DELETE > MODEL > ATTRIBUTE > VALUE > TORTOISE_OPERATOR(?)
+ """
+ casing_name = attribute.name.lower()
+ self.attribute_error(model, casing_name)
+
+ if tortoise_operator is not None:
+ casing_name += f"__{tortoise_operator.name.lower()}"
+
+ new_value = value.value
+
+ if attribute.type == Types.MODEL:
+ new_value = await Utils.get_model(attribute, new_value)
+
+ await model.value.filter(**{casing_name: new_value}).delete()
+
+ await ctx.send(
+ f"Deleted all `{model.name}` instances with a `{attribute}` value of `{value}`"
+ )
+
+ async def view(self, ctx, model, attribute, value, tortoise_operator=None):
+ """
+ Displays all instances of a model where the specified attribute meets the condition
+ defined by the optional `TORTOISE_OPERATOR` argument
+ (e.g., greater than, equal to, etc.).
+
+ Documentation
+ -------------
+ FILTER > VIEW > MODEL > ATTRIBUTE > VALUE > TORTOISE_OPERATOR(?)
+ """
+ casing_name = attribute.name.lower()
+ self.attribute_error(model, casing_name)
+
+ if tortoise_operator is not None:
+ casing_name += f"__{tortoise_operator.name.lower()}"
+
+ new_value = value.value
+
+ if attribute.type == Types.MODEL:
+ new_value = await Utils.get_model(attribute, new_value)
+
+ instances = await model.value.filter(**{casing_name: new_value}).values_list(
+ model.extra_data[0], flat=True
+ )
+
+ if instances == []:
+ await ctx.send(
+ f"No {model.name}s found with a `{attribute}` value of `{value}`"
+ )
+ return
+
+ await Utils.message_list(ctx, instances)
+
+
+class Eval(DexCommand):
+ """
+ Commands for managing eval presets.
+ """
+
+ def __loaded__(self):
+ os.makedirs("eval_presets", exist_ok=True)
+
+ async def save(self, ctx, name):
+ """
+ Saves an eval preset.
+
+ Documentation
+ -------------
+ EVAL > SAVE > NAME
+ """
+ NAME_LIMIT = 100
+
+ if len(name.name) > NAME_LIMIT:
+ raise Exception(
+ f"`{name}` exceeds the {NAME_LIMIT}-character limit ({len(name)} > {NAME_LIMIT})"
+ )
+
+ if os.path.isfile(f"eval_presets/{name}.py"):
+ raise Exception(f"`{name}` already exists.")
+
+ await ctx.send("Please send the eval command below...")
+
+ try:
+ message = await self.bot.wait_for(
+ "message",
+ check=lambda m: m.author == ctx.author and m.channel == ctx.channel,
+ timeout=20,
+ )
+ except asyncio.TimeoutError:
+ await ctx.send("Eval preset saving has timed out.")
+ return
+
+ with open(f"eval_presets/{name}.py", "w") as file:
+ file.write(Utils.remove_code_markdown(message.content))
+
+ await ctx.send(f"`{name}` eval preset has been saved!")
+
+ async def remove(self, ctx, name):
+ """
+ Removes an eval preset.
+
+ Documentation
+ -------------
+ EVAL > REMOVE > NAME
+ """
+ if not os.path.isfile(f"eval_presets/{name}.py"):
+ raise Exception(f"`{name}` does not exists")
+
+ os.remove(f"eval_presets/{name}.py")
+
+ await ctx.send(f"Removed `{name}` preset.")
+
+ async def list(self, ctx):
+ if os.listdir("eval_presets") == []:
+ await ctx.send("You have no eval presets saved.")
+ return
+
+ await Utils.message_list(ctx, os.listdir("eval_presets"))
+
+ async def run(self, ctx, name): # TODO: Allow args to be passed through `run`.
+ """
+ Runs an eval preset.
+
+ Documentation
+ -------------
+ EVAL > RUN > NAME
+ """
+ if not os.path.isfile(f"eval_presets/{name}.py"):
+ raise Exception(f"`{name}` does not exists")
+
+ with open(f"eval_presets/{name}.py", "r") as file:
+ try:
+ await ctx.invoke(self.bot.get_command("eval"), body=file.read())
+ except Exception as error:
+ raise Exception(error)
+ else:
+ await ctx.message.add_reaction("✅")
+
+
+class File(DexCommand):
+ """
+ Commands for managing and modifying the bot's internal filesystem.
+ """
+
+ async def read(self, ctx, file_path):
+ """
+ Sends a file based on the specified file path.
+
+ Documentation
+ -------------
+ FILE > READ > FILE_PATH
+ """
+ await ctx.send(file=discord.File(file_path.name))
+
+ async def write(self, ctx, file_path):
+ """
+ Writes to a file using the attached file's contents.
+
+ Documentation
+ -------------
+ FILE > WRITE > FILE_PATH
+ """
+ new_file = ctx.message.attachments[0]
+
+ with open(file_path.name, "w") as opened_file:
+ contents = await new_file.read()
+ opened_file.write(contents.decode("utf-8"))
+
+ await ctx.send(f"Wrote to `{file_path}`")
+
+ async def clear(self, ctx, file_path):
+ """
+ Clears the contents of a file.
+
+ Documentation
+ -------------
+ FILE > CLEAR > FILE_PATH
+ """
+ if not os.path.isfile(file_path):
+ raise Exception(f"'{file_path}' does not exist")
+
+ with open(file_path.name, "w") as _:
+ pass
+
+ await ctx.send(f"Cleared `{file_path}`")
+
+ async def listdir(self, ctx, file_path=None):
+ """
+ Lists all files inside of a directory.
+
+ Documentation
+ -------------
+ FILE > LISTDIR > FILE_PATH(?)
+ """
+ path = file_path.name if file_path is not None else None
+
+ await Utils.message_list(ctx, os.listdir(path))
+
+ async def delete(self, ctx, file_path):
+ """
+ Deletes a file or directory based on the specified file path.
+
+ Documentation
+ -------------
+ FILE > DELETE > FILE_PATH
+ """
+ is_dir = os.path.isdir(file_path.name)
+
+ file_type = "directory" if is_dir else "file"
+
+ if is_dir:
+ shutil.rmtree(file_path.name)
+ else:
+ os.remove(file_path.name)
+
+ await ctx.send(f"Deleted `{file_path}` {file_type}")
+
+
+class Template(DexCommand):
+ """
+ Template commands used to assist with DexScript commands.
+ """
+
+ # TODO: Softcode model creation template.
+ async def create(self, ctx, model, argument="..."):
+ """
+ Sends the `create` template for a model.
+
+ Documentation
+ -------------
+ TEMPLATE > CREATE > MODEL > ARGUMENT(?)
+ """
+ match model.name.lower():
+ case "ball":
+ template_commands = [
+ f"CREATE > BALL > {argument}",
+ f"UPDATE > BALL > {argument} > REGIME > ...",
+ f"UPDATE > BALL > {argument} > HEALTH > ...",
+ f"UPDATE > BALL > {argument} > ATTACK > ...",
+ f"UPDATE > BALL > {argument} > RARITY > ...",
+ f"UPDATE > BALL > {argument} > EMOJI_ID > ...",
+ f"UPDATE > BALL > {argument} > CREDITS > ...",
+ f"UPDATE > BALL > {argument} > CAPACITY_NAME > ...",
+ f"UPDATE > BALL > {argument} > CAPACITY_DESCRIPTION > ...",
+ ]
+
+ await ctx.send(f"```sql\n{'\n'.join(template_commands)}\n```")
diff --git a/DexScript/package/parser.py b/DexScript/package/parser.py
new file mode 100644
index 0000000..b5798dc
--- /dev/null
+++ b/DexScript/package/parser.py
@@ -0,0 +1,138 @@
+import inspect
+import re
+import traceback
+from dataclasses import dataclass
+from dataclasses import field as datafield
+from typing import Any
+
+from dateutil.parser import parse as parse_date
+
+from . import commands
+from .utils import Types, Utils, config
+
+
+@dataclass
+class Value:
+ name: str
+ type: Types = Types.DEFAULT
+ value: Any = None
+
+ extra_data: list = datafield(default_factory=list)
+
+ def __str__(self):
+ return self.name
+
+
+class DexScriptParser:
+ """
+ This class is used to parse DexScript into Python code.
+ """
+
+ def __init__(self, ctx, bot):
+ self.ctx = ctx
+ self.bot = bot
+ # self.attachments = ctx.message.attachments
+
+ self.command_classes = inspect.getmembers(
+ commands,
+ lambda o: (
+ inspect.isclass(o)
+ and issubclass(o, commands.DexCommand)
+ and not issubclass(o, commands.Global)
+ and o.__name__ != "DexCommand"
+ ),
+ )
+
+ self.global_methods = [x for x in dir(commands.Global) if not x.startswith("__")]
+
+ def create_value(self, line):
+ value = Value(line)
+ value.value = line
+
+ lower = line.lower()
+
+ type_dict = {
+ Types.METHOD: lower in self.global_methods,
+ Types.CLASS: lower in [x[0].lower() for x in self.command_classes],
+ Types.MODEL: lower in Utils.models(True, key=str.lower),
+ Types.DATETIME: Utils.is_date(lower) and lower.count("-") >= 2,
+ Types.BOOLEAN: lower in ["true", "false"],
+ }
+
+ for key, operation in type_dict.items():
+ if operation is False:
+ continue
+
+ value.type = key
+ break
+
+ match value.type:
+ case Types.MODEL:
+ model = Utils.fetch_model(line)
+
+ if model is None:
+ raise Exception(f"'{line}' is not a valid model")
+
+ string_key = Utils.extract_str_attr(model)
+
+ value.name = model.__name__
+ value.value = model
+
+ value.extra_data.append(string_key)
+
+ case Types.BOOLEAN:
+ value.value = lower == "true"
+
+ case Types.DATETIME:
+ value.value = parse_date(line)
+
+ return value
+
+ def error(self, message, log):
+ return (message, log)[config.debug]
+
+ async def execute(self, code: str, run_commands=True):
+ shared_instance = commands.Shared(self.ctx.message.attachments)
+
+ split_code = [x for x in code.split("\n") if x.strip() != ""]
+
+ parsed_code = [
+ [self.create_value(s.strip()) for s in re.findall(r"[^>]+", line)]
+ for line in split_code
+ if not line.strip().startswith("--")
+ ]
+
+ if not run_commands:
+ return parsed_code
+
+ for line2 in parsed_code:
+ if line2 == []:
+ continue
+
+ method = line2[0]
+
+ if method.type not in (Types.METHOD, Types.CLASS):
+ return self.error(
+ f"'{method.name}' is not a valid command.", traceback.format_exc()
+ )
+
+ if method.type == Types.CLASS:
+ line2.pop(0)
+ method = (getattr(commands, method.name.title()), line2[0])
+ else:
+ method = (commands.Global, line2[0])
+
+ line2.pop(0)
+
+ class_loaded = commands.Global if method[0] == commands.Global else method[0]
+ class_loaded = class_loaded(self.bot, shared_instance)
+ class_loaded.__loaded__()
+
+ method_call = getattr(class_loaded, method[1].name.lower())
+
+ try:
+ await method_call(self.ctx, *line2)
+ except TypeError:
+ return self.error(
+ f"Argument missing when calling '{method[1].name}'.", traceback.format_exc()
+ )
diff --git a/DexScript/package/utils.py b/DexScript/package/utils.py
new file mode 100644
index 0000000..b352ef8
--- /dev/null
+++ b/DexScript/package/utils.py
@@ -0,0 +1,415 @@
+import asyncio
+import contextlib
+import inspect
+import os
+import re
+from dataclasses import dataclass
+from difflib import get_close_matches
+from enum import Enum
+from io import StringIO
+from pathlib import Path
+from typing import Any, Callable
+
+import discord
+from ballsdex.core.models import Ball, Economy, Regime, Special # noqa: F401, I001
+from dateutil.parser import parse as parse_date
+
+START_CODE_BLOCK_RE = re.compile(r"^((```sql?)(?=\s)|(```))")
+FILENAME_RE = re.compile(r"^(.+)(\.\S+)$")
+
+STATIC = os.path.isdir("static")
+MEDIA_PATH = "./static/uploads" if STATIC else "./admin_panel/media"
+
+MODELS = [
+ "Ball",
+ "Regime",
+ "Economy",
+ "Special",
+]
+
+
+class Types(Enum):
+ DEFAULT = 0
+ METHOD = 1
+ CLASS = 2
+ BOOLEAN = 3
+ MODEL = 4
+ DATETIME = 5
+
+
+@dataclass
+class Settings:
+ """
+ Settings class for DexScript.
+ """
+
+ debug: bool = False
+ versioncheck: bool = False
+ reference: str = "main"
+
+
+config = Settings()
+
+
+@dataclass
+class Utils:
+ """
+ Utility functions for DexScript.
+ """
+
+ @staticmethod
+ def image_path(path: str) -> bool:
+ """
+ Formats an image path correctly.
+
+ Parameters
+ ----------
+ path: str
+ The path you want to format.
+ """
+ full_path = path.replace("/static/uploads/", "")
+
+ if STATIC and full_path[0] == ".":
+ full_path = full_path[1:]
+
+ return f"{MEDIA_PATH}/{full_path}"
+
+ @staticmethod
+ def is_image(path: str) -> bool:
+ """
+ Determines if a file is an image if it is found within the correct image directory.
+
+ Parameters
+ ----------
+ path: str
+ The path of the file.
+ """
+ return os.path.isfile(Utils.image_path(path))
+
+ @staticmethod
+ def is_date(string: str) -> bool:
+ """
+ Determines if a string can be parsed into a date.
+
+ Parameters
+ ----------
+ string: str
+ The string you want to check.
+ """
+ try:
+ parse_date(string)
+ return True
+ except Exception:
+ return False
+
+ @staticmethod
+ def pascal_case(string: str) -> str:
+ """
+ Converts a string from whatever case it's in to PascalCase.
+
+ Parameters
+ ----------
+ string: str
+ The string you want to convert.
+ """
+ string = string.lower()
+ return re.sub(
+ r"(_[a-z])", lambda m: m.group(1)[1].upper(), string[:1].upper() + string[1:]
+ )
+
+ @staticmethod
+ async def message_list(ctx, messages: list[str]):
+ """
+ Creates an interactive message limit that allows you to display a list of messages
+ without suprassing the Discord message character limit.
+
+ Parameters
+ ----------
+ ctx: discord.Context
+ The context object that will be used.
+ messages: list[str]
+ The list of messages you want to add to the interaction.
+ """
+ pages = [[]]
+ page_length = 0
+
+ def check(message):
+ valid_choice = message.content.lower() in ("more", "file")
+
+ return (
+ message.author == ctx.message.author and
+ message.channel == ctx.channel and valid_choice
+ )
+
+ for message in messages:
+ if page_length >= 750:
+ page_length = 0
+ pages.append([])
+
+ page_length += len(message)
+ pages[-1].append(message)
+
+ for index, page in enumerate(pages, start=1):
+ await ctx.send(f"```\n{'\n'.join(page)}\n```")
+
+ if index == len(pages):
+ break
+
+ remaining = len(pages) - index
+
+ text = f"There are `{remaining}` pages remaining."
+
+ if remaining == 1:
+ text = "There is `1` page remaining."
+
+ message = await ctx.send(
+ f"{text} Type `more` to continue or `file` to send all messages in a file"
+ )
+
+ try:
+ response = await ctx.bot.wait_for("message", check=check, timeout=15)
+ except asyncio.TimeoutError:
+ with contextlib.suppress(discord.HTTPException):
+ await message.delete()
+
+ break
+
+ with contextlib.suppress(discord.HTTPException):
+ await ctx.channel.delete_messages((message, response))
+
+ if response.content.lower() == "more":
+ continue
+
+ await ctx.send(file=discord.File(StringIO("\n".join(messages)), filename="output.txt"))
+
+ break
+
+ @staticmethod
+ async def save_file(attachment: discord.Attachment) -> Path:
+ """
+ Saves a `discord.Attachment` object into a directory.
+
+ Parameters
+ ----------
+ attachment: discord.Attachment
+ The attachment you want to save.
+ """
+ path = Path(f"{MEDIA_PATH}/{attachment.filename}")
+ match = FILENAME_RE.match(attachment.filename)
+
+ if not match:
+ raise TypeError("The file you uploaded lacks an extension.")
+
+ i = 1
+
+ while path.exists():
+ path = Path(f"{MEDIA_PATH}/{match.group(1)}-{i}{match.group(2)}")
+ i = i + 1
+
+ await attachment.save(path)
+
+ return path.relative_to(MEDIA_PATH)
+
+ @staticmethod
+ def fetch_model(model: str):
+ """
+ Fetches a model's class based on the model name provided.
+
+ Parameters
+ ----------
+ model: str
+ The name of the model you want to fetch.
+ """
+ return globals().get(Utils.pascal_case(model))
+
+ @staticmethod
+ def models(names=False, key: Callable | None = None):
+ """
+ Returns a list of models.
+
+ Parameters
+ ----------
+ names: bool
+ Whether or not a list of the model's names should be returned instead.
+ key: Callable | None
+ The model instance of name will be passed through this callable per model.
+ """
+ model_list = MODELS
+
+ if not names:
+ model_list = [
+ Utils.fetch_model(x) for x in model_list if Utils.fetch_model(x) is not None
+ ]
+
+ if key is not None:
+ model_list = [key(x) for x in model_list]
+
+ return model_list
+
+ @staticmethod
+ async def create_model(model, identifier, fields_only=False):
+ """
+ Creates a model instance while providing default values for all.
+
+ Parameters
+ ----------
+ model: Model
+ The tortoise model you want to use.
+ identifier: str
+ The name of the model instance.
+ fields_only: bool
+ Whether you want to return the fields created only or not (debugging).
+ """
+ fields = {}
+
+ special_list = {
+ "Identifiers": ["country", "catch_names", "name"],
+ "Ignore": ["id", "short_name"],
+ }
+
+ model_ids = Utils.models(True, lambda s: f"{str.lower(s)}_id")
+
+ for field, field_type in model._meta.fields_map.items():
+ if field_type.null or field in special_list["Ignore"] or field in model_ids:
+ continue
+
+ if field in special_list["Identifiers"]:
+ fields[field] = str(identifier)
+ continue
+
+ match field_type.__class__.__name__:
+ case "ForeignKeyFieldInstance":
+ casing_field = Utils.pascal_case(field)
+
+ instance = await Utils.fetch_model(casing_field).first()
+
+ if instance is None:
+ raise Exception(f"Could not find default {casing_field}")
+
+ fields[f"{field}_id"] = instance.pk
+
+ case "BigIntField":
+ fields[field] = 100**8
+
+ case "BackwardFKRelation" | "JSONField":
+ continue
+
+ case _:
+ fields[field] = 1
+
+ if fields_only:
+ return fields
+
+ await model.create(**fields)
+
+ @staticmethod
+ async def get_model(model, identifier: str):
+ """
+ Returns a model instance, providing autocorrection.
+
+ Parameters
+ ----------
+ model: Value
+ The model you want to use.
+ identifier: str
+ The identifier of the model instance you are trying to return.
+ """
+ correction_list = await model.value.all().values_list(model.extra_data[0], flat=True)
+
+ try:
+ returned_model = await model.value.filter(
+ **{model.extra_data[0]: Utils.autocorrect(str(identifier), correction_list)}
+ )
+ except AttributeError:
+ raise Exception(f"'{model}' is not a valid model.")
+
+ return returned_model[0]
+
+ @staticmethod
+ def fetch_fields(model, field_filter: Callable | None = None) -> list[str]:
+ """
+ Returns a list of a model's fields.
+
+ Parameters
+ ----------
+ model: Model
+ The model you want to fetch fields from.
+ field_filter: Callable | None
+ If this callable returns False, that specific field won't be included.
+ """
+ fetched_list = []
+
+ for field, field_type in model._meta.fields_map.items():
+ if field_filter is not None and not field_filter(field, field_type):
+ continue
+
+ fetched_list.append(field)
+
+ return fetched_list
+
+ @staticmethod
+ def get_field(model, field: str):
+ """
+ Returns a field from a model.
+
+ Parameters
+ ----------
+ model: Model
+ The tortoise model you want to use.
+ field: str
+ The field you want to fetch.
+ """
+ return model._meta.fields_map.get(field)
+
+ @staticmethod
+ def autocorrect(string: str, correction_list: list[str], error="does not exist."):
+ """
+ Autocorrects a string based on the specified `correction_list`
+ and raises an error if there are no strings similiar to the string provided.
+
+ Parameters
+ ----------
+ string: str
+ The base string that will be used for autocorrection.
+ correction_list: list[str]
+ A list of strings that will be referenced when autocorrecting.
+ error: str
+ The error message that will be raised when there are no similarities.
+ """
+ autocorrection = get_close_matches(string, correction_list)
+
+ if not autocorrection or autocorrection[0] != string:
+ suggestion = f"\nDid you mean '{autocorrection[0]}'?" if autocorrection else ""
+
+ raise Exception(f"'{string}' {error}{suggestion}")
+
+ return autocorrection[0]
+
+ @staticmethod
+ def extract_str_attr(object: Any):
+ """
+ Extracts the attribute used in the `__str__` method of a class.
+
+ Parameters
+ ----------
+ object: Any
+ The class you want to fetch the `__str__` attribute from.
+ """
+ expression = r"return\s+self\.(\w+)" # TODO: Add `return str()`
+
+ return re.search(expression, inspect.getsource(object.__str__)).group(1)
+
+ @staticmethod
+ def remove_code_markdown(content: str) -> str:
+ """
+ Removes code markdown from a message.
+
+ Parameters
+ ----------
+ content: str
+ The content you want to remove the code markdown from.
+ """
+ if content.startswith("```") and content.endswith("```"):
+ return START_CODE_BLOCK_RE.sub("", content)[:-3]
+
+ return content.strip("` \n")
diff --git a/README.md b/README.md
index bc9c7f0..4fc19a1 100644
--- a/README.md
+++ b/README.md
@@ -1,35 +1,80 @@
-
-
-
-