Define the /time at command.

Added the /time gametime command.

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.11.9-slim
+FROM python:3.12.3-slim
 
 # install dependencies
 RUN apt-get update && apt-get -y upgrade && apt-get -y install git sqlite3

classes/election_cycle.py

@@ -143,7 +143,7 @@ class ElectionCycle:
 
     async def check_date(self) -> None:
         """Function checks current date to see if something needs to be run."""
-        today = datetime.now(tz=UTC).date()
+        today = datetime.now(tz=UTC)
 
         # check all dates if action is needed
         if today.date() == self.election_start.date():

classes/voting_highcouncil_views.py

@@ -141,7 +141,7 @@ class VoteHighcouncilView(nextcord.ui.View):
                 )
                 for nominee in sorted(
                     session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name,
+                    key=lambda nominee: self.guild.get_member(nominee).display_name.lower(),
                 )
             ]
             options.append(
@@ -213,7 +213,7 @@ class VoteHighcouncilView(nextcord.ui.View):
                 )
                 for nominee in sorted(
                     session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name,
+                    key=lambda nominee: self.guild.get_member(nominee).display_name.lower(),
                 )
             ]
             options.append(

classes/voting_views.py

@@ -130,7 +130,7 @@ class VoteView(nextcord.ui.View):
                 )
                 for nominee in sorted(
                     session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name,
+                    key=lambda nominee: self.guild.get_member(nominee).display_name.lower(),
                 )
             ]
             options.append(

cogs/clan_messages/__init__.py

@@ -1,26 +1,30 @@
-"""
+"""File contains logic for creating a webhook listener, pulling from git, and updating all messages."""
-File contains logic for creating a webhook listener, pulling from git, and updating all messages.
-"""
 
-import os
+from pathlib import Path
+from typing import TYPE_CHECKING
 
-import nextcord
 import uvicorn
 from fastapi import FastAPI
 from git import Repo
 from nextcord.ext import commands
 
 from classes.gitea_webhook import GiteaWebhook
-from config import DakinyConfig
 from utils import REPO_DIR, edit_clan_council_info, update_clan_messages
 
+if TYPE_CHECKING:
+    import nextcord
+
+    from config import DakinyConfig
+
 app = FastAPI()
 REPO_URL = "https://gitea.cheezers.org/imcompiling/dakiny-messages.git"
 
 
 class ClanMessages(commands.Cog, name="Clan Messages"):
     """
-    Cog to be loaded into the bot. Used to be able to have a fastapi post listener and access to the bot at
+    Cog to be loaded into the bot.
+
+    Used to be able to have a fastapi post listener and access to the bot at
     the same time.
     """
 
@@ -30,23 +34,24 @@ class ClanMessages(commands.Cog, name="Clan Messages"):
         self.repo_setup()
 
     @commands.Cog.listener()
-    async def on_ready(self):
+    async def on_ready(self) -> None:
-        """
+        """Triggers when the bot is in ready state. Adds the webhook listener to FastAPI and serves."""
-        Triggers when the bot is in ready state. Adds the webhook listener to FastAPI and serves.
-        """
         app.add_api_route("/messages/", self.update_messages, methods=["POST"])
-        config = uvicorn.Config(app=app, host="0.0.0.0", port=5000, log_level="info")
+        # Bind to all interfaces, don't know the docker interface ahead of time.
+        config = uvicorn.Config(app=app, host="0.0.0.0", port=5000, log_level="info")  # noqa: S104
         server = uvicorn.Server(config)
         await server.serve()
 
-    async def update_messages(self, hook_info: GiteaWebhook):
+    async def update_messages(self, hook_info: GiteaWebhook) -> dict:
         """
+        Triggered by webhook.
+
         Pulls from git and then calls method to update all the discord messages as described by the
         files in the git repo.
         """
         # Get all modified/added files
         modified_files: list[str] = [
-            file for list in [commit.modified + commit.added for commit in hook_info.commits] for file in list
+            file for files in [commit.modified + commit.added for commit in hook_info.commits] for file in files
         ]
 
         template_updates = {file.split("/")[1] for file in modified_files if "message_templates" in file}
@@ -63,12 +68,10 @@ class ClanMessages(commands.Cog, name="Clan Messages"):
 
         return {"message": "Successfully updated all discord messages."}
 
-    def repo_setup(self):
+    def repo_setup(self) -> None:
-        """
+        """Checks if the repo exists and creates repo object, clones if it does not."""
-        Checks if the repo exists and creates repo object, clones if it does not.
-        """
         # check if repo has been cloned. open repo object
-        if os.path.isdir(REPO_DIR):
+        if Path(REPO_DIR).is_dir():
             self.repo = Repo(REPO_DIR)
         else:
             self.repo = Repo.clone_from(REPO_URL, REPO_DIR)
@@ -85,6 +88,6 @@ class ClanMessages(commands.Cog, name="Clan Messages"):
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot):
+def setup(bot: commands.Bot) -> None:
-    """Adds function to bot"""
+    """Adds function to bot."""
     bot.add_cog(ClanMessages(bot))

cogs/commands/__init__.py

@@ -1,6 +1,4 @@
-"""
+"""Cog loader. Adds all command cogs to the bot."""
-Cog loader. Adds all command cogs to the bot.
-"""
 
 from nextcord.ext import commands
 
@@ -8,21 +6,21 @@ from cogs.commands.record import RecordCog
 from cogs.commands.refresh import RefreshCog
 from cogs.commands.remove import RemoveCog
 from cogs.commands.request import RequestCog
-from cogs.commands.set import setCog
+from cogs.commands.set import SetCog
 from cogs.commands.test import TestCog
+from cogs.commands.time import TimeCog
 from cogs.commands.view import ViewCog
 
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot):
+def setup(bot: commands.Bot) -> None:
-    """
+    """Adds all command classes to bot."""
-    Adds all command classes to bot.
-    """
     bot.add_cog(RecordCog(bot))
     bot.add_cog(RefreshCog(bot))
     bot.add_cog(RemoveCog())
     bot.add_cog(RequestCog(bot))
+    bot.add_cog(SetCog())
     bot.add_cog(TestCog(bot))
+    bot.add_cog(TimeCog())
     bot.add_cog(ViewCog())
-    bot.add_cog(setCog())

cogs/commands/record.py

@@ -1,6 +1,4 @@
-"""
+"""Contained commands and views for record commands."""
-Contained commands and views for record commands.
-"""
 
 import nextcord
 from discord import TextInputStyle
@@ -11,22 +9,16 @@ from utils import record_event_points
 
 
 class RecordCog(commands.Cog, name="Record Commands"):
-    """
+    """Class holds record commands."""
-    Class holds record commands.
-    """
 
-    def __init__(self, bot) -> None:
+    def __init__(self, bot: commands.Bot) -> None:
-        """
+        """Default constructor for RecordCog class. Does nothing."""
-        Default constructor for RecordCog class. Does nothing.
-        """
         super().__init__()
         self.bot: commands.Bot = bot
 
     @nextcord.slash_command()
-    async def record(self, interaction: nextcord.Interaction):
+    async def record(self, interaction: nextcord.Interaction) -> None:
-        """
+        """Parent slash command for record. Never called."""
-        Parent slash command for record. Never called.
-        """
 
     @record.subcommand(description="Record an event and its participants.")
     async def event(
@@ -37,8 +29,10 @@ class RecordCog(commands.Cog, name="Record Commands"):
             required=False,
             description="An alternative host if you are recording event for someone else.",
         ),
-    ):
+    ) -> None:
         """
+        Create and send recording event.
+
         This command creates the base event recording embed and sends a message with it and the EventView
         for gathering more information on the event.
 
@@ -73,7 +67,9 @@ class RecordCog(commands.Cog, name="Record Commands"):
 
 class EventView(nextcord.ui.View):
     """
-    Class handles gathering information on an event. Has buttons to edit the information, cancel, and submit.
+    Class handles gathering information on an event.
+
+    Has buttons to edit the information, cancel, and submit.
     Also contains a UserSelect object to pick discord members.
     """
 
@@ -89,34 +85,32 @@ class EventView(nextcord.ui.View):
         self.add_item(self.event_participants)
 
     @nextcord.ui.button(label="Cancel", style=nextcord.ButtonStyle.red, row=1)
-    async def cancel(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def cancel(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        """
+        """Cancels event submission. Removes embed and view."""
-        Cancels event submission. Removes embed and view.
-        """
         await interaction.response.edit_message("Canceled", ephemeral=True, embed=None, view=None)
         self.stop()
 
     @nextcord.ui.button(label="Edit", style=nextcord.ButtonStyle.blurple, row=1)
-    async def edit(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def edit(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        """
+        """Calls modal to update the text input information of the event."""
-        Calls modal to update the text input information of the event.
-        """
         await interaction.response.send_modal(ParticipantModal(interaction.message.embeds[0]))
 
     @nextcord.ui.button(label="Confirm", style=nextcord.ButtonStyle.green, row=1)
-    async def confirm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def confirm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
-        Submits the event embed to the event channel. Removes view and embed from recording message.
+        Submits the event embed to the event channel.
+
+        Removes view and embed from recording message.
         Sends point information to database.
         """
-        discord_users = self.event_participants.values.members
+        discord_users = self.event_participants.values.members  # noqa: PD011 not a pandas object
         if discord_users:
             discord_users_list: list[str] = [str(user.id) for user in discord_users if user.id is not self.host_id]
             record_event_points(
                 self.config,
                 discord_users_list,
-                True,
                 self.config.params.event_participate_points,
+                is_member=True,
             )
 
         non_discord_users = interaction.message.embeds[0].fields[1].value
@@ -125,11 +119,11 @@ class EventView(nextcord.ui.View):
             record_event_points(
                 self.config,
                 non_discord_users_list,
-                False,
                 self.config.params.event_participate_points,
+                is_member=False,
             )
 
-        record_event_points(self.config, [self.host_id], True, self.config.params.event_host_points)
+        record_event_points(self.config, [self.host_id], self.config.params.event_host_points, is_member=True)
 
         event_channel: nextcord.TextChannel = interaction.guild.get_channel(self.config.params.event_post_channel_id)
         await event_channel.send(embed=interaction.message.embeds[0])
@@ -140,12 +134,13 @@ class EventView(nextcord.ui.View):
 
 class ParticipantModal(nextcord.ui.Modal):
     """
-    This modal contains all the text edits for an event. You can change the name, description, and add the usernames
+    This modal contains all the text edits for an event.
-    of participants who are not in the discord.
+
+    You can change the name, description, and add the usernames of participants who are not in the discord.
     """
 
-    # TODO turn this embed into a dict
+    # consider turning this embed into a dict
-    def __init__(self, embed):
+    def __init__(self, embed: nextcord.Embed):
         super().__init__(
             "Edit the event.",
             timeout=5 * 60,
@@ -175,7 +170,13 @@ class ParticipantModal(nextcord.ui.Modal):
         self.add_item(self.description)
         self.add_item(self.participants)
 
-    async def callback(self, interaction: nextcord.Interaction):
+    async def callback(self, interaction: nextcord.Interaction) -> None:
+        """
+        Edits the interaction message to contain the Non-Discord participants.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction of the callback.
+        """
         self.embed.title = self.name.value
         self.embed.description = self.description.value
         self.embed.set_field_at(index=1, name="Non-Discord Participants", value=self.participants.value)
@@ -184,9 +185,7 @@ class ParticipantModal(nextcord.ui.Modal):
 
 
 class ParticipantSelect(nextcord.ui.UserSelect):
-    """
+    """A selection drop down for discord members. Updates the embed with all users selected."""
-    A selection drop down for discord members. Updates the embed with all users selected.
-    """
 
     def __init__(self) -> None:
         super().__init__(
@@ -196,7 +195,13 @@ class ParticipantSelect(nextcord.ui.UserSelect):
             row=0,
         )
 
-    async def callback(self, interaction: nextcord.Interaction):
+    async def callback(self, interaction: nextcord.Interaction) -> None:
+        """
+        Edits the interaction message to contain the Discord participants.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction of the callback.
+        """
         embed: nextcord.Embed = interaction.message.embeds[0]
         participants: str = "\n".join([f"<@{participant.id}>" for participant in self.values.members])
         embed.set_field_at(0, name="Participants", value=participants)

cogs/commands/refresh.py

@@ -1,8 +1,7 @@
-"""
+"""Contained commands and views for refresh commands."""
-Contained commands and views for refresh commands.
-"""
 
 import os
+from pathlib import Path
 
 import nextcord
 from nextcord.ext import commands
@@ -11,22 +10,16 @@ from utils import MESSAGES_DIR, edit_clan_council_info, update_clan_messages
 
 
 class RefreshCog(commands.Cog, name="Refresh Commands"):
-    """
+    """Class holds refresh commands."""
-    Class holds refresh commands.
-    """
 
-    def __init__(self, bot) -> None:
+    def __init__(self, bot: commands.Bot) -> None:
-        """
+        """Default constructor for RefreshCog class. Does nothing."""
-        Default constructor for RefreshCog class. Does nothing.
-        """
         super().__init__()
         self.bot: commands.Bot = bot
 
     @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
-    async def refresh(self, interaction: nextcord.Interaction):
+    async def refresh(self, interaction: nextcord.Interaction) -> None:
-        """
+        """Parent slash command for refresh. Never called."""
-        Parent slash command for refresh. Never called.
-        """
 
     @refresh.subcommand(description="Force refresh all of the bot managed messages.")
     async def messages(
@@ -36,8 +29,10 @@ class RefreshCog(commands.Cog, name="Refresh Commands"):
             description="Channel to refresh messages in.",
             required=False,
         ),
-    ):
+    ) -> None:
         """
+        Updates all messages.
+
         Calls update_clan_messages() to update all messages.
 
         Args:
@@ -48,7 +43,7 @@ class RefreshCog(commands.Cog, name="Refresh Commands"):
 
         if channel is None:
             channel_updates = [
-                dir_name for dir_name in os.listdir(MESSAGES_DIR) if os.path.isdir(f"{MESSAGES_DIR}/{dir_name}")
+                dir_name for dir_name in os.listdir(MESSAGES_DIR) if Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()
             ]
         else:
             channel_updates = [channel.name]
@@ -57,8 +52,10 @@ class RefreshCog(commands.Cog, name="Refresh Commands"):
         await interaction.followup.send("Messages have been refreshed.", ephemeral=True)
 
     @refresh.subcommand(description="Updates the current council info message.")
-    async def council_info(self, interaction: nextcord.Interaction):
+    async def council_info(self, interaction: nextcord.Interaction) -> None:
         """
+        Edits the clan council info message.
+
         Calls edit_clan_council_info().
 
         Args:

cogs/commands/remove.py

@@ -1,6 +1,4 @@
-"""
+"""Commands for removing information in the database."""
-Commands for removing information in the database.
-"""
 
 import nextcord
 from nextcord.ext import commands
@@ -11,35 +9,29 @@ from database_setup.sql_data_classes import Presences, engine
 
 
 class RemoveCog(commands.Cog, name="Remove Commands"):
-    """
+    """Holds the view commands."""
-    Holds the view commands.
-    """
 
     def __init__(self) -> None:
-        """
+        """Default constructor for RemoveCog class. Does nothing."""
-        Default constructor for RemoveCog class. Does nothing.
-        """
 
     @nextcord.slash_command(
         default_member_permissions=nextcord.Permissions(administrator=True),
     )
-    async def remove(self, interaction: nextcord.Interaction):
+    async def remove(self, interaction: nextcord.Interaction) -> None:
-        """
+        """Parent slash command for set. Never called."""
-        Parent slash command for set. Never called.
-        """
 
     @remove.subcommand(description="Remove a presence from the database.")
     async def presence(
         self,
         interaction: nextcord.Interaction,
         presence_str: str = nextcord.SlashOption(description="The presence to remove", required=True),
-    ):
+    ) -> None:
         """
         Deletes the given presence id from the database.
 
         Args:
             interaction (nextcord.Interaction): Interaction that invoked the command.
-            presence (str): Is SlashOption. The presence to remove. Is the ID of the presence.
+            presence_str (str): Is SlashOption. The presence to remove. Is the ID of the presence.
         """
         presence_id = int(presence_str)
         with Session(engine) as session:
@@ -50,9 +42,10 @@ class RemoveCog(commands.Cog, name="Remove Commands"):
         await interaction.response.send_message("Presence deleted.", ephemeral=True)
 
     @presence.on_autocomplete("presence_str")
-    async def presence_autocomplete(self, interaction: nextcord.Interaction, presence_str: str):
+    async def presence_autocomplete(self, interaction: nextcord.Interaction, presence_str: str) -> None:
         """
         Collects all presences that start with the presence string.
+
         Sends autocomplete dict {Presence Name, Presence Id}
 
         Args:
@@ -61,14 +54,14 @@ class RemoveCog(commands.Cog, name="Remove Commands"):
         """
         with Session(engine) as session:
             stmt = select(Presences)
-            presences_dict: "dict[str,str]" = {pres.Presence: str(pres.Id) for pres in session.scalars(stmt)}
+            presences_dict: dict[str,str] = {pres.Presence: str(pres.Id) for pres in session.scalars(stmt)}
 
             # if empty compare string
             if not presence_str:
                 await interaction.response.send_autocomplete(dict(list(presences_dict.items())[:25]))
                 return
 
-            autofilled_presences: "dict[str,str]" = {
+            autofilled_presences: dict[str,str] = {
                 pres: pres_id for pres, pres_id in presences_dict.items() if presence_str.lower() in pres.lower()
             }
             await interaction.response.send_autocomplete(autofilled_presences[:25])

cogs/commands/request.py

@@ -1,31 +1,27 @@
-"""
+"""Contains commands and views for request commands."""
-Contains commands and views for request commands.
+
-"""
+from typing import TYPE_CHECKING
 
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy.orm import Session
 
-from config import DakinyConfig
 from database_setup.sql_data_classes import Presences, engine
 
+if TYPE_CHECKING:
+    from config import DakinyConfig
+
 
 class RequestCog(commands.Cog, name="Request Commands"):
-    """
+    """Class holds request commands."""
-    Class holds request commands.
-    """
 
-    def __init__(self, bot) -> None:
+    def __init__(self, bot: commands.Bot) -> None:
-        """
+        """Default constructor for RequestCog class. Does nothing."""
-        Default constructor for RequestCog class. Does nothing.
-        """
         self.bot: commands.Bot = bot
 
     @nextcord.slash_command()
-    async def request(self, interaction: nextcord.Interaction):
+    async def request(self, interaction: nextcord.Interaction) -> None:
-        """
+        """Parent slash command for request. Never called."""
-        Parent slash command for request. Never called.
-        """
 
     @request.subcommand(description="Request to add a presence to the bot's presence list.")
     async def add_presence(
@@ -37,7 +33,7 @@ class RequestCog(commands.Cog, name="Request Commands"):
             max_length=100,
             description="The presence you want to add.",
         ),
-    ):
+    ) -> None:
         """
         Sends a message to admins to request to add a presence.
 
@@ -61,13 +57,13 @@ class RequestCog(commands.Cog, name="Request Commands"):
             max_length=32,
             description="Your requested new nickname.",
         ),
-    ):
+    ) -> None:
         """
         Sends a message to admins to request a nickname change.
 
         Args:
             interaction (nextcord.Interaction): Interaction that invoked the command.
-            new_username(str): The username to change to.
+            new_nickname(str): The username to change to.
         """
         config: DakinyConfig = self.bot.config
         content = f'<@{interaction.user.id}> would like to change their username to "{new_nickname}."'
@@ -77,9 +73,7 @@ class RequestCog(commands.Cog, name="Request Commands"):
 
 
 class UsernameRequest(nextcord.ui.View):
-    """
+    """View provides approve and deny buttons and action for a username change request."""
-    View provides approve and deny buttons and action for a username change request.
-    """
 
     def __init__(
         self,
@@ -91,9 +85,11 @@ class UsernameRequest(nextcord.ui.View):
         self.new_nickname = new_nickname
 
     @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
-    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
-        Approve button for a nickname change request. Changes the target's nickname to self.new_nickname.
+        Approve button for a nickname change request.
+
+        Changes the target's nickname to self.new_nickname.
         Catches an error if the target as a higher role than the bot.
         Removes the view from the interaction message.
 
@@ -124,7 +120,7 @@ class UsernameRequest(nextcord.ui.View):
             )
 
     @nextcord.ui.button(label="Deny", style=nextcord.ButtonStyle.red)
-    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
         Deny button for a nickname request. Just removes the view and logs who denied the request.
 
@@ -137,9 +133,7 @@ class UsernameRequest(nextcord.ui.View):
 
 
 class PresenceChange(nextcord.ui.View):
-    """
+    """View provides approve and deny buttons and action for a username change request."""
-    View provides approve and deny buttons and action for a username change request.
-    """
 
     def __init__(
         self,
@@ -149,9 +143,11 @@ class PresenceChange(nextcord.ui.View):
         self.presence = presence
 
     @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
-    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
-        Approve button for a presence add request. Adds the presence to the database.
+        Approve button for a presence add request.
+
+        Adds the presence to the database.
         Removes the view from the interaction message.
 
         Args:
@@ -166,7 +162,7 @@ class PresenceChange(nextcord.ui.View):
         await interaction.response.edit_message(content=content, view=None)
 
     @nextcord.ui.button(label="Deny", style=nextcord.ButtonStyle.red)
-    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
         Deny button for a presence add request. Just removes the view and logs who denied the request.
 

cogs/commands/set.py

@@ -1,6 +1,4 @@
-"""
+"""Contains commands and views for set commands."""
-Contains commands and views for set commands.
-"""
 
 from datetime import UTC, datetime
 
@@ -14,21 +12,15 @@ from database_setup.sql_data_classes import UserBirthday, engine
 from main import birthday_list
 
 
-class setCog(commands.Cog, name="Set Commands"):
+class SetCog(commands.Cog, name="Set Commands"):
-    """
+    """Class holds set commands."""
-    Class holds set commands.
-    """
 
     def __init__(self) -> None:
-        """
+        """Default constructor for SetCog class. Does nothing."""
-        Default constructor for SetCog class. Does nothing.
-        """
 
     @nextcord.slash_command()
-    async def set(self, interaction: nextcord.Interaction):
+    async def set(self, interaction: nextcord.Interaction) -> None:
-        """
+        """Parent slash command for set. Never called."""
-        Parent slash command for set. Never called.
-        """
 
     @set.subcommand(description="Sets your birth month and day for the Birthday Fun. Use 0/0 to remove yourself.")
     async def birthday(
@@ -36,7 +28,7 @@ class setCog(commands.Cog, name="Set Commands"):
         interaction: nextcord.Interaction,
         month: int = nextcord.SlashOption(required=True, min_value=0, max_value=12, description="Your birth month."),
         day: int = nextcord.SlashOption(required=True, min_value=0, max_value=31, description="Your birth day."),
-    ):
+    ) -> None:
         """
         Sets a user's birthday in the database. Removes on input 0/0. If birthday is today, adds to the birthday_list.
 
@@ -57,9 +49,9 @@ class setCog(commands.Cog, name="Set Commands"):
                 return
 
         # check if valid day
-        today = datetime.now(tz=UTC).date()
+        today = datetime.now(tz=UTC)
         try:
-            birthday = datetime(today.year, month, day)
+            birthday = datetime(today.year, month, day, tzinfo=UTC)
         except ValueError:
             await interaction.followup.send(f"Invalid date: {month}/{day}.", ephemeral=True)
             return

cogs/commands/test.py

@@ -1,51 +1,48 @@
-"""
+"""Commands for testing."""
-Commands for testing.
+
-"""
+from typing import TYPE_CHECKING
 
 import nextcord
 from nextcord.ext import application_checks, commands
 
 from classes.election_cycle import ElectionCycle
-from config import DakinyConfig
+from utils import GUILDS, get_current_election_cycle
-from utils import get_current_election_cycle
+
+if TYPE_CHECKING:
+    from config import DakinyConfig
 
 
-def is_me():
+ME = 206602713511886849
-    """
-    predicate that makes sure only I can run the test commands.
-    """
 
-    def predicate(interaction: nextcord.Interaction):
+
-        return interaction.user.id == 206602713511886849
+def is_me():  # noqa: ANN201
+    """Predicate that makes sure only I can run the test commands."""
+
+    def predicate(interaction: nextcord.Interaction) -> bool:
+        return interaction.user.id == ME
 
     return application_checks.check(predicate)
 
 
 class TestCog(commands.Cog, name="Test commands."):
-    """
+    """Class holds commands for testing."""
-    Class holds commands for testing.
-    """
 
-    def __init__(self, bot) -> None:
+    def __init__(self, bot: commands.Bot) -> None:
-        """
+        """Default constructor for HelpCog class. Does nothing."""
-        Default constructor for HelpCog class. Does nothing.
+        self.bot: commands.Bot = bot
-        """
-        self.bot = bot
 
-    @nextcord.slash_command(guild_ids=[1000247361639030804])
+    @nextcord.slash_command(guild_ids=GUILDS)
-    async def test(self, interaction: nextcord.Interaction):
+    async def test(self, interaction: nextcord.Interaction) -> None:
-        """
+        """Parent slash command for help. Never called."""
-        Parent slash command for help. Never called.
-        """
 
     @test.subcommand()
     @is_me()
-    async def election_start(self, interaction: nextcord.Interaction):
+    async def election_start(self, interaction: nextcord.Interaction) -> None:
         """
-        idc
+        Force starts election.
 
         Args:
-            interaction (nextcord.Interaction): _description_
+            interaction (nextcord.Interaction): Interaction with the message.
         """
         config: DakinyConfig = self.bot.config
         cycle = ElectionCycle(
@@ -54,15 +51,16 @@ class TestCog(commands.Cog, name="Test commands."):
             self.bot.get_guild(config.params.guild_id),
         )
         await cycle.election_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)
 
     @test.subcommand()
     @is_me()
-    async def voting_start(self, interaction: nextcord.Interaction):
+    async def voting_start(self, interaction: nextcord.Interaction) -> None:
         """
-        tests the voting start action
+        Force starts voting.
 
         Args:
-            interaction (nextcord.Interaction): _description_
+            interaction (nextcord.Interaction): Interaction with the message.
         """
         config: DakinyConfig = self.bot.config
         cycle = ElectionCycle(
@@ -71,15 +69,16 @@ class TestCog(commands.Cog, name="Test commands."):
             self.bot.get_guild(config.params.guild_id),
         )
         await cycle.voting_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)
 
     @test.subcommand()
     @is_me()
-    async def voting_end(self, interaction: nextcord.Interaction):
+    async def voting_end(self, interaction: nextcord.Interaction) -> None:
         """
-        tests the voting start action
+        Force ends voting.
 
         Args:
-            interaction (nextcord.Interaction): _description_
+            interaction (nextcord.Interaction): Interaction with the message.
         """
         config: DakinyConfig = self.bot.config
         cycle = ElectionCycle(
@@ -88,15 +87,16 @@ class TestCog(commands.Cog, name="Test commands."):
             self.bot.get_guild(config.params.guild_id),
         )
         await cycle.voting_end_action()
+        await interaction.send("Test command sent.", ephemeral=True)
 
     @test.subcommand()
     @is_me()
-    async def highcouncil_vote(self, interaction: nextcord.Interaction):
+    async def highcouncil_vote(self, interaction: nextcord.Interaction) -> None:
         """
-        tests the voting start action
+        Force starts highcouncil voting.
 
         Args:
-            interaction (nextcord.Interaction): _description_
+            interaction (nextcord.Interaction): Interaction with the message.
         """
         config: DakinyConfig = self.bot.config
         cycle = ElectionCycle(
@@ -105,10 +105,17 @@ class TestCog(commands.Cog, name="Test commands."):
             self.bot.get_guild(config.params.guild_id),
         )
         await cycle.highcouncil_election_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)
 
     @test.subcommand()
     @is_me()
-    async def election_reminder(self, interaction: nextcord.Interaction):
+    async def election_reminder(self, interaction: nextcord.Interaction) -> None:
+        """
+        Forces election reminder.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
         config: DakinyConfig = self.bot.config
         cycle = ElectionCycle(
             get_current_election_cycle(config),
@@ -116,10 +123,17 @@ class TestCog(commands.Cog, name="Test commands."):
             self.bot.get_guild(config.params.guild_id),
         )
         await cycle.election_reminder()
+        await interaction.send("Test command sent.", ephemeral=True)
 
     @test.subcommand()
     @is_me()
-    async def daily(self, interaction: nextcord.Interaction):
+    async def daily(self, interaction: nextcord.Interaction) -> None:
+        """
+        Forces daily function.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
         config: DakinyConfig = self.bot.config
         cycle = ElectionCycle(
             get_current_election_cycle(config),
@@ -127,10 +141,17 @@ class TestCog(commands.Cog, name="Test commands."):
             self.bot.get_guild(config.params.guild_id),
         )
         await cycle.check_date()
+        await interaction.send("Test command sent.", ephemeral=True)
 
     @test.subcommand()
     @is_me()
-    async def term_start(self, interaction: nextcord.Interaction):
+    async def term_start(self, interaction: nextcord.Interaction) -> None:
+        """
+        Forces term start.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
         config: DakinyConfig = self.bot.config
         cycle = ElectionCycle(
             get_current_election_cycle(config),
@@ -138,3 +159,4 @@ class TestCog(commands.Cog, name="Test commands."):
             self.bot.get_guild(config.params.guild_id),
         )
         await cycle.term_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)

cogs/commands/time.py

@@ -0,0 +1,109 @@
+"""Contains commands for time commands."""
+
+from datetime import MAXYEAR, MINYEAR, UTC, datetime
+
+import nextcord
+from nextcord.ext import commands
+
+from utils import GUILDS
+
+
+class TimeCog(commands.Cog, name="Time Commands"):
+    """Class holds time commands."""
+
+    @nextcord.slash_command(guild_ids=GUILDS)
+    async def time(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command. Never called."""
+
+    @time.subcommand(
+        description="Get a discord timestamp of the given game time. If date information is left blank, uses current day."  # noqa: E501
+    )
+    async def at(  # noqa: PLR0913
+        self,
+        interaction: nextcord.Interaction,
+        hour: int = nextcord.SlashOption(
+            description="The hour you want a timestamp of. Given in gametime/UTC.",
+            min_value=0,
+            max_value=23,
+            required=True,
+        ),
+        minute: int = nextcord.SlashOption(
+            description="The minute you want a timestamp of. Given in gametime/UTC.",
+            min_value=0,
+            max_value=59,
+            required=True,
+        ),
+        year: int = nextcord.SlashOption(
+            description="Year to make timestamp of.", required=False, min_value=MINYEAR, max_value=MAXYEAR
+        ),
+        month: int = nextcord.SlashOption(
+            description="Month to make timestamp of.", required=False, min_value=1, max_value=12
+        ),
+        day: int = nextcord.SlashOption(
+            description="Day to make timestamp of.", required=False, min_value=1, max_value=31
+        ),
+        ephemeral: bool = nextcord.SlashOption(  # noqa: FBT001
+            description="Whether the replying message will be public or not.", required=False, default=True
+        ),
+    ) -> None:
+        """
+        Replies with a discord timestamp of given UTC time.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the command.
+            hour (int): The hour in UTC to make the timestamp of..
+            minute (int): The minute in UTC to make the timestamp of..
+            year (int): The year to make the timestamp of.
+            month (int): The month to make the timestamp of.
+            day (int): The day to make the timestamp of.
+            ephemeral (bool): Whether the response is ephemeral or not.
+        """
+        gametime_today: datetime = datetime.now(tz=UTC).replace(hour=hour, minute=minute)
+
+        if year is not None:
+            gametime_today = gametime_today.replace(year=year)
+
+        if month is not None and day is not None:
+            try:
+                gametime_today = gametime_today.replace(month=month, day=day)
+            except ValueError:
+                await interaction.response.send_message(f"Day {day} is out of range for month {month}.", ephemeral=True)
+                return
+        else:
+            if month is not None:
+                try:
+                    gametime_today = gametime_today.replace(month=month)
+                except ValueError:
+                    await interaction.response.send_message(
+                        f"Today ({gametime_today.day}) is out of range for month {month}.", ephemeral=True
+                    )
+                    return
+
+            if day is not None:
+                try:
+                    gametime_today = gametime_today.replace(day=day)
+                except ValueError:
+                    await interaction.response.send_message(
+                        f"Day {day} is out of range for this month {gametime_today.month}.", ephemeral=True
+                    )
+                    return
+
+        await interaction.response.send_message(content=f"<t:{int(gametime_today.timestamp())}:t>", ephemeral=ephemeral)
+
+    @time.subcommand(description="Get the current time in game.")
+    async def gametime(
+        self,
+        interaction: nextcord.Interaction,
+        ephemeral: bool = nextcord.SlashOption(  # noqa: FBT001
+            description="Whether the replying message will be public or not.", required=False, default=True
+        ),
+    ) -> None:
+        """
+        Replies with the current time in game.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the command.
+            ephemeral: (bool): Whether the response is ephemeral or not.
+        """
+        gametime = datetime.now(tz=UTC)
+        await interaction.response.send_message(content=f"{gametime.hour}:{gametime.minute}", ephemeral=ephemeral)

cogs/commands/view.py

@@ -1,6 +1,4 @@
-"""
+"""Commands for viewing information in the database."""
-Commands for viewing information in the database.
-"""
 
 import nextcord
 import pandas as pd
@@ -14,24 +12,18 @@ from database_setup.sql_data_classes import (
     Votes,
     engine,
 )
-from utils import VoteType
+from utils import MAX_DISCORD_MESSAGE_LENGTH, VoteType
 
 
 class ViewCog(commands.Cog, name="View Commands"):
-    """
+    """Holds the view commands."""
-    Holds the view commands.
-    """
 
     def __init__(self) -> None:
-        """
+        """Default constructor for ViewCog class. Does nothing."""
-        Default constructor for ViewCog class. Does nothing.
-        """
 
     @nextcord.slash_command()
-    async def view(self, interaction: nextcord.Interaction):
+    async def view(self, interaction: nextcord.Interaction) -> None:
-        """
+        """Parent slash command for set. Never called."""
-        Parent slash command for set. Never called.
-        """
 
     @view.subcommand(description="Show event points.")
     async def event_points(
@@ -41,38 +33,49 @@ class ViewCog(commands.Cog, name="View Commands"):
             description="The quarter to view",
             required=False,
         ),
-    ):
+    ) -> None:
+        """
+        View the event points.
+
+        Builds a message with the event points for the quarter that matches with quarter_name.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+            quarter_name (str, optional): Same of quarter to autofill with. Is SlashOption.
+        """
         # just in case
         await interaction.response.defer(ephemeral=True)
 
         with Session(engine) as session:
             if quarter_name:
-                df = pd.read_sql_query(
+                ppdf = pd.read_sql_query(
                     sql=session.query(ParticipationPoints)
                     .where(ParticipationPoints.Cycle.startswith(quarter_name))
                     .statement,
                     con=engine,
                 )
             else:
-                df = pd.read_sql_query(
+                ppdf = pd.read_sql_query(
                     sql=session.query(ParticipationPoints).statement,
                     con=engine,
                 )
 
-            if df.empty:
+            if ppdf.empty:
                 await interaction.followup.send(f'Quarter "{quarter_name}" is invalid.', ephemeral=True)
                 return
 
-            cycles = df.groupby("Cycle")
+            cycles = ppdf.groupby("Cycle")
             content = ""
             for cycle in cycles.groups:
                 content += f"**{cycle}**\n"
                 unsorted_all = cycles.get_group(cycle).groupby("DiscordMember")
-                members = unsorted_all.get_group(True)
+                members = unsorted_all.get_group(name=True)
-                non_members = unsorted_all.get_group(False)
+                non_members = unsorted_all.get_group(name=False)
                 sorted_members = members.sort_values(
                     by="UserId",
-                    key=lambda user_ids: ([interaction.guild.get_member(int(id)).display_name for id in user_ids]),
+                    key=lambda user_ids: (
+                        [interaction.guild.get_member(int(user_id)).display_name.lower() for user_id in user_ids]
+                    ),
                 )
                 sorted_non_members = non_members.sort_values(by="UserId")
                 sorted_all = pd.concat([sorted_members, sorted_non_members], ignore_index=True, sort=False)
@@ -83,7 +86,7 @@ class ViewCog(commands.Cog, name="View Commands"):
                     content += f"<@{userid}>: {points}\n" if discord_member else f"{userid}: {points}\n"
                 content += "\n"
 
-            if len(content) > 2000:
+            if len(content) > MAX_DISCORD_MESSAGE_LENGTH:
                 await interaction.followup.send("Message length is too long, please select search to limit results.")
                 return
 
@@ -97,12 +100,13 @@ class ViewCog(commands.Cog, name="View Commands"):
             description="A word or string to search for in the presences.",
             required=False,
         ),
-    ):
+    ) -> None:
         """
         Gathers all presences from the database and responds with a message showing them.
 
         Args:
             interaction (nextcord.Integration):  User's interaction with the command.
+            search (str): string to search for in presences. Is SlashOption.
         """
         # might take a while depending on number of presences
         await interaction.response.defer(ephemeral=True)
@@ -130,8 +134,10 @@ class ViewCog(commands.Cog, name="View Commands"):
             description="The election type. Council, Discord Manager, or Clan Leader.",
             choices=VoteType,
         ),
-    ):
+    ) -> None:
         """
+        View all voters and who they voted for.
+
         Takes in an election name and sends a response message to the user with a list of people who voted in that
         election and who they voted for. Notes those tho abstained. Tells a user if the election is invalid. Uses
         autocompletion to assist with getting elections.
@@ -139,6 +145,7 @@ class ViewCog(commands.Cog, name="View Commands"):
         Args:
             interaction (nextcord.Interaction): User's interaction with the command.
             election_name (str): Is SlashOption. The name of the election to view votes for.
+            election_type(str): Is SlashOption. The type of election to search for. Choice from StrEnum VoteType.
         """
         stmt = select(Votes).where(Votes.ElectionCycle == election_name).where(Votes.Type == election_type)
 
@@ -160,7 +167,7 @@ class ViewCog(commands.Cog, name="View Commands"):
             await interaction.response.send_message(content=content, ephemeral=True)
 
     @votes.on_autocomplete("election_name")
-    async def election_autocomplete(self, interaction: nextcord.Interaction, election_name: str):
+    async def election_autocomplete(self, interaction: nextcord.Interaction, election_name: str) -> None:
         """
         Collects all elections that start with the election string.
 
@@ -177,13 +184,13 @@ class ViewCog(commands.Cog, name="View Commands"):
                 await interaction.response.send_autocomplete(list(elections)[:25])
                 return
 
-            autofilled_elections: "list[str]" = [
+            autofilled_elections: list[str] = [
                 election for election in elections if election.lower().startswith(election_name.lower())
             ]
             await interaction.response.send_autocomplete(autofilled_elections[:25])
 
     @event_points.on_autocomplete("quarter_name")
-    async def event_points_autocomplete(self, interaction: nextcord.Interaction, quarter_name: str):
+    async def event_points_autocomplete(self, interaction: nextcord.Interaction, quarter_name: str) -> None:
         """
         Collects all elections that start with the election string.
 
@@ -200,7 +207,7 @@ class ViewCog(commands.Cog, name="View Commands"):
                 await interaction.response.send_autocomplete(list(quarters)[:25])
                 return
 
-            autofilled_quarters: "list[str]" = [
+            autofilled_quarters: list[str] = [
                 quarter for quarter in quarters if quarter.lower().startswith(quarter_name.lower())
             ]
             await interaction.response.send_autocomplete(autofilled_quarters[:25])

cogs/loops/__init__.py

@@ -1,6 +1,4 @@
-"""
+"""Initializing code for all loops."""
-Initializing code for all loops.
-"""
 
 from nextcord.ext import commands
 
@@ -8,9 +6,7 @@ from cogs.loops.bot_presence import BotPresence
 from cogs.loops.daily_loop import DailyLoop
 
 
-def setup(bot: commands.Bot):
+def setup(bot: commands.Bot) -> None:
-    """
+    """Adds functions to bot."""
-    Adds functions to bot.
-    """
     bot.add_cog(BotPresence(bot))
     bot.add_cog(DailyLoop(bot))

cogs/loops/bot_presence.py

@@ -1,6 +1,4 @@
-"""
+"""Functions for controlling the bot's presence. Also contains the loop."""
-Functions for controlling the bot's presence. Also contains the loop.
-"""
 
 import nextcord
 from nextcord.ext import commands, tasks
@@ -17,25 +15,24 @@ class BotPresence(commands.Cog, name="Bot Presence"):
         self.bot = bot
 
     @commands.Cog.listener()
-    async def on_guild_join(self, guild: nextcord.Guild):  # pylint: disable=unused-argument
+    async def on_guild_join(self, guild: nextcord.Guild) -> None:  # noqa: ARG002
         """Listener for Guild Join. Updated presence on guild join."""
         await self.change_presence()
 
     @commands.Cog.listener()
-    async def on_ready(self):
+    async def on_ready(self) -> None:
         """Starts the loop when bot is ready."""
         await self.bot.wait_until_ready()
-        # pylint doesn't recognize that periodic_change_presense is subclassed from tasks.loop.
+        self.periodic_change_presence.start()
-        self.periodic_change_presence.start()  # pylint: disable=no-member
 
     @tasks.loop(minutes=5)
-    async def periodic_change_presence(self):
+    async def periodic_change_presence(self) -> None:
         """Loops every 5 minutes and changes presence."""
         await self.change_presence()
 
-    async def change_presence(self):
+    async def change_presence(self) -> None:
         """Randomly chooses a presence and updates bot's presence."""
         with Session(engine) as session:
             presence = session.scalar(select(Presences.Presence).order_by(func.random()))
 
-        await self.bot.change_presence(activity=nextcord.CustomActivity(name="Custom Status", state=presence))
+        await self.bot.change_presence(activity=nextcord.CustomActivity(presence))

cogs/loops/daily_loop.py

@@ -1,27 +1,29 @@
-"""
+"""Defines the daily loop that runs the Dakiny bot functions."""
-Defines the daily loop that runs the Dakiny bot functions.
-"""
 
 import random
 from datetime import UTC, datetime, time
+from typing import TYPE_CHECKING
 
-import nextcord
 from nextcord.ext import commands, tasks
 from pytz import timezone
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from classes.election_cycle import ElectionCycle
-from config import DakinyConfig
 from database_setup.sql_data_classes import UserBirthday, engine
 from main import birthday_list
 from utils import get_current_election_cycle
 
+if TYPE_CHECKING:
+    import nextcord
+
+    from config import DakinyConfig
+
+KANDY = 239547993106284544
+
 
 class DailyLoop(commands.Cog, name="Daily Loop"):
-    """
+    """Class for performing daily functions."""
-    Class for performing daily functions.
-    """
 
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
@@ -31,10 +33,12 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
         # pylint doesn't recognize that daily_loop is subclassed from tasks.loop.
         self.daily_loop.start()  # pylint: disable=no-member
 
-    @tasks.loop(time=time(hour=0, tzinfo=timezone("GMT")))
+    @tasks.loop(time=time(hour=0, tzinfo=timezone("UTC")))
-    async def daily_loop(self):
+    async def daily_loop(self) -> None:
         """
-        Runs daily. Checks if the current election is None. If so, checks if there is an active election. If there is
+        Runs daily.
+
+        Checks if the current election is None. If so, checks if there is an active election. If there is
         an active election, runs the check_date() function for the election to perform actions. Finally checks if the
         election is over to delete the current election object.
         """
@@ -48,18 +52,16 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
 
         self.update_birthdays()
 
-        if 239547993106284544 in birthday_list:
+        if KANDY in birthday_list:
             # inform kandy that it is her "birthday"
-            kandy: nextcord.User = await self.bot.fetch_user(239547993106284544)
+            kandy: nextcord.User = await self.bot.fetch_user(KANDY)
             await kandy.send('Happy "Birthday"!')
 
         await self.cakedays()
 
     @daily_loop.before_loop
-    async def before_loop(self):
+    async def before_loop(self) -> None:
-        """
+        """Actions run before the loop starts. Want to wait for bot to be ready and get the current cycle."""
-        Actions run before the loop starts. Want to wait for bot to be ready and get the current cycle.
-        """
         await self.bot.wait_until_ready()
 
         # Bot needs to know guilds to get the current cycle.
@@ -67,8 +69,9 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
 
     def get_election_cycle(self) -> ElectionCycle:
         """
-        Creates an object for the current election cycle if one is active. An election is considered active
+        Creates an object for the current election cycle if one is active.
-        between the election start and the term start.
+
+        An election is considered active between the election start and the term start.
 
         Returns:
             ElectionCycle: Current election cycle, None if there is no election happening.
@@ -83,13 +86,11 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
         return ElectionCycle(cycle, config, self.bot.get_guild(config.params.guild_id))
 
     def update_birthdays(self) -> None:
-        """
+        """Goes through database to collect all birthdays that are today. Adds user's id to birthday list."""
-        Goes through database to collect all birthdays that are today. Adds user's id to birthday list.
-        """
         birthday_list.clear()
 
         # kandy's 1% chance
-        if random.randint(0, 99) == 0:
+        if random.randint(0, 99) == 0:  # noqa: S311 isn't cryptography related.
             birthday_list.append(239547993106284544)
 
         today = datetime.now(tz=UTC).date()
@@ -102,8 +103,9 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
 
     async def cakedays(self) -> None:
         """
-        Loops through the guild's humans checking for joined_at dates that match today's date. Sends a message
+        Loops through the guild's humans checking for joined_at dates that match today's date.
-        saying happy cakeday.
+
+        Sends a message saying happy cakeday.
         """
         today = datetime.now(tz=UTC).date()
         guild: nextcord.Guild = self.bot.get_guild(self.bot.config.params.guild_id)

cogs/message_listener/__init__.py

@@ -1,6 +1,4 @@
-"""
+"""Defines cog for on message listener."""
-Defines cog for on message listener.
-"""
 
 import nextcord
 from nextcord.ext import commands
@@ -15,7 +13,7 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
         self.bot = bot
 
     @commands.Cog.listener()
-    async def on_message(self, message: nextcord.Message):
+    async def on_message(self, message: nextcord.Message) -> None:
         """Listener for message creation. Adds score and attachments to submission."""
         # don't want to process any messages from bot.
         if message.author.id == self.bot.user.id:
@@ -26,8 +24,8 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot):
+def setup(bot: commands.Bot) -> None:
-    """Adds function to bot"""
+    """Adds function to bot."""
     bot.add_cog(SubmissionListener(bot))
 
 

pyproject.toml

@@ -4,20 +4,25 @@ version = "0.1.0"
 description = "Dakiny's Discord Bot."
 authors = ["imcompiling <[email protected]>"]
 readme = "README.md"
+package-mode = false
 
 [tool.poetry.dependencies]
-python = "^3.11"
+python = "^3.12"
-gitpython = "3.1.43"
+gitpython = "^3.1.43"
-fastapi = "0.111.0"
+fastapi = "^0.111.0"
-hydra-core = "1.3.2"
+hydra-core = "^1.3.2"
-nextcord = "2.4.2"
+nextcord = "^2.6.0"
-pandas = "1.5.2"
+pandas = "^2.2.2"
-python-dotenv = "1.0.0"
+python-dotenv = "^1.0.1"
-pytz = "2022.7.1"
+pytz = "^2024.1"
-sqlalchemy = "1.4.46"
+sqlalchemy = "^2.0.30"
 aiofiles = "^23.2.1"
+setuptools = "^70.0.0"
 
 
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.4.5"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
@@ -51,6 +56,7 @@ exclude = [
     "node_modules",
     "site-packages",
     "venv",
+    "dakiny-messages",    # Don't need to lint this git repo.
 ]
 
 # Same as Black.
@@ -58,7 +64,7 @@ line-length = 120
 indent-width = 4
 
 # Assume Python 3.8
-target-version = "py311"
+target-version = "py312"
 
 [tool.ruff.lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
@@ -67,9 +73,10 @@ target-version = "py311"
 select = ["ALL"]
 ignore = [
     "ANN101",
+    "B008",   # I build SlashOptions as arguments.
     "COM812",
     "COM819",
-    "D107", # don't want docstrings on init functions
+    "D107",   # don't want docstrings on init functions
     "D203",
     "D206",
     "D212",

runtime.txt

@@ -1 +0,0 @@
-python-3.10.4

utils.py

@@ -26,6 +26,8 @@ NOMINEE_SPLITTER = "========================================\n\n"
 REPO_DIR = "./dakiny-messages"
 MESSAGES_DIR = f"{REPO_DIR}/messages"
 TEMPLATES_DIR = f"{REPO_DIR}/message_templates"
+MAX_DISCORD_MESSAGE_LENGTH = 2000
+GUILDS = [1000247361639030804, 239758371358638080]
 
 VoteType = StrEnum("VoteType", ["COUNCIL", "DISCORDMANAGER", "CLANLEADER"])
 
@@ -96,7 +98,7 @@ def get_current_election_cycle(config: DakinyConfig) -> int:
     Returns:
         int: cycle index for active election. None for no active cycle
     """
-    today = datetime.now(tz=UTC).date()
+    today = datetime.now(tz=UTC)
 
     for cycle, election in enumerate(config.election_cycles):
         if (
@@ -119,7 +121,7 @@ def get_quarter_cycle(config: DakinyConfig) -> int:
     Returns:
         int: cycle index for current cycle.
     """
-    today = datetime.now(tz=UTC).date()
+    today = datetime.now(tz=UTC)
     for cycle, election in enumerate(config.election_cycles):
         if (
             today.date() >= get_datetime(election.term_start).date()
@@ -150,7 +152,7 @@ def build_votes_str(config: DakinyConfig, guild: nextcord.Guild) -> str:
 
         for nominee in sorted(
             session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name,
+            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
         ):
             votes[nominee.MemberId] = 0
 
@@ -191,7 +193,7 @@ def build_highcouncil_votes_str(config: DakinyConfig, guild: nextcord.Guild) ->
 
         for nominee in sorted(
             session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name,
+            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
         ):
             cl_votes[nominee.MemberId] = 0
 
@@ -209,7 +211,7 @@ def build_highcouncil_votes_str(config: DakinyConfig, guild: nextcord.Guild) ->
 
         for nominee in sorted(
             session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name,
+            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
         ):
             dm_votes[nominee.MemberId] = 0
 
@@ -300,7 +302,7 @@ def decorate_dm_nomination(user_id: int, speech: str) -> str:
     return msg
 
 
-def record_event_points(config: DakinyConfig, users: Sequence[str], is_member: bool, add_points: int) -> None:  # noqa: FBT001
+def record_event_points(config: DakinyConfig, users: Sequence[str], add_points: int, *, is_member: bool) -> None:
     """
     Adds event points to all users listed.
 
@@ -310,8 +312,8 @@ def record_event_points(config: DakinyConfig, users: Sequence[str], is_member: b
     Args:
         config (DakinyConfig): Dakiny config for getting points
         users (Sequence[int]): users that participated and need points.
-        is_member (bool): whether the users are a discord member or not
         add_points (int): number of points to add
+        is_member (bool): whether the users are a discord member or not
     """
     quarter_name = get_quarter_name(config)
     with Session(engine) as session:
@@ -410,8 +412,10 @@ async def update_clan_messages(guild: nextcord.Guild, channel_updates: Sequence[
             for file_name in sorted_files:
                 message_name = f"{dir_name}/{file_name}"
                 file_path = f"{dir_path}/{file_name}"
-                with aiofiles.open(file_path, encoding="utf8") as reader:
+                async with aiofiles.open(file_path, encoding="utf8") as reader:
-                    await edit_clan_message(session, channel, message_name, reader.read(2000))
+                    await edit_clan_message(
+                        session, channel, message_name, await reader.read(MAX_DISCORD_MESSAGE_LENGTH)
+                    )
 
 
 async def get_clan_message_channel(session: Session, channel_name: str, guild: nextcord.Guild) -> nextcord.TextChannel:
@@ -536,14 +540,18 @@ async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig) ->
             .where(CouncilMembers.Elected == true())
         )
 
+        council_member_ids = sorted(
+            session.scalars(stmt), key=lambda user_id: guild.get_member(user_id).display_name.lower()
+        )
+
         council_members_strs = [
-            f"<@{user_id}>" for user_id in session.scalars(stmt) if user_id not in (discord_manager, clan_leader)
+            f"<@{user_id}>" for user_id in council_member_ids if user_id not in (discord_manager, clan_leader)
         ]
 
         quarter = get_quarter_name(config)
 
-        with aiofiles.open(f"{TEMPLATES_DIR}/council_members.txt", encoding="utf8") as file:
+        async with aiofiles.open(f"{TEMPLATES_DIR}/council_members.txt", encoding="utf8") as file:
-            message = file.read()
+            message = await file.read()
             message = message.format(
                 quarter=quarter,
                 council="\n".join(council_members_strs),