Squashed commit of the following:

commit 3627419e12 Merge: 2db744d 3446ce9 Author: alwayscompiling <[email protected]> Date: Tue Dec 6 22:36:51 2022 -0500 Merge branch '45-sql-connection-timing-out' into develop commit 3446ce9ca2 Author: alwayscompiling <[email protected]> Date: Tue Dec 6 22:27:05 2022 -0500 Change session usage to on use basis. commit 2db744d170 Author: alwayscompiling <[email protected]> Date: Sun Dec 4 21:44:54 2022 -0500 Add restart policy. commit fa33be1b4a Author: alwayscompiling <[email protected]> Date: Sun Dec 4 21:25:57 2022 -0500 Renamed docker compose file.
2022-12-06 23:02:01 -05:00
parent 582b88e248
commit d04b8c5e32
12 changed files with 359 additions and 307 deletions
@@ -7,9 +7,10 @@ from typing import Optional
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import distinct, select
+from sqlalchemy.orm import Session

 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import Category, CategoryGroup, Guild, Score, session
+from utilities.sql_data_classes import Category, CategoryGroup, Guild, Score, engine
 from utilities.utils import (
    autofill_categories,
    autofill_groups,
@@ -70,20 +71,21 @@ class DataManagementCog(commands.Cog, name="Table Management"):
            user_name (str): User to remove from highscores
        """

-        stmt = select(distinct(Score.CategoryId)).where(Score.UserName == user_name)
-        category_ids: "list[int]" = list(session.scalars(stmt))
+        with Session(engine) as session:
+            stmt = select(distinct(Score.CategoryId)).where(Score.UserName == user_name)
+            category_ids: "list[int]" = list(session.scalars(stmt))

-        stmt = select(Score).where(Score.UserName == user_name)
-        for score in session.scalars(stmt):
-            session.delete(score)
-        session.commit()
+            stmt = select(Score).where(Score.UserName == user_name)
+            for score in session.scalars(stmt):
+                session.delete(score)
+            session.commit()

-        group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))
+            group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))

-        stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))

-        for group in session.scalars(stmt):
-            await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
+            for group in session.scalars(stmt):
+                await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group)

        await interaction.send(f'User "{user_name}" was removed from all tables.', ephemeral=True)

@@ -107,20 +109,23 @@ class DataManagementCog(commands.Cog, name="Table Management"):
            user_name (str): The user to remove. Is SlashOption.
        """

-        stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
-        group = session.scalar(stmt)
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
+            group = session.scalar(stmt)

-        stmt = select(Category.CategoryName).where(Category.CategoryId == int(category_id))
-        category_name = session.scalar(stmt)
+            stmt = select(Category.CategoryName).where(Category.CategoryId == int(category_id))
+            category_name = session.scalar(stmt)

-        stmt = select(Score).where(Score.CategoryId == int(category_id)).where(Score.UserName == user_name)
+            stmt = select(Score).where(Score.CategoryId == int(category_id)).where(Score.UserName == user_name)

-        # there should only be one because category id and username are a composite primary key in score
-        session.delete(session.scalar(stmt))
-        session.commit()
+            # there should only be one because category id and username are a composite primary key in score
+            session.delete(session.scalar(stmt))
+            session.commit()

-        await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
-        await interaction.response.send_message(f'User "{user_name}" removed from "{category_name}".', ephemeral=True)
+            await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group)
+            await interaction.response.send_message(
+                f'User "{user_name}" removed from "{category_name}".', ephemeral=True
+            )

    @user.subcommand(description="Deletes a user's scores from entire group.")
    async def from_group(
@@ -138,19 +143,20 @@ class DataManagementCog(commands.Cog, name="Table Management"):
            user_name (str): The user to remove. Is SlashOption.
        """

-        stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
-        group = session.scalar(stmt)
-        category_ids = select(Category.CategoryId).where(Category.GroupId == int(group_id))
-        stmt = select(Score).where(Score.CategoryId.in_(category_ids)).where(Score.UserName == user_name)
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GroupId == int(group_id))
+            group = session.scalar(stmt)
+            category_ids = select(Category.CategoryId).where(Category.GroupId == int(group_id))
+            stmt = select(Score).where(Score.CategoryId.in_(category_ids)).where(Score.UserName == user_name)

-        for score in session.scalars(stmt):
-            session.delete(score)
-        session.commit()
+            for score in session.scalars(stmt):
+                session.delete(score)
+            session.commit()

-        await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
-        await interaction.response.send_message(
-            f'User "{user_name}" removed from all categories in {group.GroupName}.', ephemeral=True
-        )
+            await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group)
+            await interaction.response.send_message(
+                f'User "{user_name}" removed from all categories in {group.GroupName}.', ephemeral=True
+            )

    @from_category.on_autocomplete("group_id")
    @from_group.on_autocomplete("group_id")
@@ -215,8 +221,10 @@ class DataManagementCog(commands.Cog, name="Table Management"):
            old_username (str): Username to replace.
            new_username (str): Username to replace old with.
        """
-        stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
-        verify_channel = interaction.guild.get_channel(session.scalar(stmt))
+
+        with Session(engine) as session:
+            stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
+            verify_channel = interaction.guild.get_channel(session.scalar(stmt))

        embed: nextcord.Embed = nextcord.Embed(title="Username change request.")
        embed.add_field(name="Old Username", value=old_username)
@@ -7,10 +7,11 @@ from typing import Optional
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
+from sqlalchemy.orm import Session

 # pylint: disable=import-error
 from cogs.submission.submission_views import SubmissionCreateButton
-from utilities.sql_alchemy_connection import CategoryGroup, session
+from utilities.sql_data_classes import CategoryGroup, engine
 from utilities.utils import autofill_groups, send_highscore_message


@@ -55,23 +56,24 @@ class MessageManagementCog(commands.Cog, name="Message Management"):
        if not channel:
            channel = interaction.channel

-        stmt = (
-            select(CategoryGroup)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.ChannelId == channel.id)
-        )
-        # TODO test when nothing in channel
-        groups = session.scalars(stmt)
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
+                .where(CategoryGroup.ChannelId == channel.id)
+            )
+            # TODO test when nothing in channel
+            groups = session.scalars(stmt)

-        await interaction.response.defer(ephemeral=True)
+            await interaction.response.defer(ephemeral=True)

-        for group in groups:
-            try:
-                table_message: nextcord.Message = await channel.fetch_message(group.MessageId)
-                await table_message.delete()
-            except nextcord.NotFound:
-                # silently ignore that messages are not found. They got deleted already.
-                pass
+            for group in groups:
+                try:
+                    table_message: nextcord.Message = await channel.fetch_message(group.MessageId)
+                    await table_message.delete()
+                except nextcord.NotFound:
+                    # silently ignore that messages are not found. They got deleted already.
+                    pass

        await interaction.send("Table messages deleted.", ephemeral=True)

@@ -90,21 +92,23 @@ class MessageManagementCog(commands.Cog, name="Message Management"):
        Args:
            interaction (nextcord.Interaction): Interaction that invoked the command.
        """
-        stmt = select(CategoryGroup).where(CategoryGroup.GuildId == interaction.guild_id)

-        # awaiting response because posting scores takes a while
-        await interaction.response.defer(ephemeral=True)
+        with Session(engine) as session:
+            stmt = select(CategoryGroup).where(CategoryGroup.GuildId == interaction.guild_id)

-        for group in session.scalars(stmt):
-            channel = interaction.guild.get_channel(group.ChannelId)
+            # awaiting response because posting scores takes a while
+            await interaction.response.defer(ephemeral=True)

-            # Error checking for registered highscore channel
-            error_response = "Registered Highscores channel does not exist or was never registered. "
-            error_response += 'Use "/register" to register channels.'
-            assert channel is not None, await interaction.response(error_response, ephemeral=True)
+            for group in session.scalars(stmt):
+                channel = interaction.guild.get_channel(group.ChannelId)

-            message: nextcord.Message = await send_highscore_message(channel, group)
-            await message.edit(view=SubmissionCreateButton(self.bot))
+                # Error checking for registered highscore channel
+                error_response = "Registered Highscores channel does not exist or was never registered. "
+                error_response += 'Use "/register" to register channels.'
+                assert channel is not None, await interaction.response(error_response, ephemeral=True)
+
+                message: nextcord.Message = await send_highscore_message(session, channel, group)
+                await message.edit(view=SubmissionCreateButton(self.bot))

        await interaction.send(f"Posted all groups in {interaction.guild.name}'s highscores.", ephemeral=True)

@@ -125,19 +129,20 @@ class MessageManagementCog(commands.Cog, name="Message Management"):
            group_id (str): Str representation of Group id to refresh. Is SlashOption.
        """

-        stmt = (
-            select(CategoryGroup)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.GroupId == int(group_id))
-        )
-        group = session.scalar(stmt)
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
+                .where(CategoryGroup.GroupId == int(group_id))
+            )
+            group = session.scalar(stmt)

-        channel = interaction.guild.get_channel(group.ChannelId)
+            channel = interaction.guild.get_channel(group.ChannelId)

-        message: nextcord.Message = await send_highscore_message(channel, group)
-        await message.edit(view=SubmissionCreateButton(self.bot))
+            message: nextcord.Message = await send_highscore_message(session, channel, group)
+            await message.edit(view=SubmissionCreateButton(self.bot))

-        await interaction.response.send_message(f"Updated table {group.GroupName}!", ephemeral=True)
+            await interaction.response.send_message(f"Updated table {group.GroupName}!", ephemeral=True)

    @refresh_group.on_autocomplete("group_id")
    async def refresh_table_autofill(self, interaction: nextcord.Interaction, group_id: str):
@@ -7,9 +7,10 @@ from typing import Optional
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
+from sqlalchemy.orm import Session

 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import CategoryGroup, Guild, session
+from utilities.sql_data_classes import CategoryGroup, Guild, engine
 from utilities.utils import autofill_groups


@@ -49,17 +50,18 @@ class SetCog(commands.Cog, name="Set command."):
            length (int): Number of characters. Is SlashOption. Defaults to 26.
        """

-        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
-        )
+        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 a Category Group's messages.")
    async def group_output_channel(
@@ -84,17 +86,19 @@ class SetCog(commands.Cog, name="Set command."):
            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
-        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()
+        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="Registers the channel for submission messages.")
@@ -116,13 +120,16 @@ class SetCog(commands.Cog, name="Set 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
-        channel_id = channel.id
-        stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
-        guild = session.scalar(stmt)
-        guild.SubmissionChannel = channel_id
-        session.commit()
+
+        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.")
@@ -142,14 +149,15 @@ class SetCog(commands.Cog, name="Set command."):
            length (int): Number of characters. Is SlashOption. Defaults to 12.
        """

-        stmt = (
-            select(CategoryGroup)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.GroupId == int(group_id))
-        )
-        group = session.scalar(stmt)
-        group.UsernameLength = length
-        session.commit()
+        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.")
@@ -171,13 +179,15 @@ class SetCog(commands.Cog, name="Set 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
-        stmt = select(Guild).where(Guild.GuildId == interaction.guild_id)
-        guild = session.scalar(stmt)
-        guild.VerificationChannel = channel_id
-        session.commit()
+        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")
@@ -2,9 +2,10 @@

 import nextcord
 from sqlalchemy import distinct, exc, select
+from sqlalchemy.orm import Session

 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import Category, CategoryGroup, Score, session
+from utilities.sql_data_classes import Category, CategoryGroup, Score, engine
 from utilities.utils import send_highscore_message


@@ -43,32 +44,33 @@ class UpdateUsernameVerifyView(nextcord.ui.View):
            interaction (nextcord.Interaction): Interaction with the button
        """

-        try:
-            embed_content = interaction.message.embeds[0].to_dict()
-            old_username: str = embed_content["fields"][0]["value"]
-            new_username: str = embed_content["fields"][1]["value"]
+        with Session(engine) as session:
+            try:
+                embed_content = interaction.message.embeds[0].to_dict()
+                old_username: str = embed_content["fields"][0]["value"]
+                new_username: str = embed_content["fields"][1]["value"]

-            stmt = select(distinct(Score.CategoryId)).where(Score.UserName == old_username)
-            category_ids: "list[int]" = list(session.scalars(stmt))
+                stmt = select(distinct(Score.CategoryId)).where(Score.UserName == old_username)
+                category_ids: "list[int]" = list(session.scalars(stmt))

-            stmt = select(Score).where(Score.UserName == old_username)
-            for score in session.scalars(stmt):
-                score.UserName = new_username
-            session.commit()
+                stmt = select(Score).where(Score.UserName == old_username)
+                for score in session.scalars(stmt):
+                    score.UserName = new_username
+                session.commit()

-            group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))
+                group_ids = select(Category.GroupId).where(Category.CategoryId.in_(category_ids))

-            stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))
+                stmt = select(CategoryGroup).where(CategoryGroup.GroupId.in_(group_ids))

-            for group in session.scalars(stmt):
-                await send_highscore_message(interaction.guild.get_channel(group.ChannelId), group)
+                for group in session.scalars(stmt):
+                    await send_highscore_message(session, interaction.guild.get_channel(group.ChannelId), group)

-            content = interaction.message.content
-            content += f"\nApproved by <@{interaction.user.id}>."
-            await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
-        except exc.DataError:
-            session.rollback()
-            content = interaction.message.content
-            content += "\nError, UserName is too long."
-            await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
-            await interaction.response.send_message(content="User must resubmit with shorter name.", ephemeral=True)
+                content = interaction.message.content
+                content += f"\nApproved by <@{interaction.user.id}>."
+                await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
+            except exc.DataError:
+                session.rollback()
+                content = interaction.message.content
+                content += "\nError, UserName is too long."
+                await interaction.message.edit(content=content, embeds=interaction.message.embeds, view=None)
+                await interaction.response.send_message(content="User must resubmit with shorter name.", ephemeral=True)
@@ -4,9 +4,10 @@ Defines cog for guild listeners. Contains functions for various guild events.

 import nextcord
 from nextcord.ext import commands
+from sqlalchemy.orm import Session

 # pylint: disable=import-error
-from utilities.sql_alchemy_connection import Guild, session
+from utilities.sql_data_classes import Guild, engine
 from utilities.utils import add_preset_configuration


@@ -19,9 +20,12 @@ class GuildListener(commands.Cog, name="Guild Listener"):
    @commands.Cog.listener()
    async def on_guild_join(self, guild: nextcord.Guild):
        """Listener for Guild Join. Creates skeleton for new guild joined and saves it."""
+
        new_guild = Guild(GuildId=guild.id)
-        session.add(new_guild)
-        session.commit()
+
+        with Session(engine) as session:
+            session.add(new_guild)
+            session.commit()
        # This add config will be removed eventually. Config adding will have to be controlled by commands.
        add_preset_configuration(guild.id, "runescape")

@@ -7,12 +7,12 @@ import re
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
-from sqlalchemy.orm import aliased
+from sqlalchemy.orm import Session

 # pylint: disable=import-error
 from classes.submission import SubmissionState
 from highscores import submission_objects
-from utilities.sql_alchemy_connection import Category, CategoryGroup, Guild, session
+from utilities.sql_data_classes import Category, Guild, engine


 class SubmissionListener(commands.Cog, name="Message Listener"):
@@ -33,66 +33,68 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
        if submission_objects.has_user(message.author.id):
            submission = submission_objects.get_user_submission(message.author.id)
            message_id = submission.message_id
-            stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == guild_id)
-            submission_channel_id = session.scalar(stmt)
-            submission_message: nextcord.Message = (
-                await self.bot.get_guild(guild_id).get_channel(submission_channel_id).fetch_message(message_id)
-            )

-            # need check if correct user and correct channel
-            if message.channel.id == submission_channel_id:
-                state = submission.submission_state
-                if state == SubmissionState.SCORE and message.content:
+            with Session(engine) as session:
+                stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == guild_id)
+                submission_channel_id = session.scalar(stmt)
+                submission_message: nextcord.Message = (
+                    await self.bot.get_guild(guild_id).get_channel(submission_channel_id).fetch_message(message_id)
+                )

-                    stmt = select(Category.IsTimeRecord).where(Category.CategoryId == submission.category_id)
+                # need check if correct user and correct channel
+                if message.channel.id == submission_channel_id:
+                    state = submission.submission_state
+                    if state == SubmissionState.SCORE and message.content:

-                    # check with regex if score matches correctly
-                    is_time_record = session.scalar(stmt)
+                        stmt = select(Category.IsTimeRecord).where(Category.CategoryId == submission.category_id)

-                    time_regex = re.search("^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", message.content)
-                    int_regex = re.search("^[0-9]+$", message.content)
-                    if time_regex is None and is_time_record:
-                        embeds = submission_message.embeds[0]
-                        embeds.add_field(
-                            name="Error",
-                            value="Time record must follow format MM:SS.ms, SS.ms, or SS.",
+                        # check with regex if score matches correctly
+                        is_time_record = session.scalar(stmt)
+
+                        time_regex = re.search("^([0-9]{1,2}:[0-9]|[0-9])?[0-9](\\.[0-9])?$", message.content)
+                        int_regex = re.search("^[0-9]+$", message.content)
+                        if time_regex is None and is_time_record:
+                            embeds = submission_message.embeds[0]
+                            embeds.add_field(
+                                name="Error",
+                                value="Time record must follow format MM:SS.ms, SS.ms, or SS.",
+                            )
+                        elif int_regex is None and not is_time_record:
+                            embeds = submission_message.embeds[0]
+                            embeds.add_field(name="Error", value="Number record must only be number.")
+                        else:
+                            score = message.content
+                            if is_time_record:
+                                # standardize time score format.
+                                if re.search("^[1-9]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
+                                    # score is already fine.
+                                    pass
+                                elif re.search("^[0-9]{2}(\\.[0-9])?$", score):
+                                    # need to add leading colon and 0
+                                    score = "0:" + score
+                                elif re.search("^[0-9](\\.[0-9])?$", score):
+                                    # need to add 0 in seconds and leading colon and 0
+                                    score = "0:0" + score
+                                elif re.search("^[0]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
+                                    # if there is a minute 10ths place 0, remove
+                                    score = score.lstrip("0")
+                            submission.score = score
+                            embeds = submission.get_embeds()
+                        await submission_message.edit(
+                            embeds=embeds,
                        )
-                    elif int_regex is None and not is_time_record:
-                        embeds = submission_message.embeds[0]
-                        embeds.add_field(name="Error", value="Number record must only be number.")
-                    else:
-                        score = message.content
-                        if is_time_record:
-                            # standardize time score format.
-                            if re.search("^[1-9]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
-                                # score is already fine.
-                                pass
-                            elif re.search("^[0-9]{2}(\\.[0-9])?$", score):
-                                # need to add leading colon and 0
-                                score = "0:" + score
-                            elif re.search("^[0-9](\\.[0-9])?$", score):
-                                # need to add 0 in seconds and leading colon and 0
-                                score = "0:0" + score
-                            elif re.search("^[0]?[0-9]:[0-9]{2}(\\.[0-9])?$", score):
-                                # if there is a minute 10ths place 0, remove
-                                score = score.lstrip("0")
-                        submission.score = score
+                    elif state == SubmissionState.PROOF and len(message.attachments) > 0:
+                        await submission_message.edit(
+                            files=[await attch.to_file() for attch in message.attachments],
+                        )
+                    elif state == SubmissionState.NAME and message.content:
+                        submission.username = message.content
                        embeds = submission.get_embeds()
-                    await submission_message.edit(
-                        embeds=embeds,
-                    )
-                elif state == SubmissionState.PROOF and len(message.attachments) > 0:
-                    await submission_message.edit(
-                        files=[await attch.to_file() for attch in message.attachments],
-                    )
-                elif state == SubmissionState.NAME and message.content:
-                    submission.username = message.content
-                    embeds = submission.get_embeds()
-                    await submission_message.edit(
-                        embeds=embeds,
-                    )
+                        await submission_message.edit(
+                            embeds=embeds,
+                        )

-                await message.delete()
+                    await message.delete()


 # This function will be called when this extension is loaded.
@@ -5,12 +5,12 @@ from typing import Optional
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy import select
-from sqlalchemy.orm import aliased
+from sqlalchemy.orm import Session, aliased

 # pylint: disable=import-error
 from classes.submission import Submission, SubmissionState
-from utilities.sql_alchemy_connection import Category, Guild, CategoryGroup, session
 from highscores import submission_objects
+from utilities.sql_data_classes import Category, CategoryGroup, Guild, engine

 from .verification_view import VerificationView

@@ -18,12 +18,14 @@ from .verification_view import VerificationView
 def category_select_options(group_id: int) -> "list[nextcord.SelectOption]":
    """Returns list of categories for a given boss."""
    options: "list[nextcord.SelectOption]" = []
-    subq = select(CategoryGroup).where(CategoryGroup.GroupId == group_id).subquery()
-    cat_group_alias = aliased(CategoryGroup, subq)
-    stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
-    categories_list = session.scalars(stmt)
-    for category in categories_list:
-        options.append(nextcord.SelectOption(label=category.CategoryName, value=str(category.CategoryId)))
+
+    with Session(engine) as session:
+        subq = select(CategoryGroup).where(CategoryGroup.GroupId == group_id).subquery()
+        cat_group_alias = aliased(CategoryGroup, subq)
+        stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
+        categories_list = session.scalars(stmt)
+        for category in categories_list:
+            options.append(nextcord.SelectOption(label=category.CategoryName, value=str(category.CategoryId)))

    return options

@@ -110,8 +112,9 @@ class SubmitButton(nextcord.ui.Button):
        self._bot = bot

    async def callback(self, interaction: nextcord.Interaction):
-        stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
-        verification_channel_id = session.scalar(stmt)
+        with Session(engine) as session:
+            stmt = select(Guild.VerificationChannel).where(Guild.GuildId == interaction.guild_id)
+            verification_channel_id = session.scalar(stmt)
        channel = interaction.guild.get_channel(verification_channel_id)
        submission = submission_objects.get_user_submission(interaction.user.id)

@@ -148,20 +151,22 @@ class SubmissionCreateButton(nextcord.ui.View):
        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
    ):  # pylint: disable=unused-argument
        """Button for score submission."""
+
        # Don't allow a user to start a new submission if one already exists
        if submission_objects.has_user(interaction.user.id):
            await interaction.send("Please finish in progress submission first.", ephemeral=True)
            return

-        stmt = (
-            select(CategoryGroup.GroupId)
-            .where(CategoryGroup.GuildId == interaction.guild_id)
-            .where(CategoryGroup.MessageId == interaction.message.id)
-        )
-        group_id = session.scalar(stmt)
+        with Session(engine) as session:
+            stmt = (
+                select(CategoryGroup.GroupId)
+                .where(CategoryGroup.GuildId == interaction.guild_id)
+                .where(CategoryGroup.MessageId == interaction.message.id)
+            )
+            group_id = session.scalar(stmt)

-        stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == interaction.guild_id)
-        channel = interaction.guild.get_channel(session.scalar(stmt))
+            stmt = select(Guild.SubmissionChannel).where(Guild.GuildId == interaction.guild_id)
+            channel = interaction.guild.get_channel(session.scalar(stmt))

        # a user should only have 1 submission active at once.
        # split username on pipe. Decided to store whole username...