comprobot 2.2.6__tar.gz → 2.3.1__tar.gz

{comprobot-2.2.6 → comprobot-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comprobot
-Version: 2.2.6
+Version: 2.3.1
 Summary: A self-hostable Discord bot built for maximum customization.
 Author: badluma
 License: MIT

{comprobot-2.2.6 → comprobot-2.3.1}/comprobot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comprobot
-Version: 2.2.6
+Version: 2.3.1
 Summary: A self-hostable Discord bot built for maximum customization.
 Author: badluma
 License: MIT

{comprobot-2.2.6 → comprobot-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "comprobot"
-version = "2.2.6"
+version = "2.3.1"
 authors = [{name = "badluma"}]
 description = "A self-hostable Discord bot built for maximum customization."
 readme = "README.md"

{comprobot-2.2.6 → comprobot-2.3.1}/src/api.py

@@ -39,7 +39,7 @@ def quote():
         fetched_quote = data[0]["q"]
         author = data[0]["a"]
         response = (
-            choice(output["commands"]["quote"])
+            choice(output["general"]["quote"])
             .replace(r"{{QUOTE}}", fetched_quote)
             .replace(r"{{AUTHOR}}", author)
         )
@@ -54,7 +54,7 @@ def meme():
     )
     if not success:
         return url
-    return choice(output["commands"]["meme"]).replace(r"{{URL}}", url)
+    return choice(output["general"]["meme"]).replace(r"{{URL}}", url)
 
 
 def waifu():
@@ -69,7 +69,7 @@ def waifu():
     if not success2:
         return waifu2
     return (
-        choice(output["commands"]["waifu"])
+        choice(output["general"]["waifu"])
         .replace(r"{{URL1}}", waifu1)
         .replace(r"{{URL2}}", waifu2)
     )
@@ -81,7 +81,7 @@ def duck():  # TODO: Fix function (command doesnt respond)
     )
     if not success:
         return url
-    return choice(output["commands"]["duck"]).replace(r"{{URL}}", url)
+    return choice(output["general"]["duck"]).replace(r"{{URL}}", url)
 
 
 def dog():
@@ -90,7 +90,7 @@ def dog():
     )
     if not success:
         return url
-    return choice(output["commands"]["dog"]).replace(r"{{URL}}", url)
+    return choice(output["general"]["dog"]).replace(r"{{URL}}", url)
 
 
 def cat():
@@ -99,7 +99,7 @@ def cat():
         return f"{error_messages['cat']} (HTTP {raw.status_code})"
     try:
         data = raw.json()
-        response = choice(output["commands"]["cat"]).replace(r"{{URL}}", data[0]["url"])
+        response = choice(output["general"]["cat"]).replace(r"{{URL}}", data[0]["url"])
     except (requests.exceptions.JSONDecodeError, KeyError, IndexError):
         response = error_messages["cat"]
     return response
@@ -111,7 +111,7 @@ def chuck():
     )
     if not success:
         return joke
-    return choice(output["commands"]["chuck_norris"]).replace(r"{{JOKE}}", joke)
+    return choice(output["general"]["chuck_norris"]).replace(r"{{JOKE}}", joke)
 
 
 def fact():
@@ -122,7 +122,7 @@ def fact():
     )
     if not success:
         return fact_text
-    return choice(output["commands"]["fact"]).replace(r"{{FACT}}", fact_text)
+    return choice(output["general"]["fact"]).replace(r"{{FACT}}", fact_text)
 
 
 def bible(
@@ -140,7 +140,7 @@ def bible(
             if "random_verse" in data:
                 verse = data["random_verse"]
                 response = (
-                    choice(output["commands"]["bible"])
+                    choice(output["general"]["bible"])
                     .replace(r"{{PASSAGE}}", verse["text"].strip())
                     .replace(r"{{BOOK}}", verse["book"].strip())
                     .replace(r"{{CHAPTER}}", str(verse["chapter"].strip()))
@@ -158,7 +158,7 @@ def bible(
                 )
                 verse_num = chapter_verse.split(":")[1] if ":" in chapter_verse else "1"
                 response = (
-                    choice(output["commands"]["bible"])
+                    choice(output["general"]["bible"])
                     .replace(r"{{PASSAGE}}", data["text"].strip())
                     .replace(r"{{BOOK}}", book.strip())
                     .replace(r"{{CHAPTER}}", chapter.strip())
@@ -188,7 +188,7 @@ def bitcoin(currency_parameter):
         data = bitcoin_price.json()
         if "bitcoin" in data and currency in data["bitcoin"]:
             response = (
-                choice(output["commands"]["bitcoin"])
+                choice(output["general"]["bitcoin"])
                 .replace(r"{{AMOUNT}}", str(data["bitcoin"][currency]))
                 .replace(r"{{CURRENCY}}", currency.upper())
             )
@@ -217,7 +217,7 @@ def joke():
     try:
         data = raw.json()
         response = (
-            choice(output["commands"]["joke"])
+            choice(output["general"]["joke"])
             .replace(r"{{SETUP}}", data["setup"])
             .replace(r"{{PUNCHLINE}}", data["punchline"])
         )
@@ -264,7 +264,7 @@ def currency(currency1, currency2, amount):
     rate = raw_response[currency1][currency2]
     converted_amount = rate * amount
     response = (
-        choice(output["commands"]["currency"])
+        choice(output["general"]["currency"])
         .replace(r"{{FROM_AMOUNT}}", str(amount))
         .replace(r"{{FROM_CURRENCY}}", currency1.upper())
         .replace(r"{{TO_AMOUNT}}", f"{converted_amount:.2f}")

{comprobot-2.2.6 → comprobot-2.3.1}/src/bot.py

@@ -21,5 +21,6 @@ from .data import config  # noqa: E402
 bot = commands.Bot(
     command_prefix=lambda b, m: config["prefix"],
     intents=intents,
+    help_command=None,
 )
 client = bot

comprobot-2.3.1/src/commands.py

@@ -0,0 +1,54 @@
+from random import choice
+
+from .data import active, config, error_messages, keywords, output, descriptions
+
+
+def qr(link):
+    url = f"https://api.qrserver.com/v1/create-qr-code/?size=150x150&data={link}"
+    return choice(output["general"]["qr_code"]).replace(r"{{URL}}", url)
+
+
+def calculate(calculation):
+    try:
+        result = eval(calculation)
+        response = choice(output["general"]["calculate"]).replace(
+            r"{{RESULT}}", str(result)
+        )
+    except ZeroDivisionError:
+        response = error_messages["calculate"]
+    except Exception:
+        response = error_messages["calculate"]
+    return response
+
+
+def help(category=None):
+    if not category:
+        message = "# Commands"
+        for category in list(keywords.keys()):
+            message += f"\n## {category.title()}\n"
+            for command in list(keywords[category].keys()):
+                if active.get(command, True):
+                    message += f"\n**{config['prefix']}{keywords[category][command][0]}** - {descriptions[category][command]}"
+                    if len(keywords[category][command]) > 1:
+                        message += f"\n-# Aliases: {config['prefix']}{', '.join(keywords[category][command][1:])}"
+                    message += "\n-# \u200b"
+        return message
+    else:
+        if not category.lower() in list(keywords.keys()):
+            return error_messages["unknown_category"]
+        message = f"## {category.title()}\n"
+        for command in list(keywords[category.lower()].keys()):
+            if active.get(command, True):
+                message += f"\n**{config['prefix']}{keywords[category.lower()][command][0]}** - {descriptions[category.lower()][command]}"
+                if len(keywords[category.lower()][command]) > 1:
+                    message += f"\n-# Aliases: {config['prefix']}{', '.join(keywords[category][command][1:])}"
+                message += "\n-# "
+        return message
+
+
+def ascii():
+    if not config["ascii_art"]:
+        return error_messages["no_ascii_art"]
+    return choice(output["general"]["ascii_art"]).replace(
+        r"{{ASCII_ART}}", choice(config["ascii_art"])
+    )

{comprobot-2.2.6 → comprobot-2.3.1}/src/data.py

@@ -29,6 +29,12 @@ def merge_defaults(data, defaults):
             merge_defaults(data[key], value)
 
 
+def migrate_section(data, old_key, new_key):
+    if old_key in data and new_key not in data:
+        data[new_key] = data[old_key]
+        del data[old_key]
+
+
 def load_or_create(path, template_content):
     try:
         with open(path, "r", encoding="utf-8") as f:
@@ -38,6 +44,8 @@ def load_or_create(path, template_content):
         with open(path, "r", encoding="utf-8") as f:
             data = tomlkit.loads(f.read())
 
+    migrate_section(data, "commands", "general")
+
     defaults = tomlkit.loads(template_content)
     merge_defaults(data, defaults)
 
@@ -67,6 +75,9 @@ output: Dict[str, Dict[str, List[str]]] = load_or_create(
 moderation: Dict[Any, Any] = load_or_create(
     get_data_path("moderation.toml"), templates.moderation
 )
+descriptions: Dict[str, Dict[str, str]] = load_or_create(
+    get_data_path("descriptions.toml"), templates.descriptions
+)
 
 ensure_file(get_data_path(".env"), templates.env)
 

{comprobot-2.2.6 → comprobot-2.3.1}/src/process.py

@@ -31,40 +31,40 @@ class Comprobot(ext_commands.Cog):
     # ── Commands ─────────────────────────────────────────────────────────────
 
     @ext_commands.command(
-        name=keywords["commands"]["quote"][0],
-        aliases=keywords["commands"]["quote"][1:],
+        name=keywords["general"]["quote"][0],
+        aliases=keywords["general"]["quote"][1:],
     )
     @ext_commands.check(lambda ctx: active["quote"])
     async def quote_cmd(self, ctx):
         await ctx.send(api.quote())
 
     @ext_commands.command(
-        name=keywords["commands"]["joke"][0],
-        aliases=keywords["commands"]["joke"][1:],
+        name=keywords["general"]["joke"][0],
+        aliases=keywords["general"]["joke"][1:],
     )
     @ext_commands.check(lambda ctx: active["joke"])
     async def joke_cmd(self, ctx):
         await ctx.send(api.joke())
 
     @ext_commands.command(
-        name=keywords["commands"]["meme"][0],
-        aliases=keywords["commands"]["meme"][1:],
+        name=keywords["general"]["meme"][0],
+        aliases=keywords["general"]["meme"][1:],
     )
     @ext_commands.check(lambda ctx: active["meme"])
     async def meme_cmd(self, ctx):
         await ctx.send(api.meme())
 
     @ext_commands.command(
-        name=keywords["commands"]["waifu"][0],
-        aliases=keywords["commands"]["waifu"][1:],
+        name=keywords["general"]["waifu"][0],
+        aliases=keywords["general"]["waifu"][1:],
     )
     @ext_commands.check(lambda ctx: active["waifu"])
     async def waifu_cmd(self, ctx):
         await ctx.send(api.waifu())
 
     @ext_commands.group(
-        name=keywords["commands"]["image"][0],
-        aliases=keywords["commands"]["image"][1:],
+        name=keywords["general"]["image"][0],
+        aliases=keywords["general"]["image"][1:],
         invoke_without_command=True,
     )
     @ext_commands.check(lambda ctx: active["image"])
@@ -72,48 +72,48 @@ class Comprobot(ext_commands.Cog):
         await ctx.send(error_messages["missing_argument"])
 
     @image_cmd.command(
-        name=keywords["commands"]["duck"][0],
-        aliases=keywords["commands"]["duck"][1:],
+        name=keywords["general"]["duck"][0],
+        aliases=keywords["general"]["duck"][1:],
     )
     @ext_commands.check(lambda ctx: active["duck"])
     async def duck_cmd(self, ctx):
         await ctx.send(api.duck())
 
     @image_cmd.command(
-        name=keywords["commands"]["dog"][0],
-        aliases=keywords["commands"]["dog"][1:],
+        name=keywords["general"]["dog"][0],
+        aliases=keywords["general"]["dog"][1:],
     )
     @ext_commands.check(lambda ctx: active["dog"])
     async def dog_cmd(self, ctx):
         await ctx.send(api.dog())
 
     @image_cmd.command(
-        name=keywords["commands"]["cat"][0],
-        aliases=keywords["commands"]["cat"][1:],
+        name=keywords["general"]["cat"][0],
+        aliases=keywords["general"]["cat"][1:],
     )
     @ext_commands.check(lambda ctx: active["cat"])
     async def cat_cmd(self, ctx):
         await ctx.send(api.cat())
 
     @ext_commands.command(
-        name=keywords["commands"]["chuck_norris"][0],
-        aliases=keywords["commands"]["chuck_norris"][1:],
+        name=keywords["general"]["chuck_norris"][0],
+        aliases=keywords["general"]["chuck_norris"][1:],
     )
     @ext_commands.check(lambda ctx: active["chuck_norris"])
     async def chuck_cmd(self, ctx):
         await ctx.send(api.chuck())
 
     @ext_commands.command(
-        name=keywords["commands"]["fact"][0],
-        aliases=keywords["commands"]["fact"][1:],
+        name=keywords["general"]["fact"][0],
+        aliases=keywords["general"]["fact"][1:],
     )
     @ext_commands.check(lambda ctx: active["fact"])
     async def fact_cmd(self, ctx):
         await ctx.send(api.fact())
 
     @ext_commands.command(
-        name=keywords["commands"]["bible"][0],
-        aliases=keywords["commands"]["bible"][1:],
+        name=keywords["general"]["bible"][0],
+        aliases=keywords["general"]["bible"][1:],
     )
     @ext_commands.check(lambda ctx: active["bible"])
     async def bible_cmd(self, ctx, book: str | None = None, chapter: int | None = None, verse: int | None = None):
@@ -125,68 +125,68 @@ class Comprobot(ext_commands.Cog):
             await ctx.send(error_messages["missing_argument"])
 
     @ext_commands.command(
-        name=keywords["commands"]["truth"][0],
-        aliases=keywords["commands"]["truth"][1:],
+        name=keywords["general"]["truth"][0],
+        aliases=keywords["general"]["truth"][1:],
     )
     @ext_commands.check(lambda ctx: active["truth"])
     async def truth_cmd(self, ctx, rating: str | None = None):
         result = api.tord("https://api.truthordarebot.xyz/v1/truth", rating)
         if result:
-            await ctx.send(choice(output["commands"]["truth"]).replace("{{QUESTION}}", result))
+            await ctx.send(choice(output["general"]["truth"]).replace("{{QUESTION}}", result))
         else:
             await ctx.send(error_messages["truth"])
 
     @ext_commands.command(
-        name=keywords["commands"]["dare"][0],
-        aliases=keywords["commands"]["dare"][1:],
+        name=keywords["general"]["dare"][0],
+        aliases=keywords["general"]["dare"][1:],
     )
     @ext_commands.check(lambda ctx: active["dare"])
     async def dare_cmd(self, ctx, rating: str | None = None):
         result = api.tord("https://api.truthordarebot.xyz/api/dare", rating)
         if result:
-            await ctx.send(choice(output["commands"]["dare"]).replace("{{QUESTION}}", result))
+            await ctx.send(choice(output["general"]["dare"]).replace("{{QUESTION}}", result))
         else:
             await ctx.send(error_messages["dare"])
 
     @ext_commands.command(
-        name=keywords["commands"]["wyr"][0],
-        aliases=keywords["commands"]["wyr"][1:],
+        name=keywords["general"]["wyr"][0],
+        aliases=keywords["general"]["wyr"][1:],
     )
     @ext_commands.check(lambda ctx: active["wyr"])
     async def wyr_cmd(self, ctx, rating: str | None = None):
         result = api.tord("https://api.truthordarebot.xyz/api/wyr", rating)
         if result:
-            await ctx.send(choice(output["commands"]["wyr"]).replace("{{QUESTION}}", result))
+            await ctx.send(choice(output["general"]["wyr"]).replace("{{QUESTION}}", result))
         else:
             await ctx.send(error_messages["wyr"])
 
     @ext_commands.command(
-        name=keywords["commands"]["never_have_i_ever"][0],
-        aliases=keywords["commands"]["never_have_i_ever"][1:],
+        name=keywords["general"]["never_have_i_ever"][0],
+        aliases=keywords["general"]["never_have_i_ever"][1:],
     )
     @ext_commands.check(lambda ctx: active["never_have_i_ever"])
     async def nhie_cmd(self, ctx, rating: str | None = None):
         result = api.tord("https://api.truthordarebot.xyz/api/nhie", rating)
         if result:
-            await ctx.send(choice(output["commands"]["never_have_i_ever"]).replace("{{QUESTION}}", result))
+            await ctx.send(choice(output["general"]["never_have_i_ever"]).replace("{{QUESTION}}", result))
         else:
             await ctx.send(error_messages["never-hie"])
 
     @ext_commands.command(
-        name=keywords["commands"]["paranoia"][0],
-        aliases=keywords["commands"]["paranoia"][1:],
+        name=keywords["general"]["paranoia"][0],
+        aliases=keywords["general"]["paranoia"][1:],
     )
     @ext_commands.check(lambda ctx: active["paranoia"])
     async def paranoia_cmd(self, ctx, rating: str | None = None):
         result = api.tord("https://api.truthordarebot.xyz/api/paranoia", rating)
         if result:
-            await ctx.send(choice(output["commands"]["paranoia"]).replace("{{QUESTION}}", result))
+            await ctx.send(choice(output["general"]["paranoia"]).replace("{{QUESTION}}", result))
         else:
             await ctx.send(error_messages["paranoia"])
 
     @ext_commands.command(
-        name=keywords["commands"]["qr_code"][0],
-        aliases=keywords["commands"]["qr_code"][1:],
+        name=keywords["general"]["qr_code"][0],
+        aliases=keywords["general"]["qr_code"][1:],
     )
     @ext_commands.check(lambda ctx: active["qr_code"])
     async def qr_cmd(self, ctx, link: str | None = None):
@@ -196,8 +196,8 @@ class Comprobot(ext_commands.Cog):
             await ctx.send(error_messages["missing_argument"])
 
     @ext_commands.command(
-        name=keywords["commands"]["calculate"][0],
-        aliases=keywords["commands"]["calculate"][1:],
+        name=keywords["general"]["calculate"][0],
+        aliases=keywords["general"]["calculate"][1:],
     )
     @ext_commands.check(lambda ctx: active["calculate"])
     async def calculate_cmd(self, ctx, *, expression: str | None = None):
@@ -207,23 +207,31 @@ class Comprobot(ext_commands.Cog):
             await ctx.send(error_messages["missing_argument"])
 
     @ext_commands.command(
-        name=keywords["commands"]["bitcoin"][0],
-        aliases=keywords["commands"]["bitcoin"][1:],
+        name=keywords["general"]["bitcoin"][0],
+        aliases=keywords["general"]["bitcoin"][1:],
     )
     @ext_commands.check(lambda ctx: active["bitcoin"])
     async def bitcoin_cmd(self, ctx, currency: str = "usd"):
         await ctx.send(api.bitcoin(currency))
 
     @ext_commands.command(
-        name=keywords["commands"]["ascii_art"][0],
-        aliases=keywords["commands"]["ascii_art"][1:],
+        name=keywords["general"]["help"][0],
+        aliases=keywords["general"]["help"][1:],
+    )
+    @ext_commands.check(lambda ctx: active["help"])
+    async def help_cmd(self, ctx, category: str | None = None):
+        await ctx.send(cmd_module.help(category))
+
+    @ext_commands.command(
+        name=keywords["general"]["ascii_art"][0],
+        aliases=keywords["general"]["ascii_art"][1:],
     )
     async def ascii_cmd(self, ctx):
         await ctx.send(cmd_module.ascii())
 
     @ext_commands.command(
-        name=keywords["commands"]["currency"][0],
-        aliases=keywords["commands"]["currency"][1:],
+        name=keywords["general"]["currency"][0],
+        aliases=keywords["general"]["currency"][1:],
     )
     @ext_commands.check(lambda ctx: active["currency"])
     async def currency_cmd(self, ctx, amount: str | None = None, from_currency: str | None = None, to_currency: str | None = None):

{comprobot-2.2.6 → comprobot-2.3.1}/src/templates.py

@@ -71,9 +71,11 @@ unknown_command   = "Unknown command."
 unknown_argument  = "Unknown argument."
 missing_argument  = "Missing argument."
 no_attachment     = "No attachment given."
-bot_unavailable   = "Bot not available."'''
+bot_unavailable   = "Bot not available."
+unknown_category  = "Unknown category."
+no_ascii_art      = "No ASCII art available."'''
 
-keywords = r"""[commands]
+keywords = r"""[general]
 quote             = ["quote"]
 joke              = ["joke"]
 meme              = ["meme"]
@@ -90,6 +92,7 @@ bitcoin           = ["bitcoin", "btc"]
 currency          = ["currency", "convert", "conv"]
 qr_code           = ["qr_code", "qr"]
 ascii_art         = ["ascii", "art"]
+help              = ["help"]
 
 truth             = ["truth"]
 dare              = ["dare"]
@@ -136,6 +139,7 @@ calculate         = true
 bitcoin           = true
 currency          = true
 qr_code           = true
+help              = true
 
 truth             = true
 dare              = true
@@ -148,7 +152,47 @@ nsfw              = false
 purge             = true
 """
 
-output = r"""[commands]
+descriptions = r"""[general]
+quote             = "Get a random inspirational quote."
+joke              = "Get a random two-part joke"
+meme              = "Get a random meme image"
+waifu             = "Compare two random waifu images"
+image             = "Get a random animal image (duck/dog/cat)"
+duck              = "Get a random duck image"
+dog               = "Get a random dog image"
+cat               = "Get a random cat image"
+chuck_norris      = "Get a random Chuck Norris fact"
+fact              = "Get a random fun fact"
+bible             = "Get a random or specific Bible verse"
+calculate         = "Evaluate a math expression"
+bitcoin           = "Get the current Bitcoin price in a given currency"
+currency          = "Convert an amount between two currencies"
+qr_code           = "Generate a QR code from a URL"
+ascii_art         = "Display the bot's ASCII art"
+help              = "Show available commands"
+
+truth             = "Get a truth question for truth or dare"
+dare              = "Get a dare challenge for truth or dare"
+wyr               = "Get a would you rather question"
+never_have_i_ever = "Get a never have I ever prompt"
+paranoia          = "Get a paranoia question"
+
+purge             = "Delete all messages in the channel (admin only)"
+
+[settings]
+settings          = "Configure the bot"
+profile_picture   = "Change the bot's profile picture"
+banner            = "Change the bot's banner"
+change_name       = "Change the bot's username"
+change_keywords   = "Change a command's trigger keywords"
+
+[money]
+check_balance     = "Check a user's money balance"
+add_money         = "Add money to a user's balance (admin only)"
+remove_money      = "Remove money from a user's balance (admin only)"
+"""
+
+output = r"""[general]
 quote             = ["{{QUOTE}}\n~ {{AUTHOR}}"]
 joke              = ["{{SETUP}} ||{{PUNCHLINE}}||"]
 meme              = ["{{URL}}"]

comprobot-2.2.6/src/commands.py

@@ -1,27 +0,0 @@
-from random import choice
-
-from .data import config, error_messages, output
-
-
-def qr(link):
-    url = f"https://api.qrserver.com/v1/create-qr-code/?size=150x150&data={link}"
-    return choice(output["commands"]["qr_code"]).replace(r"{{URL}}", url)
-
-
-def calculate(calculation):
-    try:
-        result = eval(calculation)
-        response = choice(output["commands"]["calculate"]).replace(
-            r"{{RESULT}}", str(result)
-        )
-    except ZeroDivisionError:
-        response = error_messages["calculate"]
-    except Exception:
-        response = error_messages["calculate"]
-    return response
-
-
-def ascii():
-    return choice(output["commands"]["ascii_art"]).replace(
-        r"{{ASCII_ART}}", choice(config["ascii_art"])
-    )