Indent so that a command can properly use session.

Remove commented out code. Also add work to an issue.

.vscode/settings.json

@@ -10,7 +10,7 @@
         "ondelete"
     ],
     "python.analysis.diagnosticSeverityOverrides": {
-        "reportOptionalMemberAccess": false,
+        "reportOptionalMemberAccess": "warning",
         "reportArgumentType": "information",
         "reportAttributeAccessIssue": "warning"
     }

cogs/commands/get.py

@@ -37,21 +37,20 @@ class GetCog(commands.Cog, name="Get command."):
 
         Args:
             interaction (nextcord.Interaction):  Interaction that invoked the command.
-            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
-            category_id (str): String representation of Category id to register channel to. Is SlashOption.
+            category_id (str): String representation of Category id to get information from. Is SlashOption.
         """
         stmt = (
-            select(Category).where(col(CategoryGroup.id) == int(group_id)).where(col(Category.id) == int(category_id))
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
         )
 
         with Session(engine) as session:
-            category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
-            if category 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.",
+                f"**{category.name}** is sorted in **{'ascending' if category.is_ascending else 'descending'}** order.",
                 ephemeral=True,
             )
 
@@ -69,16 +68,15 @@ class GetCog(commands.Cog, name="Get command."):
 
         Args:
             interaction (nextcord.Interaction):  Interaction that invoked the command.
-            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
-            category_id (str): String representation of Category id to register channel to. Is SlashOption.
+            category_id (str): String representation of Category id to get information from. Is SlashOption.
         """
         stmt = (
-            select(Category).where(col(CategoryGroup.id) == int(group_id)).where(col(Category.id) == int(category_id))
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
         )
 
         with Session(engine) as session:
-            category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
-            if category is None:
                 await interaction.response.send_message("Group or Category was not found.", ephemeral=True)
                 return
 
@@ -99,25 +97,76 @@ class GetCog(commands.Cog, name="Get command."):
 
         Args:
             interaction (nextcord.Interaction):  Interaction that invoked the command.
-            group_id (str): String representation of Group id to register channel to. Is SlashOption.
+            group_id (str): String representation of Group id get information from. Is SlashOption.
-            category_id (str): String representation of Category id to register channel to. Is SlashOption.
+            category_id (str): String representation of Category id to get information from. Is SlashOption.
         """
         stmt = (
-            select(Category).where(col(CategoryGroup.id) == int(group_id)).where(col(Category.id) == int(category_id))
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
         )
 
         with Session(engine) as session:
-            category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
-            if category 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)
+            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")
@@ -136,7 +185,9 @@ class GetCog(commands.Cog, name="Get command."):
 
     @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.

cogs/commands/set.py

@@ -22,7 +22,7 @@ class SetCog(commands.Cog, name="Set command."):
     async def set(self, interaction: nextcord.Interaction) -> None:
         """Parent slash command for setting settings. Never called."""
 
-    @set.subcommand("Commands for editing a category.")
+    @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."""
 
@@ -46,31 +46,29 @@ class SetCog(commands.Cog, name="Set command."):
             size (int): Size to set. Is SlashOption.
         """
         stmt = (
-            select(Category).where(col(CategoryGroup.id) == int(group_id)).where(col(Category.id) == int(category_id))
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
         )
 
         with Session(engine) as session:
-            category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
-            if category is None:
                 await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
                 return
             category.size = size
-            # session.add(category) test if this is needed. SQLAlchemy can do the update without adding.
             session.commit()
 
             # Use the relationship to get group category is in.
-            group = category.category_group
+            if (group := category.category_group) is None:
-            if group is None:
                 agon_logger.warning(f"{category.name}:{category.id} group relationship was None.")
 
                 stmt = select(CategoryGroup).where(col(CategoryGroup.id) == group_id)
-                group = session.scalar(stmt)
+                if (group := session.scalar(stmt)) is None:
-                if group 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)
+        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(
@@ -94,32 +92,28 @@ class SetCog(commands.Cog, name="Set command."):
             ascending (bool): Boolean to set. Determines whether scores are sorted ascending or not. Is SlashOption.
         """
         stmt = (
-            select(Category).where(col(CategoryGroup.id) == int(group_id)).where(col(Category.id) == int(category_id))
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
         )
 
         with Session(engine) as session:
-            category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
-            if category is None:
                 await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
                 return
             category.is_ascending = ascending
-            # session.add(category) test if this is needed. SQLAlchemy can do the update without adding.
             session.commit()
 
             # Use the relationship to get group category is in.
-            group = category.category_group
+            if (group := category.category_group) is None:
-            if group is None:
                 agon_logger.warning(f"{category.name}:{category.id} group relationship was None.")
 
                 stmt = select(CategoryGroup).where(col(CategoryGroup.id) == group_id)
-                group = session.scalar(stmt)
+                if (group := session.scalar(stmt)) is None:
-                if group 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
+            f"**{category.name}** is_ascending has been updated to **{ascending}**.", ephemeral=True
         )
 
     @category.subcommand(description="Update the is_validated value for a category.")
@@ -144,31 +138,18 @@ class SetCog(commands.Cog, name="Set command."):
             validated (bool): Boolean to set. Determines whether scores are validated or not. Is SlashOption.
         """
         stmt = (
-            select(Category).where(col(CategoryGroup.id) == int(group_id)).where(col(Category.id) == int(category_id))
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
         )
 
         with Session(engine) as session:
-            category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
-            if category is None:
                 await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
                 return
             category.is_validated = validated
-            # session.add(category) test if this is needed. SQLAlchemy can do the update without adding.
             session.commit()
 
-            # Use the relationship to get group category is in.
-            group = category.category_group
-            if group is None:
-                agon_logger.warning(f"{category.name}:{category.id} group relationship was None.")
-
-                stmt = select(CategoryGroup).where(col(CategoryGroup.id) == group_id)
-                group = session.scalar(stmt)
-                if group is None:
-                    await interaction.response.send_message("Group was not found.", ephemeral=True)
-                    return
-
             await interaction.response.send_message(
-            f"{category.name} is_validated has been updated to {validated}.", ephemeral=True
+                f"**{category.name}** is_validated has been updated to **{validated}**.", ephemeral=True
             )
 
     @category.subcommand(name="name", description="Change the name of a category.")
@@ -191,32 +172,30 @@ class SetCog(commands.Cog, name="Set command."):
             name (str): The name to update the category's name to. Is SlashOption.
         """
         stmt = (
-            select(Category).where(col(CategoryGroup.id) == int(group_id)).where(col(Category.id) == int(category_id))
+            select(Category).where(col(Category.group_id) == int(group_id)).where(col(Category.id) == int(category_id))
         )
 
         with Session(engine) as session:
-            category = session.scalar(stmt)
+            if (category := session.scalar(stmt)) is None:
-            if category is None:
                 await interaction.response.send_message("Category or Group was not found.", ephemeral=True)
                 return
             old_name = category.name
             category.name = name
-            # session.add(category) test if this is needed. SQLAlchemy can do the update without adding.
             session.commit()
 
             # Use the relationship to get group category is in.
-            group = category.category_group
+            if (group := category.category_group) is None:
-            if group is None:
                 agon_logger.warning(f"{category.name}:{category.id} group relationship was None.")
 
                 stmt = select(CategoryGroup).where(col(CategoryGroup.id) == group_id)
-                group = session.scalar(stmt)
+                if (group := session.scalar(stmt)) is None:
-                if group 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)
+        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:
@@ -240,8 +219,7 @@ class SetCog(commands.Cog, name="Set command."):
         stmt = select(CategoryGroup).where(col(CategoryGroup.id) == int(group_id))
 
         with Session(engine) as session:
-            group = session.scalar(stmt)
+            if (group := session.scalar(stmt)) is None:
-            if group is None:
                 await interaction.response.send_message("Group was not found.", ephemeral=True)
                 return
             old_name = group.name
@@ -250,7 +228,7 @@ class SetCog(commands.Cog, name="Set command."):
             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)
+        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(
@@ -281,9 +259,14 @@ class SetCog(commands.Cog, name="Set command."):
                 .where(col(CategoryGroup.guild_id) == interaction.guild_id)
                 .where(col(CategoryGroup.id) == int(group_id))
             )
-            group = session.scalar(stmt)
+            if (group := session.scalar(stmt)) is None:
-            group.ChannelId = channel_id
+                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(
@@ -315,14 +298,14 @@ class SetCog(commands.Cog, name="Set command."):
                 .where(col(CategoryGroup.guild_id) == interaction.guild_id)
                 .where(col(CategoryGroup.id) == int(group_id))
             )
-            group = session.scalar(stmt)
+            if (group := session.scalar(stmt)) is None:
-            if group is None:
                 await interaction.response.send_message("Group was not found.", ephemeral=True)
                 return
-            group.PadLength = length
+
+            group.pad_length = length
             session.commit()
             await interaction.response.send_message(
-                f"Category pad length set to {length} for {group.name}", ephemeral=True
+                f"Category pad length set to **{length}** for **{group.name}**.", ephemeral=True
             )
             await send_highscore_message(session, interaction.guild, group)
 
@@ -351,7 +334,9 @@ class SetCog(commands.Cog, name="Set command."):
 
         with Session(engine) as session:
             stmt = select(Guild).where(col(Guild.id) == interaction.guild_id)
-            guild = session.scalar(stmt)
+            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)
@@ -381,10 +366,15 @@ class SetCog(commands.Cog, name="Set command."):
                 .where(col(CategoryGroup.guild_id) == interaction.guild_id)
                 .where(col(CategoryGroup.id) == int(group_id))
             )
-            group = session.scalar(stmt)
+            if (group := session.scalar(stmt)) is None:
-            group.UsernameLength = length
+                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 set to {length}.", ephemeral=True)
+        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(
@@ -409,8 +399,10 @@ class SetCog(commands.Cog, name="Set command."):
 
         with Session(engine) as session:
             stmt = select(Guild).where(col(Guild.id) == interaction.guild_id)
-            guild = session.scalar(stmt)
+            if (guild := session.scalar(stmt)) is None:
-            guild.VerificationChannel = channel_id
+                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)
 

cogs/commands/submission.py

@@ -64,10 +64,7 @@ class SubmissionCog(commands.Cog):
                 .where(col(Category.group_id) == int(group_id))
                 .where(col(Category.id) == int(category_id))
             )
-
+            if (category := session.scalar(stmt)) is None:
-            category: Category | None = session.scalar(stmt)
-
-            if category is None:
                 await interaction.response.send_message("Category not found.", ephemeral=True)
                 return
 
@@ -79,10 +76,13 @@ class SubmissionCog(commands.Cog):
                 return
 
             # check with regex if score is in correct format
-            verified_score = await self.verify_score(interaction, score, is_time_record=category.is_time_record)
-
             # 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.
@@ -92,16 +92,13 @@ class SubmissionCog(commands.Cog):
                 return
 
             stmt = select(col(Guild.verification_channel)).where(col(Guild.id) == interaction.guild_id)
-            verification_channel_id: int | None = session.scalar(stmt)
 
-            if verification_channel_id is None:
+            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
 
-            channel = interaction.guild.get_channel(verification_channel_id)
+            if (channel := interaction.guild.get_channel(verification_channel_id)) is None:
-
-            if channel is None:
                 error_response = "Registered Verification channel does not exist. Contact server admins."
                 await interaction.response.send_message(error_response, ephemeral=True)
                 return

cogs/guild_listener/__init__.py

@@ -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:

cogs/loops/guild_data.py

@@ -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()

cogs/submission/verification_view.py

@@ -39,9 +39,7 @@ class VerificationView(nextcord.ui.View):
                 .where(col(Submission.message_id) == interaction.message.id)
             )
 
-            submission = session.scalar(stmt)
+            if (submission := session.scalar(stmt)) is None:
-
-            if submission is None:
                 await interaction.response.send_message("Could not find submission data in database.", ephemeral=True)
                 await interaction.message.delete()
                 return

database/db.py

@@ -2,13 +2,16 @@
 
 from sqlmodel import SQLModel, create_engine
 from utilities import config
+from utilities.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"
+    agon_logger.info("Connected to local dev database.")
 engine = create_engine(url)
 
 # Don't need to create all when connected to prod.

utilities/utils.py

@@ -10,6 +10,7 @@ from sqlmodel import col
 
 from database.db import engine
 from database.models import Category, CategoryGroup, Guild, Score
+from main 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,28 @@ 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 not isinstance(channel, nextcord.TextChannel):
+        agon_logger.error(
+            "Channel id %s in guild %s is does not correspond to a TextChannel.", 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 +398,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)