comprobot 2.2.5__tar.gz → 2.3.0__tar.gz

{comprobot-2.2.5 → comprobot-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comprobot
-Version: 2.2.5
+Version: 2.3.0
 Summary: A self-hostable Discord bot built for maximum customization.
 Author: badluma
 License: MIT
@@ -18,8 +18,7 @@ Requires-Dist: requests
 Requires-Dist: tomlkit
 Requires-Dist: appdirs
 Requires-Dist: ollama
-Requires-Dist: google-genai
-Requires-Dist: groq
+Requires-Dist: httpx
 Requires-Dist: InquirerPy
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"

{comprobot-2.2.5 → comprobot-2.3.0}/comprobot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comprobot
-Version: 2.2.5
+Version: 2.3.0
 Summary: A self-hostable Discord bot built for maximum customization.
 Author: badluma
 License: MIT
@@ -18,8 +18,7 @@ Requires-Dist: requests
 Requires-Dist: tomlkit
 Requires-Dist: appdirs
 Requires-Dist: ollama
-Requires-Dist: google-genai
-Requires-Dist: groq
+Requires-Dist: httpx
 Requires-Dist: InquirerPy
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"

{comprobot-2.2.5 → comprobot-2.3.0}/comprobot.egg-info/requires.txt

@@ -4,8 +4,7 @@ requests
 tomlkit
 appdirs
 ollama
-google-genai
-groq
+httpx
 InquirerPy
 
 [dev]

{comprobot-2.2.5 → comprobot-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "comprobot"
-version = "2.2.5"
+version = "2.3.0"
 authors = [{name = "badluma"}]
 description = "A self-hostable Discord bot built for maximum customization."
 readme = "README.md"
@@ -22,8 +22,7 @@ dependencies = [
     "tomlkit",
     "appdirs",
     "ollama",
-    "google-genai",
-    "groq",
+    "httpx",
     "InquirerPy",
 ]
 

{comprobot-2.2.5 → comprobot-2.3.0}/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.5 → comprobot-2.3.0}/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.0/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.5 → comprobot-2.3.0}/src/config.py

@@ -24,7 +24,8 @@ def make_pretty(string):
         .replace("_", " ") \
         .replace("-", " ") \
         .title() \
-        .replace("Ai", "AI")
+        .replace("Ai", "AI") \
+        .replace("Api", "API")
 
 def pick_file():
     data_dir = appdirs.user_data_dir("Comprobot", appauthor=False)
@@ -101,7 +102,7 @@ def pick_key(content, is_secret=False):
             ).execute()
             content[key] = value
 
-        case str() | int():
+        case str():
             print()
             if is_secret:
                 value = secret.SecretPrompt(
@@ -120,6 +121,30 @@ def pick_key(content, is_secret=False):
                 ).execute()
             content[key] = value
 
+        case int():
+            print()
+            if is_secret:
+                value = secret.SecretPrompt(
+                    message=f"New value for '{make_pretty(key)}'?",
+                    style=style,
+                    amark="!",
+                    vi_mode=True,
+                ).execute()
+            else:
+                value = input.InputPrompt(
+                    message=f"What number do you want to assign to '{make_pretty(key)}'?",
+                    instruction=f"(Current: {content[key]})",
+                    style=style,
+                    amark="!",
+                    vi_mode=True,
+                ).execute()
+
+            if int(value) == None:
+                content[key] = 0
+                return
+            
+            content[key] = int(value)
+
         case list():
             print()
             value = input.InputPrompt(
@@ -129,7 +154,7 @@ def pick_key(content, is_secret=False):
                 amark="!",
                 vi_mode=True,
             ).execute().split(",")
-            content[key] = [item.strip() for item in value]
+            content[key] = [item.strip() for item in value if item.strip()]
 
 
 

{comprobot-2.2.5 → comprobot-2.3.0}/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.5 → comprobot-2.3.0}/src/functions.py

@@ -1,3 +1,4 @@
+import asyncio
 import os
 import re
 import subprocess
@@ -5,10 +6,8 @@ from typing import Any, Dict, List, cast
 
 import appdirs
 import discord
-import groq
+import httpx
 import ollama
-from google import genai
-from google.genai.errors import ClientError
 
 from .bot import client
 from .data import ai, system_prompt_text
@@ -144,7 +143,6 @@ async def chat(message):
         )
         content = response.message.content or ""
     elif provider == "gemini":
-        gemini_client = genai.Client(api_key=os.getenv("GEMINI"))
         formatted_messages = []
         for m in messages:
             formatted_messages.append(
@@ -153,33 +151,55 @@ async def chat(message):
                     "parts": [{"text": m["content"]}],
                 }
             )
-
-        config = None
+        body: Dict[str, Any] = {"contents": formatted_messages}
         if system_prompt_text:
-            config = genai.types.GenerateContentConfig(
-                system_instruction=system_prompt_text
-            )
-
-        try:
-            response = gemini_client.models.generate_content(
-                model=ai["model"], contents=formatted_messages, config=config
-            )
-            content = response.text or ""
-        except ClientError as e:
-            if "NOT_FOUND" in str(e) or "404" in str(e):
-                available = gemini_client.models.list()
-                print(f"Available models: {[m.name for m in available]}")
-            raise
+            body["systemInstruction"] = {"parts": [{"text": system_prompt_text}]}
+
+        async with httpx.AsyncClient() as http:
+            resp = None
+            for attempt in range(4):
+                resp = await http.post(
+                    f"https://generativelanguage.googleapis.com/v1beta/models/{ai['model']}:generateContent",
+                    params={"key": os.getenv("GEMINI")},
+                    json=body,
+                    timeout=60,
+                )
+                if resp.status_code != 429:
+                    break
+                data = resp.json()
+                retry_delay = None
+                is_daily_quota = False
+                for detail in data.get("error", {}).get("details", []):
+                    if "retryDelay" in detail:
+                        retry_delay = detail["retryDelay"]
+                    if "violations" in detail:
+                        for v in detail["violations"]:
+                            if "PerDay" in v.get("quotaId", ""):
+                                is_daily_quota = True
+                if is_daily_quota or attempt == 3:
+                    resp.raise_for_status()
+                match = re.search(r"(\d+(?:\.\d+)?)", retry_delay or "")
+                wait = float(match.group(1)) if match else min(30 * (2 ** attempt), 120)
+                await asyncio.sleep(wait)
+            if resp is None:
+                raise RuntimeError("Gemini request never sent")
+            if resp.status_code == 404:
+                print(f"Model '{ai['model']}' not found. Check ai.toml for valid model name.")
+            resp.raise_for_status()
+            content = resp.json()["candidates"][0]["content"]["parts"][0]["text"]
     elif provider == "groq":
-        groq_client = groq.Groq(api_key=os.getenv("GROQ"))
         formatted_messages = [
             {"role": "system", "content": system_prompt_text}
         ] + messages
-        response = groq_client.chat.completions.create(
-            model=cast(str, ai["model"]),
-            messages=cast(Any, formatted_messages),
-        )
-        content = response.choices[0].message.content or ""
+        async with httpx.AsyncClient() as http:
+            resp = await http.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                headers={"Authorization": f"Bearer {os.getenv('GROQ')}"},
+                json={"model": ai["model"], "messages": formatted_messages},
+                timeout=60,
+            )
+        resp.raise_for_status()
+        content = resp.json()["choices"][0]["message"]["content"] or ""
     else:
         raise ValueError(f"Unknown provider: {ai['provider']}")
 

{comprobot-2.2.5 → comprobot-2.3.0}/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.5 → comprobot-2.3.0}/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.5/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"])
-    )