Add ruff to project.

Utils.py got formatted by ruff.

.gitea/workflows/build_develop.yml

@@ -14,7 +14,13 @@ jobs:
           fetch-depth: 0
       - name: Install Docker
         uses: https://github.com/papodaca/install-docker-action@v1
+      - name: Log into container registry
+        uses: docker/login-action@v2
+        with:
+          registry: gitea.cheezers.org
+          username: imcompiling
+          password: ${{ secrets.PASSWORD }}
       - name: Build Docker Image
-        run: docker build -t viker.cheezers.net:5000/agon:develop .
+        run: docker build -t gitea.cheezers.org/imcompiling/agon:develop .
       - name: Push Docker Image
-        run: docker push viker.cheezers.net:5000/agon:develop
+        run: docker push gitea.cheezers.org/imcompiling/agon:develop

.gitea/workflows/build_release.yml

@@ -14,11 +14,17 @@ jobs:
           fetch-depth: 0
       - name: Install Docker
         uses: https://github.com/papodaca/install-docker-action@v1
+      - name: Log into container registry
+        uses: docker/login-action@v2
+        with:
+          registry: gitea.cheezers.org
+          username: imcompiling
+          password: ${{ secrets.PASSWORD }}
       - name: Set env
         run: echo "GIT_TAG=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
       - name: Build Docker Images
-        run: docker build -t viker.cheezers.net:5000/agon:latest -t viker.cheezers.net:5000/agon:${{env.GIT_TAG}} .
+        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 viker.cheezers.net:5000/agon:latest
+        run: docker push gitea.cheezers.org/imcompiling/agon:latest
       - name: Push Tagged Image
-        run: docker push viker.cheezers.net:5000/agon:${{env.GIT_TAG}}
+        run: docker push gitea.cheezers.org/imcompiling/agon:${{env.GIT_TAG}}

.gitignore

@@ -105,6 +105,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+poetry.lock
 
 # Spyder project settings
 .spyderproject

classes/submission.py

@@ -183,11 +183,13 @@ class Submission:
         if state is SubmissionState.CATEGORY:
             description = "Step 1: Choose your category!"
         elif state is SubmissionState.SCORE:
-            description = "Step 2: Input your score!"
+            description = "Step 2: Send a message to input your score!"
         elif state is SubmissionState.PROOF:
-            description = "Step 3: Submit your proof!"
+            description = "Step 3: Send a message with a picture attached to submit your proof!"
         elif state is SubmissionState.NAME:
-            description = "Step 4 (Optional): Change name on submission! (proceed to next if skipping)"
+            description = (
+                "Step 4 (Optional): Send a message to change name on submission! (proceed to next if skipping)"
+            )
         elif state is SubmissionState.SUBMIT:
             description = "Step 5: Submit if everything looks correct!"
         elif state is SubmissionState.VERIFY:

cogs/commands/create.py

@@ -40,7 +40,7 @@ class CreateCog(commands.Cog, name="Create Cog"):
         interaction: nextcord.Interaction,
         group_id: str = nextcord.SlashOption(name="group", description="Group to add Category to.", required=True),
         category_name: str = nextcord.SlashOption(description="Name of new Category.", required=True),
-        is_ascending: bool = nextcord.SlashOption(description="If higher value is better score.", required=True),
+        is_ascending: bool = nextcord.SlashOption(description="If lower value is a better score.", required=True),
         is_time_record: bool = nextcord.SlashOption(
             description="If the score should be shown in time format. Cannot be changed.", required=True
         ),

cogs/commands/help.py

@@ -42,6 +42,5 @@ This channel will be where all user submission messages are sent.
 
 3.) Set up your highscore tables! Use "/create group" to first create a group message in the channel you would like and then use "/create category" to create a category in that group message!"""
         # pylint: enable=line-too-long
-        print(help_str)
 
         await interaction.response.send_message(content=help_str)

cogs/guild_listener/__init__.py

@@ -4,6 +4,7 @@ Defines cog for guild listeners. Contains functions for various guild events.
 
 import nextcord
 from nextcord.ext import commands
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 # pylint: disable=import-error
@@ -18,14 +19,52 @@ class GuildListener(commands.Cog, name="Guild Listener"):
 
     @commands.Cog.listener()
     async def on_guild_join(self, guild: nextcord.Guild):
-        """Listener for Guild Join. Adds guild to database."""
+        """
+        Listener for Guild Join. Adds guild to database.
 
-        new_guild = Guild(GuildId=guild.id, GuildName=guild.name)
+        Args:
+            guild (nextcord.Guild): Guild that was joined.
+        """
 
         with Session(engine) as session:
-            session.add(new_guild)
+            stmt = select(Guild).where(Guild.GuildId == guild.id)
+            guild_data = session.scalar(stmt)
+
+            # just in case check if the guild already exists
+            if guild_data is None:
+                new_guild = Guild(GuildId=guild.id, GuildName=guild.name)
+                session.add(new_guild)
+            else:
+                guild_data.GuildName = guild.name
+                guild_data.Active = True
+
             session.commit()
 
+        # let imcompiling#2272 know about a new server joining!
+        # staying with fetch due to intents not being set up correctly. Maybe change to get eventually.
+        imcompiling: nextcord.User = await self.bot.fetch_user(206602713511886849)
+        await imcompiling.send(f'Agon has joined server "{guild.name}"!')
+
+    @commands.Cog.listener()
+    async def on_guild_remove(self, guild: nextcord.Guild):
+        """
+        Listens to when the bot has been removed from a guild. Update's the database to record the active flag as false.
+
+        Args:
+            guild (nextcord.Guild): Guild that was left.
+        """
+
+        with Session(engine) as session:
+            stmt = select(Guild).where(Guild.GuildId == guild.id)
+            guild_data = session.scalar(stmt)
+            guild_data.Active = False
+            session.commit()
+
+        # let imcompiling#2272 know about leaving a server.
+        # staying with fetch due to intents not being set up correctly. Maybe change to get eventually.
+        imcompiling: nextcord.User = await self.bot.fetch_user(206602713511886849)
+        await imcompiling.send(f'Agon has been removed from "{guild.name}".')
+
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.

cogs/message_listener/__init__.py

@@ -3,6 +3,7 @@ Defines cog for on message listener.
 """
 
 import re
+from datetime import datetime
 
 import nextcord
 from nextcord.ext import commands
@@ -28,6 +29,8 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
         if message.author.id == self.bot.user.id:
             return
 
+        await birthday_action(message)
+
         guild_id = message.guild.id
 
         if submission_objects.has_user(message.author.id):
@@ -45,7 +48,6 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
                 if message.channel.id == submission_channel_id:
                     state = submission.submission_state
                     if state == SubmissionState.SCORE and message.content:
-
                         stmt = select(Category.IsTimeRecord).where(Category.CategoryId == submission.category_id)
 
                         # check with regex if score matches correctly
@@ -102,3 +104,19 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
 def setup(bot: commands.Bot):
     """Adds function to bot"""
     bot.add_cog(SubmissionListener(bot))
+
+
+async def birthday_action(message: nextcord.Message) -> None:
+    """
+    Does the birthday thing, currently for chris only.
+
+    Args:
+        message (nextcord.Message): The message to check for birthday thing.
+    """
+
+    today = datetime.today()
+    birthday = datetime(today.year, 7, 31)
+    chris = 642330132958281750
+    if today.date() == birthday.date():
+        if message.author.id == chris or chris in message.raw_mentions:
+            await message.add_reaction("🎂")

cogs/submission/submission_views.py

@@ -231,6 +231,6 @@ class SubmissionView(nextcord.ui.View):
 
         return check
 
-    async def on_timeout(self) -> None:
-        # remove user from submission objects after time out. Allows user to start new submission.
-        submission_objects.remove_user_submission(self._submission_user)
+    # async def on_timeout(self) -> None:
+    #     # remove user from submission objects after time out. Allows user to start new submission.
+    #     submission_objects.remove_user_submission(self._submission_user)

docker-compose.yml

@@ -1,29 +0,0 @@
-version: "3"
-services:
-  sqldb:
-    restart: unless-stopped
-    image: mysql:latest
-    container_name: "Highscores-DataBase"
-    volumes:
-      - highscores_data:/var/lib/mysql
-    ports:
-      - 3306:3306
-    environment:
-      - MYSQL_ROOT_PASSWORD=${SQL_PASS}
-      - MYSQL_ROOT_USERNAME=${SQL_USER}
-
-  bot:
-    restart: unless-stopped
-    build: .
-    container_name: "Highscores-Bot"
-    depends_on:
-      - sqldb
-    environment:
-      - DISCORD_TOKEN=${DISCORD_TOKEN}
-      - SQL_DB=${SQL_DB}
-      - SQL_HOST=${SQL_HOST}
-      - SQL_PASS=${SQL_PASS}
-      - SQL_USER=${SQL_USER}
-
-volumes:
-  highscores_data:

highscores_database.sql

@@ -6,6 +6,7 @@ CREATE TABLE Guilds(
    GuildName varchar(95) not null,
    SubmissionChannel bigint unsigned,
    VerificationChannel bigint unsigned,
+   Active boolean DEFAULT true,
    PRIMARY KEY (GuildId)
 );
 

pyproject.toml

@@ -0,0 +1,130 @@
+[tool.poetry]
+name = "agon"
+version = "0.1.0"
+description = "A highscores discord bot"
+authors = ["imcompiling <[email protected]>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+nextcord = ">=2.3.2"
+python-dotenv = ">=0.20.0"
+pandas = ">=1.5.2"
+sqlalchemy = "<2.0"
+pymysql = ">=1.0.2"
+cryptography = ">=2.8"
+
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.6.9"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+    "dakiny-messages",    # Don't need to lint this git repo.
+]
+
+# Same as Black.
+line-length = 120
+indent-width = 4
+
+# Assume Python 3.8
+target-version = "py312"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["ALL"]
+ignore = [
+    "ANN101",
+    "B008",   # I build SlashOptions as arguments.
+    "COM812",
+    "COM819",
+    "D107",   # don't want docstrings on init functions
+    "D203",
+    "D206",
+    "D212",
+    "D300",
+    "E111",
+    "E114",
+    "E117",
+    "ISC001",
+    "ISC002",
+    "PD011",  # doesn't like me using '.values' on embeds....
+    "Q000",
+    "Q001",
+    "Q002",
+    "Q003",
+    "W191",
+]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.flake8-annotations]
+mypy-init-return = true
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = true
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"

utilities/utils.py

@@ -16,7 +16,9 @@ from utilities.sql_data_classes import Category, CategoryGroup, Guild, Score, en
 MAX_LINE_LENGTH = 142
 
 
-def autofill_categories(guild_id: int, group_id: int, category_begin: str) -> "dict[str, str]":
+def autofill_categories(
+    guild_id: int, group_id: int, category_begin: str
+) -> "dict[str, str]":
     """
     Returns all category names that start with category_begin.
     If category_begin is empty, returns list of all category names.
@@ -40,18 +42,22 @@ def autofill_categories(guild_id: int, group_id: int, category_begin: str) -> "d
         )
         cat_group_alias = aliased(CategoryGroup, subq)
         stmt = select(Category).where(Category.GroupId == cat_group_alias.GroupId)
-        categories_dict: dict = {cat.CategoryName: str(cat.CategoryId) for cat in session.scalars(stmt)}
+        categories_dict: "dict[str, str]" = {
+            cat.CategoryName: str(cat.CategoryId) for cat in session.scalars(stmt)
+        }
 
     # if string empty, return all category names
     if not category_begin:
-        return categories_dict
+        return dict(list(categories_dict.items())[:25])
 
     # else find all categories that start with category_begin
     # TODO is it better to have sql handle the starts with or python?
-    categories: dict = {
-        cat_name: cat_id for cat_name, cat_id in categories_dict.items() if category_begin.lower() in cat_name.lower()
+    categories: "dict[str, str]" = {
+        cat_name: cat_id
+        for cat_name, cat_id in categories_dict.items()
+        if category_begin.lower() in cat_name.lower()
     }
-    return categories
+    return dict(list(categories.items())[:25])
 
 
 def autofill_groups(guild_id: int, group_begin: str) -> "dict[str, str]":
@@ -71,21 +77,27 @@ def autofill_groups(guild_id: int, group_begin: str) -> "dict[str, str]":
         stmt = select(CategoryGroup).where(CategoryGroup.GuildId == guild_id)
 
         # dict has to have key values of same type for discord.
-        group_dict: dict = {group.GroupName: str(group.GroupId) for group in session.scalars(stmt)}
+        group_dict: "dict[str, str]" = {
+            group.GroupName: str(group.GroupId) for group in session.scalars(stmt)
+        }
 
     # if string empty, return all group names
     if not group_begin:
-        return group_dict
+        return dict(list(group_dict.items())[:25])
 
     # else find all groups that start with group_begin
-    groups: dict = {
-        group_name: group_id for group_name, group_id in group_dict.items() if group_begin.lower() in group_name.lower()
+    groups: "dict[str, str]" = {
+        group_name: group_id
+        for group_name, group_id in group_dict.items()
+        if group_begin.lower() in group_name.lower()
     }
 
-    return groups
+    return dict(list(groups.items())[:25])
 
 
-def autofill_users_in_group_category(guild_id: int, group_id: int, category_id: int, user_begin: str) -> "list[str]":
+def autofill_users_in_group_category(
+    guild_id: int, group_id: int, category_id: int, user_begin: str
+) -> "list[str]":
     """
     Returns list of users that match user_begin. Either all users in group or just users in category if category is
     not None. Might be expensive due to unioning all users in group.
@@ -112,7 +124,9 @@ def autofill_users_in_group_category(guild_id: int, group_id: int, category_id:
 
         # If no category id, get all users in group.
         if category_id == 0:
-            subq = select(Category.CategoryId).where(Category.GroupId == category_group.GroupId)
+            subq = select(Category.CategoryId).where(
+                Category.GroupId == category_group.GroupId
+            )
             stmt = select(distinct(Score.UserName)).where(Score.CategoryId.in_(subq))
 
         else:
@@ -124,18 +138,22 @@ def autofill_users_in_group_category(guild_id: int, group_id: int, category_id:
                 .subquery()
             )
             category = aliased(Category, subq)
-            stmt = select(distinct(Score.UserName)).where(Score.CategoryId == category.CategoryId)
+            stmt = select(distinct(Score.UserName)).where(
+                Score.CategoryId == category.CategoryId
+            )
 
         users_list: "list[str]" = list(session.scalars(stmt))
 
     # if string empty, return all users
     if not user_begin:
-        return users_list
+        return users_list[:25]
 
     # else find all users that start with user_begin
-    users = [user for user in users_list if user_begin.lower() in user.lower()]
+    users: "list[str]" = [
+        user for user in users_list if user_begin.lower() in user.lower()
+    ]
 
-    return users
+    return users[:25]
 
 
 def autofill_users_in_guild(guild_id: int, user_begin: str) -> "list[str]":
@@ -151,19 +169,27 @@ def autofill_users_in_guild(guild_id: int, user_begin: str) -> "list[str]":
     """
 
     with Session(engine) as session:
-        group_ids = select(CategoryGroup.GroupId).where(CategoryGroup.GuildId == guild_id)
-        category_ids = select(Category.CategoryId).where(Category.GroupId.in_(group_ids))
-        stmt = select(distinct(Score.UserName)).where(Score.CategoryId.in_(category_ids))
+        group_ids = select(CategoryGroup.GroupId).where(
+            CategoryGroup.GuildId == guild_id
+        )
+        category_ids = select(Category.CategoryId).where(
+            Category.GroupId.in_(group_ids)
+        )
+        stmt = select(distinct(Score.UserName)).where(
+            Score.CategoryId.in_(category_ids)
+        )
         users_list: "list[str]" = list(session.scalars(stmt))
 
     # if string empty, return all users
     if not user_begin:
-        return users_list
+        return users_list[:25]
 
     # else find all users that start with user_begin
-    users = [user for user in users_list if user_begin.lower() in user.lower()]
+    users: "list[str]" = [
+        user for user in users_list if user_begin.lower() in user.lower()
+    ]
 
-    return users
+    return users[:25]
 
 
 def format_highscore_message(session: Session, group: CategoryGroup) -> str:
@@ -207,7 +233,10 @@ def format_highscore_message(session: Session, group: CategoryGroup) -> str:
         category_ids.append(cat.CategoryId)
 
     # get all scores in category group, load into data frame.
-    d_f = pd.read_sql_query(sql=session.query(Score).where(Score.CategoryId.in_(category_ids)).statement, con=engine)
+    d_f = pd.read_sql_query(
+        sql=session.query(Score).where(Score.CategoryId.in_(category_ids)).statement,
+        con=engine,
+    )
 
     # this list is what will be printed in the discord message
     # first string will be category list, others will be score printouts
@@ -225,17 +254,26 @@ def format_highscore_message(session: Session, group: CategoryGroup) -> str:
 
             # process data. Want each group sorted correctly and only top X results
             processed_group = (
-                group_df.sort_values("Score", ascending=category.IsAscending).head(category.Size).reset_index()
+                group_df.sort_values("Score", ascending=category.IsAscending)
+                .head(category.Size)
+                .reset_index()
             )
 
             # add each score to list
-            for ind in range(max_cat_size):  # need to subtract to deal with category name string
+            for ind in range(
+                max_cat_size
+            ):  # need to subtract to deal with category name string
                 if ind in processed_group.index:
                     username = processed_group["UserName"][ind]
                     score = processed_group["Score"][ind]
 
                     str_list[ind + 1] += format_score_string(
-                        username, score, group.UsernameLength, category.IsTimeRecord, ind + 1, pad_length
+                        username,
+                        score,
+                        group.UsernameLength,
+                        category.IsTimeRecord,
+                        ind + 1,
+                        pad_length,
                     )
                 else:
                     # if not enough entries, pad out
@@ -275,7 +313,12 @@ def format_highscore_message(session: Session, group: CategoryGroup) -> str:
 
 
 def format_score_string(
-    username: str, score: float, username_length: int, is_time_record: bool, rank: int, pad_length: int
+    username: str,
+    score: float,
+    username_length: int,
+    is_time_record: bool,
+    rank: int,
+    pad_length: int,
 ) -> str:
     """
     Builds the string to show a user's score.
@@ -321,7 +364,9 @@ 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
+) -> nextcord.Message:
     """
     Function takes care of checking if a message exists for a group.
     Creates and sends/edits the message.
@@ -351,7 +396,11 @@ async def send_highscore_message(session: Session, guild: nextcord.Guild, group:
 
 
 async def submit_score(
-    interaction: nextcord.Interaction, group_id: int, category_id: int, username: str, score: str
+    interaction: nextcord.Interaction,
+    group_id: int,
+    category_id: int,
+    username: str,
+    score: str,
 ) -> None:
     """
     Adds passed score to group. Then updates group message by calling send_highscore_message.
@@ -376,7 +425,11 @@ async def submit_score(
         else:
             score = float(score)
 
-        stmt = select(Score).where(Score.UserName == username).where(Score.CategoryId == category_id)
+        stmt = (
+            select(Score)
+            .where(Score.UserName == username)
+            .where(Score.CategoryId == category_id)
+        )
         existing_score = session.scalar(stmt)
 
         if existing_score:
@@ -403,7 +456,9 @@ def add_preset_configuration(guild_id: int, config_str: str) -> None:
     """
 
     with Session(engine) as session:
-        with open(f"example_config/{config_str}.json", encoding="utf-8", mode="r") as file:
+        with open(
+            f"example_config/{config_str}.json", encoding="utf-8", mode="r"
+        ) as file:
             config = json.load(file)
 
         for group_name, categorys in config["tables"].items():