comprobot 2.1.0__tar.gz → 2.1.2__tar.gz

{comprobot-2.1.0/comprobot.egg-info → comprobot-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comprobot
-Version: 2.1.0
+Version: 2.1.2
 Summary: A self-hostable Discord bot built for maximum customization.
 Author: badluma
 License: MIT
@@ -19,7 +19,7 @@ Requires-Dist: appdirs
 Requires-Dist: ollama
 Requires-Dist: google-genai
 Requires-Dist: groq
-Requires-Dist: InqurererPy
+Requires-Dist: InquirerPy
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 
@@ -27,10 +27,38 @@ Requires-Dist: ruff; extra == "dev"
 
 Comprobot is a highly-customizable, open-source Discord bot that you can run on your own server.
 
-It’s built with Python, has a wide range of fun and useful commands, and is designed to be easy to extend. You can add new commands, customize outputs , or change the behaviour of existing ones. You can also easily edit the keywords of existing commands and customize their outputs.
+It’s built with Python, has a wide range of fun and useful commands, and is designed to be easy to extend. You can add new commands, customize outputs, or change the behaviour of existing ones. You can also easily edit the keywords of existing commands and customize their outputs.
 
 The bot also comes with built-in AI capabilities when pinging the bot, with Ollama, Groq and Gemini as available providers.
 
+## Install
+
+**pipx** (All platforms)
+```sh
+pipx install comprobot
+```
+
+**APT** (Ubuntu/Debian)
+```sh
+sudo add-apt-repository ppa:badluma/ppa
+sudo apt update && sudo apt upgrade 
+sudo apt install comprobot
+```
+
+**Homebrew** (macOS)
+```sh
+brew tap badluma/homebrew
+brew install comprobot
+```
+
+**Scoop** (Windows)
+```sh
+scoop bucket add badluma https://github.com/badluma/scoop-bucket
+scoop install comprobot
+```
+
+Support for Docker Hub and AUR (Arch Linux) is planned.
+
 ## Documentation
 
 You can find the whole documentation [here](https://badluma.github.io/Comprobot-Docs/).

comprobot-2.1.2/README.md

@@ -0,0 +1,43 @@
+# Comprobot
+
+Comprobot is a highly-customizable, open-source Discord bot that you can run on your own server.
+
+It’s built with Python, has a wide range of fun and useful commands, and is designed to be easy to extend. You can add new commands, customize outputs, or change the behaviour of existing ones. You can also easily edit the keywords of existing commands and customize their outputs.
+
+The bot also comes with built-in AI capabilities when pinging the bot, with Ollama, Groq and Gemini as available providers.
+
+## Install
+
+**pipx** (All platforms)
+```sh
+pipx install comprobot
+```
+
+**APT** (Ubuntu/Debian)
+```sh
+sudo add-apt-repository ppa:badluma/ppa
+sudo apt update && sudo apt upgrade 
+sudo apt install comprobot
+```
+
+**Homebrew** (macOS)
+```sh
+brew tap badluma/homebrew
+brew install comprobot
+```
+
+**Scoop** (Windows)
+```sh
+scoop bucket add badluma https://github.com/badluma/scoop-bucket
+scoop install comprobot
+```
+
+Support for Docker Hub and AUR (Arch Linux) is planned.
+
+## Documentation
+
+You can find the whole documentation [here](https://badluma.github.io/Comprobot-Docs/).
+
+## License
+
+MIT

{comprobot-2.1.0 → comprobot-2.1.2/comprobot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comprobot
-Version: 2.1.0
+Version: 2.1.2
 Summary: A self-hostable Discord bot built for maximum customization.
 Author: badluma
 License: MIT
@@ -19,7 +19,7 @@ Requires-Dist: appdirs
 Requires-Dist: ollama
 Requires-Dist: google-genai
 Requires-Dist: groq
-Requires-Dist: InqurererPy
+Requires-Dist: InquirerPy
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 
@@ -27,10 +27,38 @@ Requires-Dist: ruff; extra == "dev"
 
 Comprobot is a highly-customizable, open-source Discord bot that you can run on your own server.
 
-It’s built with Python, has a wide range of fun and useful commands, and is designed to be easy to extend. You can add new commands, customize outputs , or change the behaviour of existing ones. You can also easily edit the keywords of existing commands and customize their outputs.
+It’s built with Python, has a wide range of fun and useful commands, and is designed to be easy to extend. You can add new commands, customize outputs, or change the behaviour of existing ones. You can also easily edit the keywords of existing commands and customize their outputs.
 
 The bot also comes with built-in AI capabilities when pinging the bot, with Ollama, Groq and Gemini as available providers.
 
+## Install
+
+**pipx** (All platforms)
+```sh
+pipx install comprobot
+```
+
+**APT** (Ubuntu/Debian)
+```sh
+sudo add-apt-repository ppa:badluma/ppa
+sudo apt update && sudo apt upgrade 
+sudo apt install comprobot
+```
+
+**Homebrew** (macOS)
+```sh
+brew tap badluma/homebrew
+brew install comprobot
+```
+
+**Scoop** (Windows)
+```sh
+scoop bucket add badluma https://github.com/badluma/scoop-bucket
+scoop install comprobot
+```
+
+Support for Docker Hub and AUR (Arch Linux) is planned.
+
 ## Documentation
 
 You can find the whole documentation [here](https://badluma.github.io/Comprobot-Docs/).

comprobot-2.1.2/comprobot.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+comprobot.egg-info/PKG-INFO
+comprobot.egg-info/SOURCES.txt
+comprobot.egg-info/dependency_links.txt
+comprobot.egg-info/entry_points.txt
+comprobot.egg-info/requires.txt
+comprobot.egg-info/top_level.txt
+src/__init__.py
+src/__main__.py
+src/api.py
+src/bot.py
+src/commands.py
+src/data.py
+src/functions.py
+src/main.py
+src/moderation.py
+src/money_system.py
+src/onboarding.py
+src/process.py
+src/templates.py
+src/testing.py

comprobot-2.1.2/comprobot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+comprobot = src.__main__:cli_main

{comprobot-2.1.0 → comprobot-2.1.2}/comprobot.egg-info/requires.txt

@@ -6,7 +6,7 @@ appdirs
 ollama
 google-genai
 groq
-InqurererPy
+InquirerPy
 
 [dev]
 ruff

comprobot-2.1.2/comprobot.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

{comprobot-2.1.0 → comprobot-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "comprobot"
-version = "2.1.0"
+version = "2.1.2"
 authors = [{name = "badluma"}]
 description = "A self-hostable Discord bot built for maximum customization."
 readme = "README.md"
@@ -24,7 +24,7 @@ dependencies = [
     "ollama",
     "google-genai",
     "groq",
-    "InqurererPy",
+    "InquirerPy",
 ]
 
 [project.optional-dependencies]
@@ -35,8 +35,8 @@ Homepage = "https://badluma.github.io/Comprobot-Docs"
 Repository = "https://github.com/badluma/comprobot"
 
 [project.scripts]
-comprobot = "Comprobot.main:main"
+comprobot = "src.__main__:cli_main"
 
 [tool.setuptools.packages.find]
 where = ["."]
-include = ["Comprobot*"]
+include = ["src*"]

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/__main__.py

@@ -6,21 +6,20 @@ from .data import active, ai, get_data_path, save_toml
 from .main import main
 from .onboarding import onboarding
 
-parser = argparse.ArgumentParser(
-    prog="comprobot",
-    description="A self-hostable open-source Discord bot built for maximum customization.",
-)
-subparsers = parser.add_subparsers(dest="command", metavar="")
-subparsers.add_parser("onboard", help="Set up Comprobot for the first time.")
-subparsers.add_parser("start", help="Start the bot.")
-# subparsers.add_parser("config", help="View or edit the bot's configuration.") TODO: implement config command
-# subparsers.add_parser("reset", help="Reset the bot's data and configuration.") TODO: implement reset command
 
-args = parser.parse_args()
+def cli_main():
+    parser = argparse.ArgumentParser(
+        prog="comprobot",
+        description="A self-hostable open-source Discord bot built for maximum customization.",
+    )
+    subparsers = parser.add_subparsers(dest="command", metavar="")
+    subparsers.add_parser("onboard", help="Set up Comprobot for the first time.")
+    subparsers.add_parser("start", help="Start the bot.")
+    test_parser = subparsers.add_parser("test", help="Process a message through the bot's command processor.")
+    test_parser.add_argument("message", help="The message to process (e.g. '!calculate 2+2')")
 
-settings: dict = {}
+    args = parser.parse_args()
 
-if __name__ == "__main__":
     match args.command:
         case "start":
             main()
@@ -73,5 +72,13 @@ if __name__ == "__main__":
 
             main()
 
+        case "test":
+            from .testing import run_test
+            run_test(args.message)
+
         case _:
             print(parser.format_help())
+
+
+if __name__ == "__main__":
+    cli_main()

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/api.py

@@ -6,10 +6,13 @@ from .data import error_messages, output
 
 
 def access_api(url, parameter, error_message, headers=None):
-    if headers:
-        raw = requests.get(url, headers=headers)
-    else:
-        raw = requests.get(url)
+    try:
+        if headers:
+            raw = requests.get(url, headers=headers)
+        else:
+            raw = requests.get(url)
+    except requests.exceptions.RequestException as e:
+        return (False, str(f"{error_message} ({e})"))
     if raw.status_code == 200:
         try:
             data = raw.json()
@@ -25,7 +28,10 @@ def access_api(url, parameter, error_message, headers=None):
 
 # ---------- Commands ----------
 def quote():
-    quote_response = requests.get("https://zenquotes.io/api/random")
+    try:
+        quote_response = requests.get("https://zenquotes.io/api/random")
+    except requests.exceptions.RequestException as e:
+        return f"{error_messages['quote']} ({e})"
     if quote_response.status_code != 200:
         return f"{error_messages['quote']} (HTTP {quote_response.status_code})"
     try:

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/bot.py

@@ -3,6 +3,7 @@ import os
 import appdirs
 import discord
 import dotenv
+from discord.ext import commands
 
 dotenv.load_dotenv(
     dotenv.find_dotenv(
@@ -14,4 +15,11 @@ dotenv.load_dotenv(
 
 intents = discord.Intents.default()
 intents.message_content = True
-client = discord.Client(intents=intents)
+
+from .data import config  # noqa: E402
+
+bot = commands.Bot(
+    command_prefix=lambda b, m: config["prefix"],
+    intents=intents,
+)
+client = bot

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/data.py

@@ -17,7 +17,7 @@ def ensure_file(path, content):
 
     os.makedirs(os.path.dirname(path), exist_ok=True)
     if not os.path.isfile(path):
-        with open(path, "w") as f:
+        with open(path, "w", encoding="utf-8") as f:
             f.write(content)
 
 
@@ -31,18 +31,18 @@ def merge_defaults(data, defaults):
 
 def load_or_create(path, template_content):
     try:
-        with open(path, "rb") as f:
-            data = tomlkit.load(f)
+        with open(path, "r", encoding="utf-8") as f:
+            data = tomlkit.loads(f.read())
     except FileNotFoundError:
         ensure_file(path, template_content)
-        with open(path, "rb") as f:
-            data = tomlkit.load(f)
+        with open(path, "r", encoding="utf-8") as f:
+            data = tomlkit.loads(f.read())
 
     defaults = tomlkit.loads(template_content)
     merge_defaults(data, defaults)
 
     if data != defaults:
-        with open(path, "w") as f:
+        with open(path, "w", encoding="utf-8") as f:
             tomlkit.dump(data, f)
 
     return data
@@ -56,7 +56,7 @@ keywords: Dict[str, Dict[str, List[str]]] = load_or_create(
     get_data_path("keywords.toml"), templates.keywords
 )
 ai: Dict[str, Any] = load_or_create(get_data_path("ai.toml"), templates.ai)
-system_prompt_text = ai["system_prompt"]
+system_prompt_text: str = str(ai["system_prompt"])
 money: Dict[str, Dict[str, int]] = load_or_create(
     get_data_path("money.toml"), r"""members = {}"""
 )
@@ -72,5 +72,5 @@ ensure_file(get_data_path(".env"), templates.env)
 
 
 def save_toml(data, path):
-    with open(path, "w") as f:
+    with open(path, "w", encoding="utf-8") as f:
         tomlkit.dump(data, f)

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/functions.py

@@ -176,8 +176,8 @@ async def chat(message):
             {"role": "system", "content": system_prompt_text}
         ] + messages
         response = groq_client.chat.completions.create(
-            model=ai["model"],
-            messages=formatted_messages,  # type: ignore
+            model=cast(str, ai["model"]),
+            messages=cast(Any, formatted_messages),
         )
         content = response.choices[0].message.content or ""
     else:

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/main.py

@@ -6,8 +6,9 @@ from os import path as os_path
 import appdirs
 import dotenv
 
-from . import process
-from .functions import client, para
+from .bot import client
+from .functions import para
+from .process import Comprobot
 
 dotenv.load_dotenv(
     dotenv.find_dotenv(
@@ -17,8 +18,6 @@ dotenv.load_dotenv(
     )
 )
 
-
-response = None
 if sys.platform.startswith("win"):
     print("Running on Windows (cmd)")
 elif platform.system() in ["Linux", "Darwin"]:
@@ -27,9 +26,11 @@ else:
     print("Unknown OS")
 
 
-@client.event
-async def on_message(message):
-    await process.process(message)
+async def _setup_hook():
+    await client.add_cog(Comprobot(client))
+
+
+client.setup_hook = _setup_hook
 
 
 @client.event

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/moderation.py

@@ -50,6 +50,7 @@ async def kick(message, item):
         print(f"Couldn't DM {message.author.name}")
 
 
+
 async def check_message(message):
     if message.guild is None:
         return

comprobot-2.1.2/src/process.py

@@ -0,0 +1,411 @@
+import os
+from random import choice
+
+import discord
+from appdirs import user_cache_dir, user_data_dir
+from discord.ext import commands as ext_commands
+
+from . import api
+from . import commands as cmd_module
+from . import money_system
+from .bot import bot
+from .data import active, ai, config, error_messages, keywords, output
+from .functions import chat
+from .moderation import check_message
+
+
+def _is_admin_or_bot_admin():
+    async def predicate(ctx):
+        return (
+            ctx.author.guild_permissions.administrator
+            or ctx.author.id in config["bot_admins"]
+        )
+    return ext_commands.check(predicate)
+
+
+class Comprobot(ext_commands.Cog):
+
+    async def cog_before_invoke(self, ctx):
+        await ctx.bot.http.send_typing(ctx.channel.id)
+
+    # ── Commands ─────────────────────────────────────────────────────────────
+
+    @ext_commands.command(
+        name=keywords["commands"]["quote"][0],
+        aliases=keywords["commands"]["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:],
+    )
+    @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:],
+    )
+    @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:],
+    )
+    @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:],
+        invoke_without_command=True,
+    )
+    @ext_commands.check(lambda ctx: active["image"])
+    async def image_cmd(self, ctx):
+        await ctx.send(error_messages["missing_argument"])
+
+    @image_cmd.command(
+        name=keywords["commands"]["duck"][0],
+        aliases=keywords["commands"]["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:],
+    )
+    @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:],
+    )
+    @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:],
+    )
+    @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:],
+    )
+    @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:],
+    )
+    @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):
+        if book is None:
+            await ctx.send(api.bible(True))
+        elif chapter is not None and verse is not None:
+            await ctx.send(api.bible(False, book, chapter, verse))
+        else:
+            await ctx.send(error_messages["missing_argument"])
+
+    @ext_commands.command(
+        name=keywords["commands"]["truth"][0],
+        aliases=keywords["commands"]["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))
+        else:
+            await ctx.send(error_messages["truth"])
+
+    @ext_commands.command(
+        name=keywords["commands"]["dare"][0],
+        aliases=keywords["commands"]["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))
+        else:
+            await ctx.send(error_messages["dare"])
+
+    @ext_commands.command(
+        name=keywords["commands"]["wyr"][0],
+        aliases=keywords["commands"]["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))
+        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:],
+    )
+    @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))
+        else:
+            await ctx.send(error_messages["never-hie"])
+
+    @ext_commands.command(
+        name=keywords["commands"]["paranoia"][0],
+        aliases=keywords["commands"]["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))
+        else:
+            await ctx.send(error_messages["paranoia"])
+
+    @ext_commands.command(
+        name=keywords["commands"]["qr_code"][0],
+        aliases=keywords["commands"]["qr_code"][1:],
+    )
+    @ext_commands.check(lambda ctx: active["qr_code"])
+    async def qr_cmd(self, ctx, link: str | None = None):
+        if link:
+            await ctx.send(cmd_module.qr(link))
+        else:
+            await ctx.send(error_messages["missing_argument"])
+
+    @ext_commands.command(
+        name=keywords["commands"]["calculate"][0],
+        aliases=keywords["commands"]["calculate"][1:],
+    )
+    @ext_commands.check(lambda ctx: active["calculate"])
+    async def calculate_cmd(self, ctx, *, expression: str | None = None):
+        if expression:
+            await ctx.send(cmd_module.calculate(expression))
+        else:
+            await ctx.send(error_messages["missing_argument"])
+
+    @ext_commands.command(
+        name=keywords["commands"]["bitcoin"][0],
+        aliases=keywords["commands"]["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:],
+    )
+    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:],
+    )
+    @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):
+        if not all([amount, from_currency, to_currency]):
+            await ctx.send(error_messages["missing_argument"])
+            return
+        await ctx.send(api.currency(from_currency, to_currency, amount))
+
+    # ── Money ─────────────────────────────────────────────────────────────────
+
+    @ext_commands.command(
+        name=keywords["money"]["check_balance"][0],
+        aliases=keywords["money"]["check_balance"][1:],
+    )
+    async def check_balance_cmd(self, ctx, username: str | None = None):
+        if username:
+            await ctx.send(money_system.check_balance(username))
+        else:
+            await ctx.send(error_messages["missing_argument"])
+
+    @ext_commands.command(
+        name=keywords["money"]["add_money"][0],
+        aliases=keywords["money"]["add_money"][1:],
+    )
+    @_is_admin_or_bot_admin()
+    async def add_money_cmd(self, ctx, username: str | None = None, amount: str | None = None):
+        if not username or not amount:
+            await ctx.send(error_messages["missing_argument"])
+            return
+        try:
+            await ctx.send(money_system.add_money(username, int(amount)))
+        except ValueError:
+            await ctx.send(f"Invalid amount: {amount}")
+
+    @ext_commands.command(
+        name=keywords["money"]["remove_money"][0],
+        aliases=keywords["money"]["remove_money"][1:],
+    )
+    @_is_admin_or_bot_admin()
+    async def remove_money_cmd(self, ctx, username: str | None = None, amount: str | None = None):
+        if not username or not amount:
+            await ctx.send(error_messages["missing_argument"])
+            return
+        try:
+            await ctx.send(money_system.remove_money(username, int(amount)))
+        except ValueError:
+            await ctx.send(f"Invalid amount: {amount}")
+
+    @ext_commands.command(name="purge")
+    @ext_commands.check(lambda ctx: active["purge"])
+    @ext_commands.has_permissions(administrator=True)
+    async def purge_cmd(self, ctx):
+        await ctx.channel.purge()
+
+    # ── Settings ──────────────────────────────────────────────────────────────
+
+    @ext_commands.group(
+        name=keywords["settings"]["settings"][0],
+        aliases=keywords["settings"]["settings"][1:],
+        invoke_without_command=True,
+    )
+    async def settings_cmd(self, ctx):
+        await ctx.send(error_messages["unknown_command"])
+
+    @settings_cmd.command(
+        name=keywords["settings"]["profile_picture"][0],
+        aliases=keywords["settings"]["profile_picture"][1:],
+    )
+    @_is_admin_or_bot_admin()
+    async def pfp_cmd(self, ctx):
+        if not ctx.message.attachments:
+            await ctx.send(error_messages["no_attachment"])
+            return
+        cache_dir = user_cache_dir("Comprobot", appauthor=False)
+        os.makedirs(cache_dir, exist_ok=True)
+        await ctx.message.attachments[0].save(f"{cache_dir}/pfp.png")
+        if bot.user is None:
+            await ctx.send(error_messages["bot_unavailable"])
+            return
+        with open(f"{cache_dir}/pfp.png", "rb") as f:
+            await bot.user.edit(avatar=f.read())
+        await ctx.send(choice(output["settings"]["profile_picture_applied"]))
+
+    @settings_cmd.command(
+        name=keywords["settings"]["banner"][0],
+        aliases=keywords["settings"]["banner"][1:],
+    )
+    @_is_admin_or_bot_admin()
+    async def banner_cmd(self, ctx):
+        if not ctx.message.attachments:
+            await ctx.send(error_messages["no_attachment"])
+            return
+        cache_dir = user_cache_dir("Comprobot", appauthor=False)
+        os.makedirs(cache_dir, exist_ok=True)
+        await ctx.message.attachments[0].save(f"{cache_dir}/banner.png")
+        if bot.user is None:
+            await ctx.send(error_messages["bot_unavailable"])
+            return
+        with open(f"{cache_dir}/banner.png", "rb") as f:
+            await bot.user.edit(banner=f.read())
+        await ctx.send(choice(output["settings"]["banner_applied"]))
+
+    @settings_cmd.command(
+        name=keywords["settings"]["change_name"][0],
+        aliases=keywords["settings"]["change_name"][1:],
+    )
+    @_is_admin_or_bot_admin()
+    async def name_cmd(self, ctx, *, name: str | None = None):
+        if not name:
+            await ctx.send(error_messages["missing_argument"])
+            return
+        if bot.user is None:
+            await ctx.send(error_messages["bot_unavailable"])
+            return
+        await bot.user.edit(username=name)
+        await ctx.send(choice(output["settings"]["nickname_applied"]).replace("{{NAME}}", name))
+
+    @settings_cmd.command(
+        name=keywords["settings"]["change_keywords"][0],
+        aliases=keywords["settings"]["change_keywords"][1:],
+    )
+    @_is_admin_or_bot_admin()
+    async def keywords_cmd(self, ctx, command_name: str | None = None, *new_keywords):
+        if not command_name or not new_keywords:
+            await ctx.send(error_messages["missing_argument"])
+            return
+        from . import data as data_module
+
+        target_category = None
+        for category in data_module.keywords:
+            if command_name in data_module.keywords[category]:
+                target_category = category
+                break
+        if target_category is None:
+            await ctx.send(error_messages["unknown_argument"])
+            return
+        data_module.keywords[target_category][command_name] = list(new_keywords)
+        data_module.save_toml(
+            data_module.keywords,
+            f"{user_data_dir('Comprobot')}/keywords.toml",
+        )
+        await ctx.send(
+            choice(output["settings"]["keywords_applied"])
+            .replace("{{KEYWORDS}}", " ".join(new_keywords))
+            .replace("{{COMMAND}}", command_name)
+        )
+
+    # ── Events ────────────────────────────────────────────────────────────────
+
+    @ext_commands.Cog.listener()
+    async def on_message(self, message):
+        print(
+            "\033[90m"
+            + f"[{message.channel}] "
+            + "\033[36m"
+            + f"{message.author.name}: "
+            + "\033[0m"
+            + message.content
+        )
+
+        if message.author == bot.user:
+            return
+
+        await check_message(message)
+
+        user_id = bot.user.id if bot.user else None
+
+        is_reply_to_bot = False
+        if message.reference and message.reference.message_id and user_id:
+            try:
+                ref_msg = await message.channel.fetch_message(message.reference.message_id)
+                is_reply_to_bot = ref_msg.author.id == user_id
+            except discord.NotFound:
+                pass
+
+        if (
+            f"<@{user_id}>" in message.content
+            or (is_reply_to_bot and ai["answer_to_reply"])
+        ) and ai["activate_ai"]:
+            async with message.channel.typing():
+                response = await chat(message)
+                if response:
+                    content = str(response)
+                    for chunk in [content[i : i + 2000] for i in range(0, len(content), 2000)]:
+                        await message.channel.send(chunk)

{comprobot-2.1.0/Comprobot → comprobot-2.1.2/src}/templates.py

@@ -37,9 +37,7 @@ user_prompt_structure = """
 '''
 
 config = r"""
-command_prefix =  "!"
-settings_prefix = "s!"
-music_prefix    = "m!"
+prefix =  "!"
 
 money_symbol    = "$"
 bot_admins      = []

comprobot-2.1.2/src/testing.py

@@ -0,0 +1,123 @@
+import asyncio
+import inspect
+import sys
+from typing import Any, cast
+
+from discord.ext import commands as ext_commands
+
+from .data import config
+from .process import Comprobot
+
+
+class _FakeHTTP:
+    async def send_typing(self, _):
+        pass
+
+
+class _FakePermissions:
+    administrator = True
+
+
+class _FakeAuthor:
+    id = 0
+    name = "tester"
+    guild_permissions = _FakePermissions()
+
+
+class _FakeChannel:
+    id = 0
+
+    async def purge(self):
+        pass
+
+
+class _FakeBotUser:
+    id = 1
+
+
+class _FakeBot:
+    http = _FakeHTTP()
+    user = _FakeBotUser()
+
+
+class _FakeMessage:
+    attachments = []
+    reference = None
+
+
+class _FakeCtx:
+    def __init__(self):
+        self.author = _FakeAuthor()
+        self.channel = _FakeChannel()
+        self.message = _FakeMessage()
+        self.bot = _FakeBot()
+
+    async def send(self, content):
+        print(content)
+
+
+def _find_command(cog, parts):
+    """Return (command, remaining_args) or (None, [])."""
+    if not parts:
+        return None, []
+
+    cmd_name = parts[0].lower()
+    remaining = parts[1:]
+
+    for command in cog.__cog_commands__:
+        if command.parent is not None:
+            continue
+        names = [command.name] + list(command.aliases or [])
+        if cmd_name not in names:
+            continue
+        if isinstance(command, ext_commands.Group) and remaining:
+            sub = command.all_commands.get(remaining[0].lower())
+            if sub:
+                return sub, remaining[1:]
+        return command, remaining
+
+    return None, []
+
+
+async def _run(message: str) -> int:
+    prefix = config.get("prefix", "!")
+    if not message.startswith(prefix):
+        print(f"Error: message must start with prefix '{prefix}'")
+        return 1
+
+    parts = message[len(prefix):].split()
+    if not parts:
+        print("Error: empty command")
+        return 1
+
+    cog = Comprobot()
+    ctx: Any = _FakeCtx()
+    await cog.cog_before_invoke(ctx)
+
+    command, args = _find_command(cog, parts)
+    if command is None:
+        print(f"Error: unknown command '{parts[0]}'")
+        return 1
+
+    sig = inspect.signature(command.callback)
+    params = list(sig.parameters.values())[2:]  # skip self, ctx
+    kw_only = [p for p in params if p.kind == inspect.Parameter.KEYWORD_ONLY]
+
+    fn = cast(Any, command.callback)
+    try:
+        if kw_only and args:
+            await fn(cog, ctx, **{kw_only[0].name: " ".join(args)})
+        else:
+            await fn(cog, ctx, *args)
+    except Exception as e:
+        print(f"Error: {e}")
+        return 1
+
+    return 0
+
+
+def run_test(message: str) -> None:
+    import io
+    if isinstance(sys.stdout, io.TextIOWrapper):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(asyncio.run(_run(message)))

comprobot-2.1.0/Comprobot/process.py

@@ -1,256 +0,0 @@
-import os
-from random import choice
-from typing import Any, cast
-
-import discord
-from appdirs import user_cache_dir, user_data_dir
-
-from . import api, commands, data, money_system
-from .bot import client
-from .data import active, ai, config, error_messages, keywords, output
-from .functions import chat
-from .moderation import check_message
-
-
-async def command(message) -> str | None | Any:
-
-    command_parts = message.content[len(config["command_prefix"]) :].strip().split()
-
-    command = command_parts[0]
-    args = command_parts[1:]
-
-    if command in keywords["commands"]["quote"] and active["quote"]:
-        return api.quote()
-    elif command in keywords["commands"]["joke"] and active["joke"]:
-        return api.joke()
-    elif command in keywords["commands"]["meme"] and active["meme"]:
-        return api.meme()
-    elif command in keywords["commands"]["waifu"] and active["waifu"]:
-        return api.waifu()
-    elif command in keywords["commands"]["image"] and active["image"]:
-        if args[0] in keywords["commands"]["duck"] and active["duck"]:
-            return api.duck()
-        elif args[0] in keywords["commands"]["dog"] and active["dog"]:
-            return api.dog()
-        elif args[0] in keywords["commands"]["cat"] and active["cat"]:
-            return api.cat()
-        elif not args:
-            return error_messages["missing_argument"]
-        else:
-            return error_messages["unknown_argument"]
-    elif command in keywords["commands"]["chuck_norris"] and active["chuck_norris"]:
-        return api.chuck()
-    elif command in keywords["commands"]["fact"] and active["fact"]:
-        return api.fact()
-    elif command in keywords["commands"]["bible"] and active["bible"]:
-        if not args:
-            return api.bible(True)
-        if len(args) >= 3:
-            return api.bible(False, args[0], args[1], args[2])
-        return error_messages["passage_not_found"]
-    elif command in keywords["commands"]["truth"] and active["truth"]:
-        return api.tord(
-            "https://api.truthordarebot.xyz/v1/truth", args[0] if args else None
-        )
-    elif command in keywords["commands"]["dare"] and active["dare"]:
-        return api.tord(
-            "https://api.truthordarebot.xyz/api/dare", args[0] if args else None
-        )
-    elif command in keywords["commands"]["wyr"] and active["wyr"]:
-        return api.tord(
-            "https://api.truthordarebot.xyz/api/wyr", args[0] if args else None
-        )
-    elif (
-        command in keywords["commands"]["never_have_i_ever"]
-        and active["never_have_i_ever"]
-    ):
-        return api.tord(
-            "https://api.truthordarebot.xyz/api/nhie", args[0] if args else None
-        )
-    elif command in keywords["commands"]["paranoia"] and active["paranoia"]:
-        return api.tord(
-            "https://api.truthordarebot.xyz/api/paranoia", args[0] if args else None
-        )
-
-    elif command in keywords["commands"]["qr_code"] and active["qr_code"]:
-        if args:
-            return commands.qr(args[0])
-        else:
-            return error_messages["missing_argument"]
-
-    elif command in keywords["commands"]["calculate"]:
-        if args:
-            return commands.calculate(args[0])
-        else:
-            return error_messages["missing_argument"]
-
-    elif command in keywords["commands"]["bitcoin"] and active["bitcoin"]:
-        return api.bitcoin(args[0] if args else "usd")
-
-    elif command in keywords["commands"]["ascii_art"]:
-        return commands.ascii()
-
-    elif command in keywords["commands"]["currency"] and active["currency"]:
-        if not len(args) >= 3:
-            return error_messages["missing_argument"]
-        return api.currency(args[1], args[2], args[0])
-
-    elif command in keywords["money"]["check_balance"]:
-        if args:
-            return money_system.check_balance(args[0])
-        else:
-            return error_messages["missing_argument"]
-    elif command in keywords["money"]["add_money"] and (
-        message.author.guild_permissions.administrator or config["bot_admins"]
-    ):
-        if len(args) >= 2:
-            try:
-                amount = int(args[1])
-                return money_system.add_money(args[0], amount)
-            except ValueError:
-                return f"Invalid amount: {args[1]}"
-        else:
-            return "No amount given."
-    elif command in keywords["money"]["remove_money"] and (
-        message.author.guild_permissions.administrator or config["bot_admins"]
-    ):
-        if len(args) >= 2:
-            try:
-                amount = int(args[1])
-                return money_system.remove_money(args[0], amount)
-            except ValueError:
-                return f"Invalid amount: {args[1]}"
-        else:
-            return "No amount given."
-
-    elif command == "purge" and active["purge"]:
-        if message.author.guild_permissions.administrator:
-            await message.channel.purge()
-            return "All messages deleted."
-
-    else:
-        return None
-
-
-async def settings(message):
-
-    command_parts = message.content[len(config["settings_prefix"]) :].strip().split()
-
-    command = command_parts[0]
-    args = command_parts[1:]
-
-    cache_dir = user_cache_dir("Comprobot", appauthor=False)
-    os.makedirs(cache_dir, exist_ok=True)
-
-    if command in keywords["settings"]["profile_picture"]:
-        if not message.attachments:
-            return error_messages["no_attachments"]
-        if client is None or client.user is None:
-            return error_messages["bot_unavailable"]
-        new_pfp = message.attachments[0]
-        await new_pfp.save(f"{cache_dir}/pfp.png")
-        with open(f"{cache_dir}/pfp.png", "rb") as image_file:
-            image_data = image_file.read()
-        await client.user.edit(avatar=image_data)
-        return choice(output["settings"]["profile_picture_applied"])
-
-    elif command in keywords["settings"]["banner"]:
-        if not message.attachments:
-            return error_messages["no_attachments"]
-        if client is None or client.user is None:
-            return error_messages["bot_unavailable"]
-        new_banner = message.attachments[0]
-        await new_banner.save(f"{cache_dir}/banner.png")
-        with open(f"{cache_dir}/banner.png", "rb") as image_file:
-            image_data = image_file.read()
-        await client.user.edit(banner=image_data)
-        return choice(output["settings"]["banner_applied"])
-
-    elif command in keywords["settings"]["change_name"]:
-        if len(args) < 2:
-            return error_messages["missing_argument"]
-        if client is None or client.user is None:
-            return error_messages["bot_unavailable"]
-        await client.user.edit(username=args[1])
-        return choice(output["settings"]["nickname_applied"]).replace(
-            "{{NAME}}", " ".join(args[1:])
-        )
-
-    elif command in keywords["settings"]["change_keywords"]:
-        if len(args) < 2:
-            return error_messages["missing_argument"]
-
-        target_category = None
-        for category in keywords:
-            if args[0] in keywords[category]:
-                target_category = category
-                break
-
-        if target_category is None:
-            return error_messages["unknown_argument"]
-
-        keywords[target_category][args[0]] = args[1:]
-
-        data.save_toml(keywords, f"{user_data_dir('Comprobot')}/keywords.toml")
-
-        return (
-            choice(output["settings"]["keywords_applied"])
-            .replace("{{KEYWORDS}}", " ".join(args[1:]))
-            .replace("{{COMMAND}}", args[0])
-        )
-
-    else:
-        return error_messages["unknown_command"]
-
-
-async def games(message):
-    pass
-
-
-async def process(message):
-    print(
-        "\033[90m"
-        + f"[{message.channel}] "
-        + "\033[36m"
-        + f"{message.author.name}: "
-        + "\033[0m"
-        + message.content
-    )
-
-    global response
-
-    if message.author == client.user:
-        return
-    response = None
-
-    await check_message(message)
-
-    if message.content.startswith(cast(str, config["command_prefix"])):
-        async with message.channel.typing():
-            response = await command(message)
-    elif message.content.startswith(cast(str, config["settings_prefix"])):
-        async with message.channel.typing():
-            response = await settings(message)
-
-    is_reply_to_bot = False
-    user_id = client.user.id if client.user else None
-    if message.reference and message.reference.message_id and user_id:
-        try:
-            ref_msg = await message.channel.fetch_message(message.reference.message_id)
-            is_reply_to_bot = ref_msg.author.id == user_id
-        except discord.NotFound:
-            pass
-
-    if (
-        f"<@{user_id}>" in message.content
-        or (is_reply_to_bot if ai["answer_to_reply"] else False)
-        and ai["activate_ai"]
-    ):
-        async with message.channel.typing():
-            response = await chat(message)
-
-    if response:
-        async with message.channel.typing():
-            content = str(response)
-            for chunk in [content[i : i + 2000] for i in range(0, len(content), 2000)]:
-                await message.channel.send(chunk)

comprobot-2.1.0/README.md

@@ -1,15 +0,0 @@
-# Comprobot
-
-Comprobot is a highly-customizable, open-source Discord bot that you can run on your own server.
-
-It’s built with Python, has a wide range of fun and useful commands, and is designed to be easy to extend. You can add new commands, customize outputs , or change the behaviour of existing ones. You can also easily edit the keywords of existing commands and customize their outputs.
-
-The bot also comes with built-in AI capabilities when pinging the bot, with Ollama, Groq and Gemini as available providers.
-
-## Documentation
-
-You can find the whole documentation [here](https://badluma.github.io/Comprobot-Docs/).
-
-## License
-
-MIT

comprobot-2.1.0/comprobot.egg-info/SOURCES.txt

@@ -1,21 +0,0 @@
-README.md
-pyproject.toml
-Comprobot/__init__.py
-Comprobot/__main__.py
-Comprobot/api.py
-Comprobot/bot.py
-Comprobot/commands.py
-Comprobot/data.py
-Comprobot/functions.py
-Comprobot/main.py
-Comprobot/moderation.py
-Comprobot/money_system.py
-Comprobot/onboarding.py
-Comprobot/process.py
-Comprobot/templates.py
-comprobot.egg-info/PKG-INFO
-comprobot.egg-info/SOURCES.txt
-comprobot.egg-info/dependency_links.txt
-comprobot.egg-info/entry_points.txt
-comprobot.egg-info/requires.txt
-comprobot.egg-info/top_level.txt

comprobot-2.1.0/comprobot.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-comprobot = Comprobot.main:main

comprobot-2.1.0/comprobot.egg-info/top_level.txt

@@ -1 +0,0 @@
-Comprobot