Use get_channel_or_thread so that threads can be found.

Reviewed-on: #87
Reviewed-by: imcompiling <[email protected]>

.dockerignore

@@ -1,2 +1,5 @@
 .*
 Dockerfile
+LICENSE
+README.md
+renovate.json

.gitea/workflows/build_develop.yml

@@ -2,14 +2,18 @@ name: build_develop
 
 on:
   push:
-    branches: [main]
+    branches:
+      - "*"
+      - "!main"
+    paths-ignore:
+      - "README.md"
 
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Install Docker
@@ -20,7 +24,9 @@ jobs:
           registry: gitea.cheezers.org
           username: imcompiling
           password: ${{ secrets.PASSWORD }}
+      - name: set env
+        run: echo "GIT_BRANCH=${GITHUB_HEAD_REF:-${GITHUB_REF#refs/heads/}}" >> $GITHUB_ENV
       - name: Build Docker Image
-        run: docker build -t gitea.cheezers.org/imcompiling/agon:develop .
+        run: docker build -t gitea.cheezers.org/imcompiling/agon:${{env.GIT_BRANCH}} .
       - name: Push Docker Image
-        run: docker push gitea.cheezers.org/imcompiling/agon:develop
+        run: docker push gitea.cheezers.org/imcompiling/agon:${{env.GIT_BRANCH}}

.gitea/workflows/build_latest.yaml

@@ -0,0 +1,28 @@
+name: build_latest
+
+on:
+  push:
+    branches: [main]
+    paths-ignore:
+      - "README.md"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Install Docker
+        uses: https://github.com/papodaca/install-docker-action@v1
+      - name: Log into container registry
+        uses: docker/login-action@v3
+        with:
+          registry: gitea.cheezers.org
+          username: imcompiling
+          password: ${{ secrets.PASSWORD }}
+      - name: Build Docker Image
+        run: docker build -t gitea.cheezers.org/imcompiling/agon:latest .
+      - name: Push Docker Image
+        run: docker push gitea.cheezers.org/imcompiling/agon:latest

.gitea/workflows/build_release.yml

@@ -23,8 +23,6 @@ jobs:
       - name: Set env
         run: echo "GIT_TAG=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
       - name: Build Docker Images
-        run: docker build -t gitea.cheezers.org/imcompiling/agon:latest -t gitea.cheezers.org/imcompiling/agon:${{env.GIT_TAG}} .
-      - name: Push Latest Image
-        run: docker push gitea.cheezers.org/imcompiling/agon:latest
+        run: docker build -t gitea.cheezers.org/imcompiling/agon:${{env.GIT_TAG}} .
       - name: Push Tagged Image
         run: docker push gitea.cheezers.org/imcompiling/agon:${{env.GIT_TAG}}

.gitignore

@@ -135,4 +135,4 @@ deleted_backups/
 highscores_data/
 TODO.txt
 sql_tester.py
-database.db
+/database

.vscode/launch.json

@@ -8,8 +8,8 @@
             "name": "Python: Module",
             "type": "debugpy",
             "request": "launch",
-            "module": "main",
+            "module": "agon",
             "justMyCode": true
         }
     ]
-}
+}

.vscode/settings.json

@@ -5,11 +5,12 @@
         "highscore",
         "highscores",
         "imcompiling",
+        "iterrows",
         "nextcord",
         "ondelete"
     ],
     "python.analysis.diagnosticSeverityOverrides": {
-        "reportOptionalMemberAccess": false,
+        "reportOptionalMemberAccess": "warning",
         "reportArgumentType": "information",
         "reportAttributeAccessIssue": "warning"
     }

Dockerfile

@@ -1,15 +1,15 @@
 FROM python:3.12.3-slim
 
 # install uv
-COPY --from=ghcr.io/astral-sh/uv:0.6.2 /uv /uvx /bin/
+COPY --from=ghcr.io/astral-sh/uv:0.6.6 /uv /uvx /bin/
 
 RUN apt-get update && apt-get -y upgrade && apt-get -y install sqlite3
 
 # Copy project to image
-ADD . /agon
+ADD . /home
 
 # Sync the project into a new environment, using the frozen lockfile
-WORKDIR /agon
+WORKDIR /home
 RUN uv sync --frozen --no-dev
 
-CMD ["uv", "run", "./main.py"]
+CMD ["uv", "run", "--frozen", "--no-dev", "-m", "agon"]

agon/__init__.py

@@ -0,0 +1 @@
+"""Empty init file for off_cooldown_bot module."""

agon/__main__.py

@@ -0,0 +1,14 @@
+"""Starts the app for agon."""
+
+import logging
+
+from .app import run
+
+nextcord_logger = logging.getLogger("nextcord")
+nextcord_logger.setLevel(logging.DEBUG)
+nextcord_handler = logging.FileHandler(filename="nextcord.log", encoding="utf-8", mode="w")
+nextcord_handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s"))
+nextcord_logger.addHandler(nextcord_handler)
+
+if __name__ == "__main__":
+    run()

agon/app.py

@@ -0,0 +1,42 @@
+"""Main file for Agon bot."""
+
+import pathlib
+import sys
+
+import nextcord
+from nextcord.ext import commands
+
+from . import config
+from .logger import agon_logger
+
+
+def run() -> None:
+    """Main function for bot."""
+    min_python_version = (3, 12)
+    if sys.version_info < min_python_version:
+        agon_logger.error("ERROR: Python version must be >= 3.12")
+        sys.exit()
+
+    # Allows privileged intents for monitoring members joining, roles editing, and role assignments
+    # These need to be enabled in the developer portal as well
+    intents = nextcord.Intents.default()
+
+    bot = commands.Bot(
+        commands.when_mentioned_or(config.BOT_PREFIX),
+        intents=intents,
+    )
+
+    # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
+    for folder in pathlib.Path("./agon/cogs").iterdir():
+        bot.load_extension(f"agon.cogs.{folder.name}")
+
+    @bot.listen()
+    async def on_ready() -> None:
+        """When Discord is connected."""
+        if bot.user is None:
+            agon_logger.error("Discord connection failed.")
+            return
+        agon_logger.info("%s has connected to Discord!", bot.user.name)
+
+    # Run Discord bot
+    bot.run(config.DISCORD_TOKEN)

agon/cogs/commands/__init__.py

@@ -2,14 +2,15 @@
 
 from nextcord.ext import commands
 
-from .create import CreateCog
-from .delete import DeleteCog
-from .help import HelpCog
-from .refresh import RefreshCog
-from .set import SetCog
-from .submission import SubmissionCog
-from .update import UpdateCog
-from .view import ViewCog
+from agon.cogs.commands.create import CreateCog
+from agon.cogs.commands.delete import DeleteCog
+from agon.cogs.commands.get import GetCog
+from agon.cogs.commands.help import HelpCog
+from agon.cogs.commands.refresh import RefreshCog
+from agon.cogs.commands.set import SetCog
+from agon.cogs.commands.submission import SubmissionCog
+from agon.cogs.commands.update import UpdateCog
+from agon.cogs.commands.view import ViewCog
 
 
 # This function will be called when this extension is loaded.
@@ -18,6 +19,7 @@ def setup(bot: commands.Bot) -> None:
     """Adds all command classes to bot."""
     bot.add_cog(CreateCog(bot))
     bot.add_cog(DeleteCog())
+    bot.add_cog(GetCog())
     bot.add_cog(HelpCog())
     bot.add_cog(RefreshCog(bot))
     bot.add_cog(SetCog())

agon/cogs/commands/create.py

@@ -6,9 +6,9 @@ from sqlalchemy import exc, select
 from sqlalchemy.orm import Session
 from sqlmodel import col
 
-from database.db import engine
-from database.models import Category, CategoryGroup
-from utilities.utils import MAX_LINE_LENGTH, autofill_groups, send_highscore_message
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup
+from agon.utils import MAX_LINE_LENGTH, autofill_groups, send_highscore_message
 
 
 class CreateCog(commands.Cog, name="Create Cog"):
@@ -99,7 +99,7 @@ class CreateCog(commands.Cog, name="Create Cog"):
             min_value=1,
             max_value=30,
         ),
-        channel: nextcord.TextChannel | None = nextcord.SlashOption(
+        channel: nextcord.TextChannel | nextcord.Thread | None = nextcord.SlashOption(
             description="Channel to post Group in. If left empty, defaults to current channel.",
             required=False,
             default=None,

agon/cogs/commands/delete.py

@@ -6,9 +6,9 @@ from sqlalchemy import distinct, select
 from sqlalchemy.orm import Session
 from sqlmodel import col
 
-from database.db import engine
-from database.models import Category, CategoryGroup, Score
-from utilities.utils import (
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup, Score
+from agon.utils import (
     autofill_categories,
     autofill_groups,
     autofill_users_in_group_category,
@@ -37,7 +37,7 @@ class DeleteCog(commands.Cog, name="Delete Cog"):
     async def channel_messages(
         self,
         interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel | None = nextcord.SlashOption(
+        channel: nextcord.TextChannel | nextcord.Thread | None = nextcord.SlashOption(
             description="Channel to clear of messages.",
             required=False,
             default=None,
@@ -54,7 +54,7 @@ class DeleteCog(commands.Cog, name="Delete Cog"):
                 Is a SlashOption. Limited to text channels. Defaults to None.
         """
         if not channel:
-            if isinstance(interaction.channel, nextcord.TextChannel):
+            if isinstance(interaction.channel, nextcord.TextChannel | nextcord.Thread):
                 channel = interaction.channel
             else:
                 # This should never happen.

agon/cogs/commands/get.py

@@ -0,0 +1,199 @@
+"""Get command hierarchy."""
+
+import nextcord
+from nextcord.ext import commands
+from sqlmodel import Session, col, select
+
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup
+from agon.utils import autofill_categories, autofill_groups
+
+
+class GetCog(commands.Cog, name="Get command."):
+    """Class holds commands for setting variables in guild's database."""
+
+    def __init__(self) -> None:
+        """Default constructor for SetCog class. Does nothing."""
+
+    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
+    async def get(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for getting. Never called."""
+
+    @get.subcommand(description="Commands for getting category information.")
+    async def category(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash subcommand for getting category information. Never called."""
+
+    @category.subcommand(description="Get whether a category is sorted in ascending or descending order.")
+    async def is_ascending(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        category_id: str = nextcord.SlashOption(
+            name="category", description="Category to information from.", required=True
+        ),
+    ) -> None:
+        """
+        Command to view how a category is sorted.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
+            category_id (str): String representation of Category id to get information from. Is SlashOption.
+        """
+        stmt = (
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
+        )
+
+        with Session(engine) as session:
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group or Category was not found.", ephemeral=True)
+                return
+
+            await interaction.response.send_message(
+                f"**{category.name}** is sorted in **{'ascending' if category.is_ascending else 'descending'}** order.",
+                ephemeral=True,
+            )
+
+    @category.subcommand(description="Get whether a category required validation.")
+    async def is_validated(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        category_id: str = nextcord.SlashOption(
+            name="category", description="Category to information from.", required=True
+        ),
+    ) -> None:
+        """
+        Command to view if a category required photo validation.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
+            category_id (str): String representation of Category id to get information from. Is SlashOption.
+        """
+        stmt = (
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
+        )
+
+        with Session(engine) as session:
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group or Category was not found.", ephemeral=True)
+                return
+
+            await interaction.response.send_message(
+                f"{category.name} does {'not ' if not category.is_validated else ''} require validation.",
+                ephemeral=True,
+            )
+
+    @category.subcommand(description="Get the size for a category.")
+    async def size(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        category_id: str = nextcord.SlashOption(name="category", description="Category to get size of.", required=True),
+    ) -> None:
+        """
+        Command to view a category's size.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
+            category_id (str): String representation of Category id to get information from. Is SlashOption.
+        """
+        stmt = (
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
+        )
+
+        with Session(engine) as session:
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group or Category was not found.", ephemeral=True)
+                return
+
+            await interaction.response.send_message(
+                f"**{category.name}** has a size of **{category.size}**.", ephemeral=True
+            )
+
+    @get.subcommand(description="Commands for getting group information.")
+    async def group(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash subcommand for getting group information. Never called."""
+
+    @group.subcommand(description="Get the pad length of a group.")
+    async def pad_length(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to get pad length of.", required=True),
+    ) -> None:
+        """
+        Command to view a group's pad length.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
+        """
+        stmt = select(CategoryGroup).where(col(CategoryGroup.id) == int(group_id))
+
+        with Session(engine) as session:
+            if (group := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group was not found.", ephemeral=True)
+                return
+
+            await interaction.response.send_message(
+                f"**{group.name}** has a pad length of **{group.pad_length}**.", ephemeral=True
+            )
+
+    @group.subcommand(description="Get the username length of a group.")
+    async def username_length(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(
+            name="group", description="Group to get username length of.", required=True
+        ),
+    ) -> None:
+        """
+        Command to view a group's username length.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
+        """
+        stmt = select(CategoryGroup).where(col(CategoryGroup.id) == int(group_id))
+
+        with Session(engine) as session:
+            if (group := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group was not found.", ephemeral=True)
+                return
+
+            await interaction.response.send_message(
+                f"**{group.name}** has a username length of **{group.username_length}**.", ephemeral=True
+            )
+
+    @is_ascending.on_autocomplete("category_id")
+    @is_validated.on_autocomplete("category_id")
+    @size.on_autocomplete("category_id")
+    async def category_autocomplete(self, interaction: nextcord.Interaction, category_id: str, group_id: str) -> None:
+        """
+        Autocomplete function for category names.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            category_id (str): String to be autocompleted with Category name.
+            group_id (str): Group to find Category from.
+        """
+        await interaction.response.send_autocomplete(
+            autofill_categories(interaction.guild_id, int(group_id), category_id)
+        )
+
+    @is_ascending.on_autocomplete("group_id")
+    @is_validated.on_autocomplete("group_id")
+    @pad_length.on_autocomplete("group_id")
+    @size.on_autocomplete("group_id")
+    @username_length.on_autocomplete("group_id")
+    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str) -> None:
+        """
+        Sends results from autofill_groups back to group_output_channel for autocompletion of group_id.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            group_id (str): String to run autocompletion against.
+        """
+        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))

agon/cogs/commands/help.py

@@ -11,7 +11,7 @@ class HelpCog(commands.Cog, name="Help commands."):
         """Default constructor for HelpCog class. Does nothing."""
 
     @nextcord.slash_command()
-    async def help(self, interaction: nextcord.Interaction):
+    async def help(self, interaction: nextcord.Interaction) -> None:
         """Parent slash command for help. Never called."""
 
     @help.subcommand(description="Describes how to get started with Agon.")

agon/cogs/commands/refresh.py

@@ -1,14 +1,14 @@
-"""
-Commands for refreshing highscore messages.
-"""
+"""Commands for refreshing highscore messages."""
 
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
 from sqlalchemy.orm import Session
+from sqlmodel import col
 
-from database.db import CategoryGroup, engine
-from utilities.utils import autofill_groups, send_highscore_message
+from agon.database.db import engine
+from agon.database.models import CategoryGroup
+from agon.utils import autofill_groups, send_highscore_message
 
 
 class RefreshCog(commands.Cog, name="Refresh Cog"):
@@ -43,13 +43,13 @@ class RefreshCog(commands.Cog, name="Refresh Cog"):
         with Session(engine) as session:
             stmt = (
                 select(CategoryGroup)
-                .where(CategoryGroup.GuildId == interaction.guild_id)
-                .where(CategoryGroup.GroupId == int(group_id))
+                .where(col(CategoryGroup.guild_id) == interaction.guild_id)
+                .where(col(CategoryGroup.id) == int(group_id))
             )
             group = session.scalar(stmt)
 
             await send_highscore_message(session, interaction.guild, group)
-            await interaction.response.send_message(f"Updated group {group.GroupName}!", ephemeral=True)
+            await interaction.response.send_message(f"Updated group {group.name}!", ephemeral=True)
 
     @refresh.subcommand()
     async def all(self, interaction: nextcord.Interaction) -> None:
@@ -67,7 +67,7 @@ class RefreshCog(commands.Cog, name="Refresh Cog"):
             interaction (nextcord.Interaction): Interaction that invoked the command.
         """
         with Session(engine) as session:
-            stmt = select(CategoryGroup).where(CategoryGroup.GuildId == interaction.guild_id)
+            stmt = select(CategoryGroup).where(col(CategoryGroup.guild_id) == interaction.guild_id)
 
             # awaiting response because posting scores takes a while
             await interaction.response.defer(ephemeral=True)

agon/cogs/commands/set.py

@@ -0,0 +1,442 @@
+"""Set command hierarchy."""
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from sqlmodel import col
+
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup, Guild
+from agon.logger import agon_logger
+from agon.utils import MAX_LINE_LENGTH, autofill_categories, autofill_groups, send_highscore_message
+
+
+class SetCog(commands.Cog, name="Set command."):
+    """Class holds commands for setting variables in guild's database."""
+
+    def __init__(self) -> None:
+        """Default constructor for SetCog class. Does nothing."""
+
+    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
+    async def set(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for setting settings. Never called."""
+
+    @set.subcommand(description="Commands for editing a category.")
+    async def category(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash subcommand for setting category settings. Never called."""
+
+    @category.subcommand(description="Update the number of entries to show for a category.", name="size")
+    async def category_size(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        category_id: str = nextcord.SlashOption(
+            name="category", description="Category to update size of.", required=True
+        ),
+        size: int = nextcord.SlashOption(description="Number of entries to show for the category.", required=True),
+    ) -> None:
+        """
+        Command to update a category's size.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            category_id (str): String representation of Category id to register channel to. Is SlashOption.
+            size (int): Size to set. Is SlashOption.
+        """
+        stmt = (
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
+        )
+
+        with Session(engine) as session:
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
+                return
+            category.size = size
+            session.commit()
+
+            # Use the relationship to get group category is in.
+            if (group := category.category_group) is None:
+                agon_logger.warning(f"{category.name}:{category.id} group relationship was None.")
+
+                stmt = select(CategoryGroup).where(col(CategoryGroup.id) == group_id)
+                if (group := session.scalar(stmt)) is None:
+                    await interaction.response.send_message("Group was not found.", ephemeral=True)
+                    return
+
+            await send_highscore_message(session, interaction.guild, group)
+        await interaction.response.send_message(
+            f"**{category.name}** size has been updated to **{size}**.", ephemeral=True
+        )
+
+    @category.subcommand(description="Update the is_ascending value for a category.")
+    async def is_ascending(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        category_id: str = nextcord.SlashOption(
+            name="category", description="Category to update is_ascending of.", required=True
+        ),
+        ascending: bool = nextcord.SlashOption(  # noqa: FBT001
+            description="Whether the scores are sorted ascending or not.", required=True
+        ),
+    ) -> None:
+        """
+        Command to update a category's is_ascending boolean.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            category_id (str): String representation of Category id to register channel to. Is SlashOption.
+            ascending (bool): Boolean to set. Determines whether scores are sorted ascending or not. Is SlashOption.
+        """
+        stmt = (
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
+        )
+
+        with Session(engine) as session:
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
+                return
+            category.is_ascending = ascending
+            session.commit()
+
+            # Use the relationship to get group category is in.
+            if (group := category.category_group) is None:
+                agon_logger.warning(f"{category.name}:{category.id} group relationship was None.")
+
+                stmt = select(CategoryGroup).where(col(CategoryGroup.id) == group_id)
+                if (group := session.scalar(stmt)) is None:
+                    await interaction.response.send_message("Group was not found.", ephemeral=True)
+                    return
+
+            await send_highscore_message(session, interaction.guild, group)
+        await interaction.response.send_message(
+            f"**{category.name}** is_ascending has been updated to **{ascending}**.", ephemeral=True
+        )
+
+    @category.subcommand(description="Update the is_validated value for a category.")
+    async def is_validated(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        category_id: str = nextcord.SlashOption(
+            name="category", description="Category to update is_ascending of.", required=True
+        ),
+        validated: bool = nextcord.SlashOption(  # noqa: FBT001
+            description="Whether the scores need to be validated.", required=True
+        ),
+    ) -> None:
+        """
+        Command to update a category's is_validated boolean.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            category_id (str): String representation of Category id to register channel to. Is SlashOption.
+            validated (bool): Boolean to set. Determines whether scores are validated or not. Is SlashOption.
+        """
+        stmt = (
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
+        )
+
+        with Session(engine) as session:
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
+                return
+            category.is_validated = validated
+            session.commit()
+
+            await interaction.response.send_message(
+                f"**{category.name}** is_validated has been updated to **{validated}**.", ephemeral=True
+            )
+
+    @category.subcommand(name="name", description="Change the name of a category.")
+    async def category_name(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        category_id: str = nextcord.SlashOption(
+            name="category", description="Category to update the name of.", required=True
+        ),
+        name: str = nextcord.SlashOption(description="Name to update to.", required=True, min_length=1, max_length=30),
+    ) -> None:
+        """
+        Command to update a category's name.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            category_id (str): String representation of Category id to register channel to. Is SlashOption.
+            name (str): The name to update the category's name to. Is SlashOption.
+        """
+        stmt = (
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
+        )
+
+        with Session(engine) as session:
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
+                return
+            old_name = category.name
+            category.name = name
+            session.commit()
+
+            # Use the relationship to get group category is in.
+            if (group := category.category_group) is None:
+                agon_logger.warning(f"{category.name}:{category.id} group relationship was None.")
+
+                stmt = select(CategoryGroup).where(col(CategoryGroup.id) == group_id)
+                if (group := session.scalar(stmt)) is None:
+                    await interaction.response.send_message("Group was not found.", ephemeral=True)
+                    return
+
+            await send_highscore_message(session, interaction.guild, group)
+        await interaction.response.send_message(
+            f"**{old_name}** has been updated to **{category.name}**.", ephemeral=True
+        )
+
+    @set.subcommand(description="Commands for editing a group.")
+    async def group(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash subcommand for setting group settings. Never called."""
+
+    @group.subcommand(name="name", description="Change the name of a Group.")
+    async def group_name(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group that Category is in.", required=True),
+        name: str = nextcord.SlashOption(description="Name to update to.", required=True, min_length=1, max_length=50),
+    ) -> None:
+        """
+        Command to update a group's name.
+
+        Args:
+            interaction (nextcord.Interaction):  Interaction that invoked the command.
+            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            name (str): The name to update the group's name to. Is SlashOption.
+        """
+        stmt = select(CategoryGroup).where(col(CategoryGroup.id) == int(group_id))
+
+        with Session(engine) as session:
+            if (group := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group was not found.", ephemeral=True)
+                return
+            old_name = group.name
+            group.name = name
+            # session.add(group) test if this is needed. SQLAlchemy can do the update without adding.
+            session.commit()
+
+            await send_highscore_message(session, interaction.guild, group)
+        await interaction.response.send_message(f"**{old_name}** has been updated to **{group.name}**.", ephemeral=True)
+
+    @group.subcommand(description="Registers the channel for a Group's messages.")
+    async def output_channel(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to assign to channel.", required=True),
+        channel: nextcord.abc.GuildChannel | None = nextcord.SlashOption(
+            description="Channel to register",
+            required=False,
+            channel_types=[nextcord.ChannelType.text],
+            default=None,
+        ),
+    ) -> None:
+        """
+        Command function to register a CategoryGroup's output channel.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            channel (nextcord.abc.GuildChannel, optional): Channel to register.
+                Is a SlashOption. Limited to text channels, Defaults to None.
+        """
+        channel_id = interaction.channel.id if not channel else channel.id
+
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(col(CategoryGroup.guild_id) == interaction.guild_id)
+                .where(col(CategoryGroup.id) == int(group_id))
+            )
+            if (group := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group or Category was not found.", ephemeral=True)
+                return
+            group.channel_id = channel_id
+            session.commit()
+            # TODO(imcompiling): delete the message and call send_highscore_message to send a new one. Bug needs fixed
+            # first.
+            # 082
+        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
+
+    @group.subcommand(
+        description="Set character length for a category. Can cut off username/score. Affects all categories."
+    )
+    async def pad_length(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(name="group", description="Group to assign pad length to.", required=True),
+        length: int = nextcord.SlashOption(
+            description="Number of characters alloted to a category.",
+            required=True,
+            default=26,
+            min_value=7,
+            max_value=MAX_LINE_LENGTH,
+        ),
+    ) -> None:
+        """
+        Changes guild's category pad length.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            group_id (str): String representation of Group id to set pad length in. Is SlashOption.
+            length (int): Number of characters. Is SlashOption. Defaults to 26.
+        """
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(col(CategoryGroup.guild_id) == interaction.guild_id)
+                .where(col(CategoryGroup.id) == int(group_id))
+            )
+            if (group := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group was not found.", ephemeral=True)
+                return
+
+            group.pad_length = length
+            session.commit()
+            await interaction.response.send_message(
+                f"Category pad length set to **{length}** for **{group.name}**.", ephemeral=True
+            )
+            await send_highscore_message(session, interaction.guild, group)
+
+    @group.subcommand(
+        description="Registers the channel for submission messages. Currently this information is deprecated."
+    )
+    async def submission_channel(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.abc.GuildChannel | None = nextcord.SlashOption(
+            description="Channel to register",
+            required=False,
+            channel_types=[nextcord.ChannelType.text],
+            default=None,
+        ),
+    ) -> None:
+        """
+        Command function to register the submission message channel.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            channel (nextcord.abc.GuildChannel): Channel to register
+                Is a SlashOption. Limited to text channels, Defaults to None.
+        """
+        channel_id = interaction.channel.id if not channel else channel.id
+
+        with Session(engine) as session:
+            stmt = select(Guild).where(col(Guild.id) == interaction.guild_id)
+            if (guild := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Guild was not found.", ephemeral=True)
+                return
+            guild.submission_channel = channel_id
+            session.commit()
+        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
+
+    @group.subcommand(description="Set username length for a Group of Categories.")
+    async def username_length(
+        self,
+        interaction: nextcord.Interaction,
+        group_id: str = nextcord.SlashOption(
+            name="group", description="Group to change username length of.", required=True
+        ),
+        length: int = nextcord.SlashOption(
+            description="Number of characters.", required=True, default=12, min_value=1, max_value=30
+        ),
+    ) -> None:
+        """
+        Changes guild's username length limit.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            group_id (str): String representation of Group id to set username length in. Is SlashOption.
+            length (int): Number of characters. Is SlashOption. Defaults to 12.
+        """
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(col(CategoryGroup.guild_id) == interaction.guild_id)
+                .where(col(CategoryGroup.id) == int(group_id))
+            )
+            if (group := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Group or Category was not found.", ephemeral=True)
+                return
+
+            group.username_length = length
+            session.commit()
+        await interaction.response.send_message(
+            f"Username length for **{group.name}** set to **{length}**.", ephemeral=True
+        )
+
+    @set.subcommand(description="Registers the channel for verification messages.")
+    async def verify_channel(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.abc.GuildChannel | None = nextcord.SlashOption(
+            description="Channel to register",
+            required=False,
+            channel_types=[nextcord.ChannelType.text],
+            default=None,
+        ),
+    ) -> None:
+        """
+        Command function to register the verification message channel.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command
+            channel (Optional[nextcord.abc.GuildChannel]): Channel to register
+                Is a SlashOption. Limited to text channels, Defaults to None.
+        """
+        channel_id = interaction.channel.id if not channel else channel.id
+
+        with Session(engine) as session:
+            stmt = select(Guild).where(col(Guild.id) == interaction.guild_id)
+            if (guild := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Guild was not found.", ephemeral=True)
+                return
+            guild.verification_channel = channel_id
+            session.commit()
+        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
+
+    @category_name.on_autocomplete("category_id")
+    @category_size.on_autocomplete("category_id")
+    @is_ascending.on_autocomplete("category_id")
+    @is_validated.on_autocomplete("category_id")
+    async def category_autocomplete(self, interaction: nextcord.Interaction, category_id: str, group_id: str) -> None:
+        """
+        Autocomplete function for category names.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            category_id (str): String to be autocompleted with Category name.
+            group_id (str): Group to find Category from.
+        """
+        await interaction.response.send_autocomplete(
+            autofill_categories(interaction.guild_id, int(group_id), category_id)
+        )
+
+    @category_name.on_autocomplete("group_id")
+    @category_size.on_autocomplete("group_id")
+    @group_name.on_autocomplete("group_id")
+    @is_ascending.on_autocomplete("group_id")
+    @is_validated.on_autocomplete("group_id")
+    @output_channel.on_autocomplete("group_id")
+    @pad_length.on_autocomplete("group_id")
+    @username_length.on_autocomplete("group_id")
+    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str) -> None:
+        """
+        Sends results from autofill_groups back to group_output_channel for autocompletion of group_id.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            group_id (str): String to run autocompletion against.
+        """
+        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))

agon/cogs/commands/submission.py

@@ -6,11 +6,13 @@ import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
 from sqlalchemy.orm import Session
+from sqlmodel import col
 
-from cogs.submission.verification_view import VerificationView
-from database.db import Category, CategoryGroup, Guild, Submission, engine
-from main import logger
-from utilities.utils import autofill_categories, autofill_groups, submit_score
+from agon.cogs.submission.verification_view import VerificationView
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup, Guild, Submission
+from agon.logger import agon_logger
+from agon.utils import autofill_categories, autofill_groups, submit_score
 
 
 class SubmissionCog(commands.Cog):
@@ -19,8 +21,10 @@ class SubmissionCog(commands.Cog):
     def __init__(self) -> None:
         return
 
+    # TODO(imcompiling): fix too many return statements when reworking command.
+    # https://gitea.cheezers.org/imcompiling/agon/issues/76
     @nextcord.slash_command()
-    async def submit(  # noqa: PLR0913
+    async def submit(  # noqa: PLR0911, PLR0913
         self,
         interaction: nextcord.Interaction,
         group_id: str = nextcord.SlashOption(name="group", required=True, description="Group to submit score to."),
@@ -56,46 +60,52 @@ class SubmissionCog(commands.Cog):
 
         with Session(engine) as session:
             stmt = (
-                select(Category).where(Category.GroupId == int(group_id)).where(Category.CategoryId == int(category_id))
+                select(Category)
+                .where(col(Category.group_id) == int(group_id))
+                .where(col(Category.id) == int(category_id))
             )
-
-            category: Category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
+                await interaction.response.send_message("Category not found.", ephemeral=True)
+                return
 
             # check if verification is required. if no picture, deny
-            if category.IsValidated and proof is None:
+            if category.is_validated and proof is None:
                 await interaction.response.send_message(
                     "This category required verification. Please attach a picture and re-submit.", ephemeral=True
                 )
                 return
 
             # check with regex if score is in correct format
-            verified_score = await self.verify_score(interaction, score, is_time_record=category.IsTimeRecord)
-
             # check if verify_score was successful. It replies with corrections required itself.
-            if verified_score is None:
+            if (
+                verified_score := await self.verify_score(interaction, score, is_time_record=category.is_time_record)
+            ) is None:
+                # This response message will be filled out better once command is split up to
+                # know which type it expects...
+                await interaction.response.send_message("Format was incorrect.", ephemeral=True)
                 return
 
             # Create submission verification request or submit score if verification not needed.
-            if not category.IsValidated:
+            if not category.is_validated:
                 await submit_score(interaction, int(group_id), int(category_id), username, verified_score)
                 await interaction.response.send_message("Score has been submitted!", ephemeral=True)
                 return
 
-            stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
-            verification_channel_id: int = session.scalar(stmt).VerificationChannel
+            stmt = select(col(Guild.verification_channel)).where(col(Guild.id) == interaction.guild_id)
 
-            channel = interaction.guild.get_channel(verification_channel_id)
-
-            if channel is None:
-                error_response = (
-                    "Registered Verification channel does not exist or was never registered. Contact server admins."
-                )
+            if (verification_channel_id := session.scalar(stmt)) is None:
+                error_response = "No verification channel was registered. Contact server admins."
                 await interaction.response.send_message(error_response, ephemeral=True)
                 return
 
-            if not isinstance(channel, nextcord.TextChannel):
+            if (channel := interaction.guild.get_channel(verification_channel_id)) is None:
+                error_response = "Registered Verification channel does not exist. Contact server admins."
+                await interaction.response.send_message(error_response, ephemeral=True)
+                return
+
+            if not isinstance(channel, nextcord.TextChannel | nextcord.Thread):
                 await interaction.response.send_message("An error happened with submission.")
-                logger.error(
+                agon_logger.error(
                     "Channel id %s in guild %s is does not correspond to a TextChannel.", channel.id, channel.guild.id
                 )
                 return
@@ -111,13 +121,13 @@ class SubmissionCog(commands.Cog):
 
             # Save the submission data for later use.
             submission: Submission = Submission(
-                CategoryId=category_id,
-                GroupId=group_id,
-                GuildId=interaction.guild_id,
-                MessageId=verification_message.id,
-                Score=verified_score,
-                UserId=interaction.user.id,
-                UserName=username,
+                category_id=int(category_id),
+                group_id=int(group_id),
+                guild_id=interaction.guild_id,
+                message_id=verification_message.id,
+                score=verified_score,
+                user_id=interaction.user.id,
+                username=username,
             )
 
             session.add(submission)
@@ -151,15 +161,15 @@ class SubmissionCog(commands.Cog):
 
         # Get group name from database
         stmt = (
-            select(CategoryGroup.GroupName)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.GroupId == group_id)
+            select(col(CategoryGroup.name))
+            .where(col(CategoryGroup.guild_id) == interaction.guild_id)
+            .where(col(CategoryGroup.id) == group_id)
         )
         embed.add_field(name="Group", value=session.scalar(stmt), inline=False)
 
         # Get category name from database
         stmt = (
-            select(Category.CategoryName).where(Category.GroupId == group_id).where(Category.CategoryId == category_id)
+            select(col(Category.name)).where(col(Category.group_id) == group_id).where(col(Category.id) == category_id)
         )
         embed.add_field(name="Category", value=session.scalar(stmt), inline=False)
         embed.add_field(name="Score", value=score, inline=False)

agon/cogs/commands/update.py

@@ -1,22 +1,20 @@
-"""
-Commands for updating information/variables held in database.
-"""
+"""Commands for updating information/variables held in database."""
 
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
 from sqlalchemy.orm import Session
+from sqlmodel import col
 
-from database.db import Guild, engine
-from utilities.utils import autofill_users_in_guild
+from agon.database.db import engine
+from agon.database.models import Guild
+from agon.utils import autofill_users_in_guild
 
 from .views.update_username_verify import UpdateUsernameVerifyView
 
 
 class UpdateCog(commands.Cog, name="Update commands."):
-    """
-    Class holds commands and views needed for updating things in bot.
-    """
+    """Class holds commands and views needed for updating things in bot."""
 
     def __init__(self, bot: commands.Bot):
         """
@@ -28,17 +26,13 @@ class UpdateCog(commands.Cog, name="Update commands."):
         self._bot: commands.Bot = bot
 
     @commands.Cog.listener()
-    async def on_ready(self):
-        """
-        Called when cog is loaded. Adds views required for DataManagement commands.
-        """
+    async def on_ready(self) -> None:
+        """Called when cog is loaded. Adds views required for DataManagement commands."""
         self._bot.add_view(UpdateUsernameVerifyView())
 
     @nextcord.slash_command()
-    async def update(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for updating things. Never called.
-        """
+    async def update(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for updating things. Never called."""
 
     @update.subcommand(description="Request a username update. Admins must approve.")
     async def username(
@@ -46,10 +40,11 @@ class UpdateCog(commands.Cog, name="Update commands."):
         interaction: nextcord.Interaction,
         old_username: str = nextcord.SlashOption(description="Username currently stored in highscores.", required=True),
         new_username: str = nextcord.SlashOption(description="Username to update to.", required=True),
-    ):
+    ) -> None:
         """
-        Creates a request to send to admins for changing a username. Uses
-        UpdateUsernameVerifyView to do the work.
+        Creates a request to send to admins for changing a username.
+
+        Uses UpdateUsernameVerifyView to do the work.
 
         Args:
             interaction (nextcord.Interaction): Interaction that invoked the command
@@ -57,9 +52,13 @@ class UpdateCog(commands.Cog, name="Update commands."):
             new_username (str): Username to replace old with.
         """
         with Session(engine) as session:
-            stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
+            stmt = select(col(Guild.verification_channel)).where(col(Guild.id) == interaction.guild_id)
             verify_channel = interaction.guild.get_channel(session.scalar(stmt))
 
+        if not isinstance(verify_channel, nextcord.TextChannel):
+            await interaction.send("Verification channel not set. Cannot process request.", ephemeral=True)
+            return
+
         embed: nextcord.Embed = nextcord.Embed(title="Username change request.")
         embed.add_field(name="Old Username", value=old_username)
         embed.add_field(name="New Username", value=new_username)
@@ -71,12 +70,12 @@ class UpdateCog(commands.Cog, name="Update commands."):
         await interaction.send("Request sent to admins for verification.", ephemeral=True)
 
     @username.on_autocomplete("old_username")
-    async def all_users_autocomplete(self, interaction: nextcord.Interaction, username: str):
+    async def all_users_autocomplete(self, interaction: nextcord.Interaction, username: str) -> None:
         """
         Sends response from autofill_users_in_guild back to update_username for autocompletion of old_username.
 
         Args:
             interaction (nextcord.Interaction): Interaction with command.
-            old_username (str): String to run autocompletion against.
+            username (str): String to run autocompletion against.
         """
         await interaction.response.send_autocomplete(autofill_users_in_guild(interaction.guild_id, username))

agon/cogs/commands/view.py

@@ -5,9 +5,11 @@ import pandas as pd
 from nextcord.ext import commands
 from sqlalchemy import select
 from sqlalchemy.orm import Session
+from sqlmodel import col
 
-from database.db import Category, CategoryGroup, Score, engine
-from utilities.utils import MAX_LINE_LENGTH, autofill_categories, autofill_groups, format_score_string
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup, Score
+from agon.utils import MAX_LINE_LENGTH, autofill_categories, autofill_groups, format_score_string
 
 
 class ViewCog(commands.Cog, name="View Command"):
@@ -46,17 +48,17 @@ class ViewCog(commands.Cog, name="View Command"):
 
         # get group, category, and all scores sorted correctly.
         with Session(engine) as session:
-            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
+            stmt = select(CategoryGroup).where(col(CategoryGroup.id) == int(group_id))
             group = session.scalar(stmt)
 
-            stmt = select(Category).where(Category.CategoryId == int(category_id))
+            stmt = select(Category).where(col(Category.id) == int(category_id))
             category = session.scalar(stmt)
 
             d_f = pd.read_sql_query(
-                sql=session.query(Score).where(Score.CategoryId == category_id).statement, con=engine
+                sql=session.query(Score).where(col(Score.category_id) == category_id).statement, con=engine
             )
 
-        scores = d_f.sort_values("Score", ascending=category.IsAscending).reset_index()
+        scores = d_f.sort_values("Score", ascending=category.is_ascending).reset_index()
 
         # get the longest string
         longest_str: int = scores.UserName.map(len).max()
@@ -67,13 +69,13 @@ class ViewCog(commands.Cog, name="View Command"):
                     row["UserName"],
                     row["Score"],
                     longest_str,
-                    category.IsTimeRecord,
+                    category.is_time_record,
                     i + 1,  # type: ignore[reportOperatorIssue]
                     MAX_LINE_LENGTH,
                 )
             )
 
-        message_str: str = f"**{group.GroupName} {category.CategoryName} Leaderboard!**\n```"
+        message_str: str = f"**{group.name} {category.name} Leaderboard!**\n```"
         if len(str_list) == 0:
             message_str += "No Submissions!"
         else:

agon/cogs/commands/views/delete_confirm.py

@@ -4,9 +4,9 @@ import nextcord
 from sqlalchemy import delete, select
 from sqlalchemy.orm import Session
 
-from database.db import engine
-from database.models import Category, CategoryGroup
-from utilities.utils import send_highscore_message
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup
+from agon.utils import send_highscore_message
 
 
 class DeleteConfirmView(nextcord.ui.Modal):
@@ -43,7 +43,7 @@ class DeleteConfirmView(nextcord.ui.Modal):
                 session.delete(group)
                 # delete the message related to group
                 channel = interaction.guild.get_channel(group.channel_id)
-                if not isinstance(channel, nextcord.TextChannel):
+                if not isinstance(channel, nextcord.TextChannel | nextcord.Thread):
                     return
                 message: nextcord.Message = await channel.fetch_message(group.message_id)
                 await message.delete()

agon/cogs/commands/views/update_username_verify.py

@@ -5,9 +5,9 @@ from sqlalchemy import distinct, exc, select
 from sqlalchemy.orm import Session
 from sqlmodel import col
 
-from database.db import engine
-from database.models import Category, CategoryGroup, Score
-from utilities.utils import send_highscore_message
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup, Score
+from agon.utils import send_highscore_message
 
 
 class UpdateUsernameVerifyView(nextcord.ui.View):

agon/cogs/guild_listener/__init__.py

@@ -6,8 +6,8 @@ from sqlalchemy import select
 from sqlalchemy.orm import Session
 from sqlmodel import col
 
-from database.db import engine
-from database.models import Guild
+from agon.database.db import engine
+from agon.database.models import Guild
 
 
 class GuildListener(commands.Cog, name="Guild Listener"):
@@ -26,10 +26,9 @@ class GuildListener(commands.Cog, name="Guild Listener"):
         """
         with Session(engine) as session:
             stmt = select(Guild).where(col(Guild.id == guild.id))
-            guild_data = session.scalar(stmt)
 
             # just in case check if the guild already exists
-            if guild_data is None:
+            if (guild_data := session.scalar(stmt)) is None:
                 new_guild = Guild(id=guild.id, name=guild.name)
                 session.add(new_guild)
             else:

agon/cogs/loops/guild_data.py

@@ -5,8 +5,8 @@ from sqlalchemy import select
 from sqlalchemy.orm import Session
 from sqlmodel import col
 
-from database.db import engine
-from database.models import Guild
+from agon.database.db import engine
+from agon.database.models import Guild
 
 
 class GuildData(commands.Cog, name="Guild Data"):
@@ -31,7 +31,7 @@ class GuildData(commands.Cog, name="Guild Data"):
         with Session(engine) as session:
             for guild in self.bot.guilds:
                 # update given guild name for guild id
-                stmt = select(Guild).where(col(Guild.id == guild.id))
+                stmt = select(Guild).where(col(Guild.id) == guild.id)
                 guild_data = session.scalar(stmt)
 
                 # just in case checking if the guild doesn't exist.
@@ -39,6 +39,6 @@ class GuildData(commands.Cog, name="Guild Data"):
                     new_guild = Guild(id=guild.id, name=guild.name)
                     session.add(new_guild)
                 else:
-                    guild_data.GuildName = guild.name
+                    guild_data.name = guild.name
 
                 session.commit()

agon/cogs/submission/verification_view.py

@@ -5,9 +5,9 @@ from sqlalchemy import delete, select
 from sqlalchemy.orm import Session
 from sqlmodel import col
 
-from database.db import engine
-from database.models import Submission
-from utilities.utils import submit_score
+from agon.database.db import engine
+from agon.database.models import Submission
+from agon.utils import submit_score
 
 
 class VerificationView(nextcord.ui.View):
@@ -39,9 +39,7 @@ class VerificationView(nextcord.ui.View):
                 .where(col(Submission.message_id) == interaction.message.id)
             )
 
-            submission = session.scalar(stmt)
-
-            if submission is None:
+            if (submission := session.scalar(stmt)) is None:
                 await interaction.response.send_message("Could not find submission data in database.", ephemeral=True)
                 await interaction.message.delete()
                 return

agon/database/db.py

@@ -1,14 +1,18 @@
 """Simple file to set up the sqlmodel connection to database."""
 
 from sqlmodel import SQLModel, create_engine
-from utilities import config
+
+from agon import config
+from agon.logger import agon_logger
 
 from . import models  # noqa: F401 - Need this import for creating the models.
 
 if config.ENVIRONMENT == "prod":
     url = f"mysql+pymysql://{config.SQL_USER}:{config.SQL_PASS}@{config.SQL_HOST}/{config.SQL_DB}"
+    agon_logger.info("Connected to prod database.")
 else:
-    url = "sqlite:///database.db"
+    url = "sqlite:///database/database.db"
+    agon_logger.info("Connected to local dev database.")
 engine = create_engine(url)
 
 # Don't need to create all when connected to prod.

agon/logger.py

@@ -0,0 +1,10 @@
+"""Creates logger for Agon bot."""
+
+import logging
+import sys
+
+agon_logger = logging.getLogger("default")
+agon_logger.setLevel(logging.INFO)
+handler = logging.StreamHandler(sys.stdout)
+handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s"))
+agon_logger.addHandler(handler)

agon/utils.py

@@ -8,8 +8,9 @@ from sqlalchemy import distinct, select
 from sqlalchemy.orm import Session, aliased
 from sqlmodel import col
 
-from database.db import engine
-from database.models import Category, CategoryGroup, Guild, Score
+from agon.database.db import engine
+from agon.database.models import Category, CategoryGroup, Guild, Score
+from agon.logger import agon_logger
 
 MAX_LINE_LENGTH = 142
 
@@ -64,7 +65,7 @@ def autofill_groups(guild_id: int, group_begin: str) -> "dict[str, str]":
     """
     with Session(engine) as session:
         # Select all groups in guild.
-        stmt = select(CategoryGroup).wherecol((CategoryGroup.guild_id) == guild_id)
+        stmt = select(CategoryGroup).where(col(CategoryGroup.guild_id) == guild_id)
 
         # dict has to have key values of same type for discord.
         group_dict: dict[str, str] = {group.name: str(group.id) for group in session.scalars(stmt)}
@@ -275,6 +276,8 @@ def format_highscore_message(session: Session, group: CategoryGroup) -> str:
     return ret_string + "```"
 
 
+# TODO(imcompiling): rework into two functions to remove the boolean and reduce function arguments.
+# 084
 def format_score_string(
     username: str,
     score: float,
@@ -327,7 +330,7 @@ def get_time_str(time_in: float) -> str:
     return time.strftime(f"%-M:%S.{milliseconds}", time.gmtime(time_in))
 
 
-async def send_highscore_message(session: Session, guild: nextcord.Guild, group: CategoryGroup) -> nextcord.Message:
+async def send_highscore_message(session: Session, guild: nextcord.Guild, group: CategoryGroup) -> None:
     """
     Function takes care of checking if a message exists for a group.
 
@@ -337,23 +340,30 @@ async def send_highscore_message(session: Session, guild: nextcord.Guild, group:
         session (Session): The sqlalchemy session being used for this function call.
         guild (nextcord.Guild): the nextcord.Guild object requesting this message.
         group (CategoryGroup): group to post to the message.
-
-    Returns:
-        nextcord.Message: Message object that was posted with group contents.
     """
     highscore_string = format_highscore_message(session, group)
-    channel = guild.get_channel(group.channel_id)
+    if (channel := guild.get_channel_or_thread(group.channel_id)) is None:
+        agon_logger.error("Channel id %s in guild %s does not exist.", group.channel_id, guild.id)
+        return
+
+    if not isinstance(channel, nextcord.TextChannel | nextcord.Thread):
+        agon_logger.error(
+            "Channel id %s in guild %s is does not correspond to a TextChannel or Thread.", channel.id, channel.guild.id
+        )
+        return
 
     if group.message_id is None:
         # message doesn't exist.
         message: nextcord.Message = await channel.send(highscore_string)
-        group.MessageId = message.id
+        group.message_id = message.id
         session.commit()
     else:
+        # TODO(imcompiling): check what happens when message is deleted.
+        # https://gitea.cheezers.org/imcompiling/agon/issues/83
         message: nextcord.Message = await channel.fetch_message(group.message_id)
         await message.edit(content=highscore_string)
 
-    return message
+    return
 
 
 async def submit_score(
@@ -390,7 +400,7 @@ async def submit_score(
         existing_score = session.scalar(stmt)
 
         if existing_score:
-            existing_score.Score = score_f
+            existing_score.score = score_f
         else:
             score_obj = Score(username=username, score=score_f, category_id=category_id)
             session.add(score_obj)

cogs/commands/set.py

@@ -1,206 +0,0 @@
-"""
-Set command heirarchy.
-"""
-
-import nextcord
-from nextcord.ext import commands
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-
-from database.db import CategoryGroup, Guild, engine
-from utilities.utils import MAX_LINE_LENGTH, autofill_groups
-
-
-class SetCog(commands.Cog, name="Set command."):
-    """
-    Class holds commands for setting variables in guild's database.
-    """
-
-    def __init__(self) -> None:
-        """
-        Default constructor for SetCog class. Does nothing.
-        """
-
-    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
-    async def set(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for setting settings. Never called.
-        """
-
-    @set.subcommand(description="Registers the channel for a Category Group's messages.")
-    async def group_output_channel(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(
-            name="group", description="Category Group to assign to channel.", required=True
-        ),
-        channel: nextcord.abc.GuildChannel | None = nextcord.SlashOption(
-            description="Channel to register",
-            required=False,
-            channel_types=[nextcord.ChannelType.text],
-            default=None,
-        ),
-    ) -> None:
-        """
-        Command function to register a CategoryGroup's output channel.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-            group_id (str): String representation of Group id to register channel to. Is SlashOption.
-            channel (nextcord.abc.GuildChannel, optional): Channel to register
-                Is a SlashOption. Limited to text channels, Defaults to None.
-        """
-        if not channel:
-            channel = interaction.channel
-        channel_id = channel.id
-        with Session(engine) as session:
-            stmt = (
-                select(CategoryGroup)
-                .where(CategoryGroup.GuildId == interaction.guild_id)
-                .where(CategoryGroup.GroupId == int(group_id))
-            )
-            group = session.scalar(stmt)
-            group.ChannelId = channel_id
-            session.commit()
-        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
-
-    @set.subcommand(
-        description="Set character length for a category. Can cut off username/score. Affects all categories."
-    )
-    async def pad_length(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(
-            name="group", description="Category Group to assign pad length to.", required=True
-        ),
-        length: int = nextcord.SlashOption(
-            description="Number of characters alloted to a category.",
-            required=True,
-            default=26,
-            min_value=7,
-            max_value=MAX_LINE_LENGTH,
-        ),
-    ) -> None:
-        """
-        Changes guild's category pad length.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            group_id (str): String representation of Group id to set pad length in. Is SlashOption.
-            length (int): Number of characters. Is SlashOption. Defaults to 26.
-        """
-        with Session(engine) as session:
-            stmt = (
-                select(CategoryGroup)
-                .where(CategoryGroup.GuildId == interaction.guild_id)
-                .where(CategoryGroup.GroupId == int(group_id))
-            )
-            group = session.scalar(stmt)
-            group.PadLength = length
-            session.commit()
-            await interaction.response.send_message(
-                f"Category pad length set to {length} for {group.GroupName}", ephemeral=True
-            )
-
-    @set.subcommand(
-        description="Registers the channel for submission messages. Currently this information is deprecated."
-    )
-    async def submission_channel(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.abc.GuildChannel | None = nextcord.SlashOption(
-            description="Channel to register",
-            required=False,
-            channel_types=[nextcord.ChannelType.text],
-            default=None,
-        ),
-    ) -> None:
-        """
-        Command function to register the submission message channel.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            channel Optional[nextcord.abc.GuildChannel], optional): Channel to register
-                Is a SlashOption. Limited to text channels, Defaults to None.
-        """
-        if not channel:
-            channel = interaction.channel
-
-        with Session(engine) as session:
-            channel_id = channel.id
-            stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
-            guild = session.scalar(stmt)
-            guild.SubmissionChannel = channel_id
-            session.commit()
-        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
-
-    @set.subcommand(description="Set username length for a Group of Categories.")
-    async def username_length(
-        self,
-        interaction: nextcord.Interaction,
-        group_id: str = nextcord.SlashOption(
-            name="group", description="Group to change username length of.", required=True
-        ),
-        length: int = nextcord.SlashOption(
-            description="Number of characters.", required=True, default=12, min_value=1, max_value=30
-        ),
-    ) -> None:
-        """
-        Changes guild's username length limit.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            length (int): Number of characters. Is SlashOption. Defaults to 12.
-        """
-        with Session(engine) as session:
-            stmt = (
-                select(CategoryGroup)
-                .where(CategoryGroup.GuildId == interaction.guild_id)
-                .where(CategoryGroup.GroupId == int(group_id))
-            )
-            group = session.scalar(stmt)
-            group.UsernameLength = length
-            session.commit()
-        await interaction.response.send_message(f"Username length set to {length}.", ephemeral=True)
-
-    @set.subcommand(description="Registers the channel for verification messages.")
-    async def verify_channel(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.abc.GuildChannel | None = nextcord.SlashOption(
-            description="Channel to register",
-            required=False,
-            channel_types=[nextcord.ChannelType.text],
-            default=None,
-        ),
-    ) -> None:
-        """
-        Command function to register the verification message channel.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command
-            channel (Optional[nextcord.abc.GuildChannel]): Channel to register
-                Is a SlashOption. Limited to text channels, Defaults to None.
-        """
-        if not channel:
-            channel = interaction.channel
-        channel_id = channel.id
-        with Session(engine) as session:
-            stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
-            guild = session.scalar(stmt)
-            guild.VerificationChannel = channel_id
-            session.commit()
-        await interaction.send(f"Registered <#{channel_id}>.", ephemeral=True)
-
-    @group_output_channel.on_autocomplete("group_id")
-    @pad_length.on_autocomplete("group_id")
-    @username_length.on_autocomplete("group_id")
-    async def group_autocomplete(self, interaction: nextcord.Interaction, group_id: str):
-        """
-        Sends results from autofill_groups back to group_output_channel for autocompletion of group_id.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with command.
-            group_id (str): String to run autocompletion against.
-        """
-        await interaction.response.send_autocomplete(autofill_groups(interaction.guild_id, group_id))

database/database_test.py

@@ -1,40 +0,0 @@
-import os
-
-from dotenv import load_dotenv
-from sqlmodel import Session, SQLModel, create_engine, select
-
-from models import CategoryGroup, Guild
-
-load_dotenv()
-
-SQL_DB = os.getenv("SQL_DB", "")
-SQL_HOST = os.getenv("SQL_HOST", "")
-SQL_PASS = os.getenv("SQL_PASS", "")
-SQL_USER = os.getenv("SQL_USER", "")
-
-url = "sqlite:///database.db"
-# url = f"mysql+pymysql://{SQL_USER}:{SQL_PASS}@{SQL_HOST}/{SQL_DB}"
-engine = create_engine(url)
-SQLModel.metadata.create_all(engine)
-
-with Session(engine) as session:
-    guild = Guild(id=1, name="test guild")
-    session.add(guild)
-    group1 = CategoryGroup(name="group1", channel_id=1, guild_id=1, message_id=1)
-    group2 = CategoryGroup(name="group2", channel_id=2, guild_id=1, message_id=2)
-    session.add(group1)
-    session.add(group2)
-    session.commit()
-
-    # anotherone = Guild(id=2, name="test guild 2", submission_channel=1, verification_channel=2)
-    # session.add(anotherone)
-    # group1 = CategoryGroup(name="group1", channel_id=1, guild_id=2, message_id=1)
-    # group2 = CategoryGroup(name="group2", channel_id=2, guild_id=2, message_id=2)
-    # session.add(group1)
-    # session.add(group2)
-    # session.commit()
-
-    stmt = select(Guild).where(Guild.name == "Dakiny")
-    guild = session.scalar(stmt)
-
-    print(guild.category_groups)

database/pyproject.toml

@@ -1,7 +0,0 @@
-[tool.ruff]
-# Extend the `pyproject.toml` file in the parent directory...
-extend = "../pyproject.toml"
-
-[tool.ruff.lint]
-# ignore implicit-namespace-package in this directory.
-ignore = ["INP001"]

highscores_database.sql

@@ -1,56 +0,0 @@
-CREATE DATABASE highscores;
-use highscores;
-
-CREATE TABLE Guilds(
-   GuildId bigint unsigned not null unique,
-   GuildName varchar(95) not null,
-   SubmissionChannel bigint unsigned, -- deprecated, is not used anymore.
-   VerificationChannel bigint unsigned,
-   Active boolean DEFAULT true,
-   PRIMARY KEY (GuildId)
-);
-
-CREATE TABLE CategoryGroups(
-   GroupId int unsigned not null unique AUTO_INCREMENT,
-   GroupName varchar(50) not null,
-   ChannelId bigint unsigned,
-   GuildId bigint unsigned not null,
-   MessageId bigint unsigned,
-   PadLength smallint not null DEFAULT 26,
-   UsernameLength smallint DEFAULT 12,
-   CONSTRAINT UniqueGuildCategoryGroup UNIQUE (GuildId, GroupName),
-   FOREIGN KEY (GuildId) REFERENCES Guilds(GuildId) ON DELETE CASCADE,
-   PRIMARY KEY (GroupId)
-);
-
-CREATE TABLE Categories(
-   CategoryId int unsigned not null unique AUTO_INCREMENT,
-   CategoryName varchar(30) not null,
-   GroupId int unsigned not null,
-   Size smallint not null DEFAULT 3,
-   IsAscending boolean not null DEFAULT true,
-   IsTimeRecord boolean not null DEFAULT false,
-   IsValidated boolean not null DEFAULT true,
-   CONSTRAINT UniqueCategoryInGroup UNIQUE (GroupId, CategoryName),
-   FOREIGN KEY (GroupId) REFERENCES CategoryGroups(GroupId) ON DELETE CASCADE,
-   PRIMARY Key (CategoryId)
-);
-
-CREATE TABLE Scores(
-   UserName varchar(30) not null,
-   Score float not null, -- Maybe should have time and int scores?? timestamp type?
-   CategoryId int unsigned not null,
-   FOREIGN KEY (CategoryId) REFERENCES Categories(CategoryId) ON DELETE CASCADE,
-   PRIMARY KEY (CategoryId, UserName)
-);
-
-CREATE TABLE Submissions(
-   CategoryId int unsigned not null,
-   GroupId int unsigned not null,
-   GuildId bigint unsigned not null,
-   MessageId bigint unsigned not null,
-   Score varchar(30) not null, -- Score is stored as a string until converted during submission
-   UserId bigint unsigned not null,
-   UserName varchar(30) not null,
-   PRIMARY KEY (CategoryId, UserName) -- one submission a category per user.
-);

main.py

@@ -1,58 +0,0 @@
-"""Main file for Agon bot."""
-
-import logging
-import os
-import sys
-
-import nextcord
-from nextcord.ext import commands
-
-from utilities import config
-
-nextcord_logger = logging.getLogger("nextcord")
-nextcord_logger.setLevel(logging.DEBUG)
-nextcord_handler = logging.FileHandler(filename="nextcord.log", encoding="utf-8", mode="w")
-nextcord_handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s"))
-nextcord_logger.addHandler(nextcord_handler)
-
-logger = logging.getLogger("default")
-logger.setLevel(logging.INFO)
-handler = logging.StreamHandler(sys.stdout)
-handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s"))
-logger.addHandler(handler)
-
-
-def main() -> None:
-    """Main function for bot."""
-    min_python_version = (3, 12)
-    if sys.version_info < min_python_version:
-        logger.error("ERROR: Python version must be >= 3.12")
-        sys.exit()
-
-    # Allows privileged intents for monitoring members joining, roles editing, and role assignments
-    # These need to be enabled in the developer portal as well
-    intents = nextcord.Intents.default()
-
-    bot = commands.Bot(
-        commands.when_mentioned_or(config.BOT_PREFIX),
-        intents=intents,
-    )
-
-    # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
-    for folder in os.listdir("cogs"):
-        bot.load_extension(f"cogs.{folder}")
-
-    @bot.listen()
-    async def on_ready() -> None:
-        """When Discord is connected."""
-        if bot.user is None:
-            logger.error("Discord connection failed.")
-            return
-        logger.info("%s has connected to Discord!", bot.user.name)
-
-    # Run Discord bot
-    bot.run(config.DISCORD_TOKEN)
-
-
-if __name__ == "__main__":
-    main()

utilities/__init__.py

@@ -1 +0,0 @@
-"""Package of utility functions and environment configuration variables."""