Define the /time at command.

Added the /time gametime command.

.gitignore

@@ -125,9 +125,6 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-# IDE
-.vscode/
-
 # logging
 nextcord.log
 

.vscode/extensions.json

@@ -0,0 +1,9 @@
+{
+    "recommendations": [
+        "ms-python.vscode-pylance",
+        "ms-python.python",
+        "ms-python.debugpy",
+        "charliermarsh.ruff",
+        "alexcvzz.vscode-sqlite"
+    ]
+}

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Module",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "main",
+            "justMyCode": true
+        }
+    ]
+}

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

README.md

@@ -7,3 +7,4 @@ Dakiny clan's own discord bot!
 - For Elections: Bot assumes that it always did the step before it. If the step before an action didn't happen, behavior is undefined.
 Object creation in the middle of a cycle is only there for restarting the bot. All relevant information should already
 exist in the database.
+- Bot is running on machine that is usint UTC time. All today() calls specify UTC time zone.

classes/election_cycle.py

@@ -1,14 +1,10 @@
-"""
+"""Contains the election cycle class."""
-Contains the election cycle class
-"""
 
 import collections
-from datetime import datetime, timedelta
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
 
 import nextcord
-from sqlalchemy import select, true, update
-from sqlalchemy.orm import Session
-
 from classes.nominate_highcouncil_views import NominateHighCouncilView
 from classes.nominate_views import NominateView
 from classes.voting_highcouncil_views import VoteHighcouncilView
@@ -20,6 +16,8 @@ from database_setup.sql_data_classes import (
     Votes,
     engine,
 )
+from sqlalchemy import select, true, update
+from sqlalchemy.orm import Session
 from utils import (
     TEMPLATES_DIR,
     VoteType,
@@ -30,9 +28,13 @@ from utils import (
     get_election_name,
 )
 
+REQUIRED_VOTES_TO_BE_ELECTED = 3
+
 
 class ElectionCycle:
     """
+    ElectionCycle class.
+
     This class represents all the dates required for an election cycle along with all the functions needed to operate
     the cycle.
     """
@@ -46,7 +48,6 @@ class ElectionCycle:
             config (DakinyConfig): The entire config object.
             guild (nextcord.Guild): The guild that this election is running in.
         """
-
         self.config: DakinyConfig = config
         self.cycle = cycle
         self.election_cycle = self.config.election_cycles[self.cycle]
@@ -55,15 +56,9 @@ class ElectionCycle:
         self.term_end: datetime = get_datetime(self.election_cycle.term_end)
         self.voting_start: datetime = get_datetime(self.election_cycle.voting_start)
         self.voting_end: datetime = get_datetime(self.election_cycle.voting_end)
-        self.highcouncil_election_announce: datetime = get_datetime(
+        self.highcouncil_election_announce: datetime = get_datetime(self.election_cycle.highcouncil_election_announce)
-            self.election_cycle.highcouncil_election_announce
+        self.highcouncil_election_start: datetime = get_datetime(self.election_cycle.highcouncil_election_start)
-        )
+        self.highcouncil_election_end: datetime = get_datetime(self.election_cycle.highcouncil_election_end)
-        self.highcouncil_election_start: datetime = get_datetime(
-            self.election_cycle.highcouncil_election_start
-        )
-        self.highcouncil_election_end: datetime = get_datetime(
-            self.election_cycle.highcouncil_election_end
-        )
         self.guild: nextcord.Guild = guild
         self.election_over: bool = False
 
@@ -75,16 +70,11 @@ class ElectionCycle:
             list[str]: A list of message contents in the correct order. Must be a string because the message is too
             long.
         """
-
+        with Path(f"{TEMPLATES_DIR}/election_announcement.txt", encoding="utf8").open() as file:
-        with open(
-            f"{TEMPLATES_DIR}/election_announcement.txt", mode="r", encoding="utf8"
-        ) as file:
             message = file.read()
 
             next_election = get_datetime(
-                self.config.election_cycles[
+                self.config.election_cycles[(self.cycle + 1) % len(self.config.election_cycles)].election_start
-                    (self.cycle + 1) % len(self.config.election_cycles)
-                ].election_start
             )
 
             message = message.format(
@@ -108,23 +98,14 @@ class ElectionCycle:
         Returns:
             str: Message to send.
         """
-
+        with Path(f"{TEMPLATES_DIR}/highcouncil_election.txt", encoding="utf8").open() as file:
-        with open(
-            f"{TEMPLATES_DIR}/highcouncil_election.txt", mode="r", encoding="utf8"
-        ) as file:
             message = file.read()
 
             return message.format(
                 clan_council_elect_role_id=self.config.params.clan_council_elect_role_id,
-                highcouncil_election_announce=self.highcouncil_election_announce.strftime(
+                highcouncil_election_announce=self.highcouncil_election_announce.strftime("%B %d"),
-                    "%B %d"
+                highcouncil_election_start=self.highcouncil_election_start.strftime("%B %d"),
-                ),
+                highcouncil_election_end=self.highcouncil_election_end.strftime("%B %d"),
-                highcouncil_election_start=self.highcouncil_election_start.strftime(
-                    "%B %d"
-                ),
-                highcouncil_election_end=self.highcouncil_election_end.strftime(
-                    "%B %d"
-                ),
                 term_start=self.term_start.strftime("%B %d"),
             )
 
@@ -135,10 +116,7 @@ class ElectionCycle:
         Returns:
             str: Message to send.
         """
-
+        with Path(f"{TEMPLATES_DIR}/highcouncil_vote.txt", encoding="utf8").open() as file:
-        with open(
-            f"{TEMPLATES_DIR}/highcouncil_vote.txt", mode="r", encoding="utf8"
-        ) as file:
             message = file.read()
 
             return message.format(
@@ -153,12 +131,9 @@ class ElectionCycle:
         Returns:
             str: Message to send
         """
-
+        with Path(f"{TEMPLATES_DIR}/vote_start.txt", encoding="utf8").open() as file:
-        with open(f"{TEMPLATES_DIR}/vote_start.txt", mode="r", encoding="utf8") as file:
             message = file.read()
-            vote_end: datetime = get_datetime(
+            vote_end: datetime = get_datetime(self.config.election_cycles[self.cycle].voting_end)
-                self.config.election_cycles[self.cycle].voting_end
-            )
 
             return message.format(
                 clan_member_id=self.config.params.clan_member_role_id,
@@ -167,21 +142,15 @@ class ElectionCycle:
             )
 
     async def check_date(self) -> None:
-        """
+        """Function checks current date to see if something needs to be run."""
-        Function checks current date to see if something needs to be run.
+        today = datetime.now(tz=UTC)
-        """
-        today = datetime.today()
 
         # check all dates if action is needed
         if today.date() == self.election_start.date():
             await self.election_start_action()
         elif today.date() == self.voting_start.date():
             await self.voting_start_action()
-        elif (
+        elif (self.voting_end - timedelta(3)).date() <= today.date() < self.voting_end.date():
-            (self.voting_end - timedelta(3)).date()
-            <= today.date()
-            < self.voting_end.date()
-        ):
             await self.election_reminder()
         elif today.date() == self.voting_end.date():
             await self.voting_end_action()
@@ -191,20 +160,14 @@ class ElectionCycle:
             await self.term_start_action()
 
     async def election_start_action(self) -> None:
-        """
+        """Performs required actions for when the election cycle starts."""
-        Performs required actions for when the election cycle starts.
-        """
         # create new channel for election
-        parent: nextcord.TextChannel = self.guild.get_channel(
+        parent: nextcord.TextChannel = self.guild.get_channel(self.config.params.voting_parent_id)
-            self.config.params.voting_parent_id
-        )
         quarter_name: str = get_election_name(self.config)
 
         thread_msg: nextcord.Message = await parent.send(content=quarter_name)
 
-        thread: nextcord.Thread = await parent.create_thread(
+        thread: nextcord.Thread = await parent.create_thread(name=quarter_name, message=thread_msg)
-            name=quarter_name, message=thread_msg
-        )
 
         # post message announcing election
         # election start message is returned as an array of string because it is too long. send each string
@@ -213,9 +176,7 @@ class ElectionCycle:
         for index, message in enumerate(messages):
             # if last item, add the nominate button
             if index + 1 == len(messages):
-                nominate_msg: nextcord.Message = await thread.send(
+                nominate_msg: nextcord.Message = await thread.send(message, view=NominateView(self.config, self.guild))
-                    message, view=NominateView(self.config, self.guild)
-                )
             else:
                 await thread.send(message)
 
@@ -231,13 +192,13 @@ class ElectionCycle:
 
     async def voting_start_action(self) -> None:
         """
+        Actions performed when starting a vote.
+
         Sends message informing members that voting has started.
         Removes write permission from the general clan member role.
         """
         message = self.build_vote_start()
-        election_thread: nextcord.Thread = self.guild.get_thread(
+        election_thread: nextcord.Thread = self.guild.get_thread(self.get_election_info().ThreadId)
-            self.get_election_info().ThreadId
-        )
         await election_thread.send(message)
         vote_msg = await election_thread.send(
             build_votes_str(self.config, self.guild),
@@ -253,23 +214,14 @@ class ElectionCycle:
             session.commit()
 
             thread: nextcord.Thread = self.guild.get_thread(info.ThreadId)
-            nominate_msg: nextcord.Message = await thread.fetch_message(
+            nominate_msg: nextcord.Message = await thread.fetch_message(info.CouncilNominationMsgId)
-                info.CouncilNominationMsgId
-            )
             await nominate_msg.edit(view=None)
 
     async def voting_end_action(self) -> None:
-        """
+        """Performs required actions for when voting time has ended."""
-        Performs required actions for when voting time has ended.
-        """
-
         message = self.build_highcouncil_election_announce()
-        council_elect_role: nextcord.Role = self.guild.get_role(
+        council_elect_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            self.config.params.clan_council_elect_role_id
+        election_thread: nextcord.Thread = self.guild.get_thread(self.get_election_info().ThreadId)
-        )
-        election_thread: nextcord.Thread = self.guild.get_thread(
-            self.get_election_info().ThreadId
-        )
 
         nominate_msg: nextcord.Message = await election_thread.send(
             message, view=NominateHighCouncilView(self.config, self.guild)
@@ -279,13 +231,9 @@ class ElectionCycle:
 
         with Session(engine) as session:
             # remove vote button from vote message
-            stmt = select(ElectionInformation).where(
+            stmt = select(ElectionInformation).where(ElectionInformation.ElectionCycle == election_name)
-                ElectionInformation.ElectionCycle == election_name
-            )
             info = session.scalar(stmt)
-            vote_msg: nextcord.Message = await election_thread.fetch_message(
+            vote_msg: nextcord.Message = await election_thread.fetch_message(info.CouncilVoteMsgId)
-                info.CouncilVoteMsgId
-            )
             await vote_msg.edit(view=None)
 
             # add the highcouncil nomination message to election information
@@ -301,7 +249,7 @@ class ElectionCycle:
             vote_count = collections.Counter(session.scalars(stmt))
 
             for user_id, votes in vote_count.items():
-                if votes >= 3:
+                if votes >= REQUIRED_VOTES_TO_BE_ELECTED:
                     stmt = (
                         select(CouncilMembers)
                         .where(CouncilMembers.ElectionCycle == election_name)
@@ -319,14 +267,9 @@ class ElectionCycle:
                     )
 
     async def highcouncil_election_start_action(self) -> None:
-        """
+        """Performs required actions for when the highcouncil is elected."""
-        Performs required actions for when the highcouncil is elected.
-        """
-
         message = self.build_highcouncil_vote_start()
-        election_thread: nextcord.Thread = self.guild.get_thread(
+        election_thread: nextcord.Thread = self.guild.get_thread(self.get_election_info().ThreadId)
-            self.get_election_info().ThreadId
-        )
         await election_thread.send(message)
         vote_msg = await election_thread.send(
             build_highcouncil_votes_str(self.config, self.guild),
@@ -342,24 +285,15 @@ class ElectionCycle:
             session.commit()
 
             # remove highcouncil nomination view
-            nomination_msg: nextcord.Message = await election_thread.fetch_message(
+            nomination_msg: nextcord.Message = await election_thread.fetch_message(info.HighCouncilNominationMsgId)
-                info.HighCouncilNominationMsgId
-            )
             await nomination_msg.edit(view=None)
 
     async def term_start_action(self) -> None:
-        """
+        """Marks the election as over."""
-        Marks the election as over.
-        """
-
         self.election_over = True
 
-        elect_role: nextcord.Role = self.guild.get_role(
+        elect_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            self.config.params.clan_council_elect_role_id
+        council_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_role_id)
-        )
-        council_role: nextcord.Role = self.guild.get_role(
-            self.config.params.clan_council_role_id
-        )
 
         election_cycle = get_election_name(self.config)
 
@@ -422,9 +356,7 @@ class ElectionCycle:
 
             session.commit()
 
-        election_thread: nextcord.Thread = self.guild.get_thread(
+        election_thread: nextcord.Thread = self.guild.get_thread(self.get_election_info().ThreadId)
-            self.get_election_info().ThreadId
-        )
 
         # clear view from vote message
         stmt = select(ElectionInformation.HighCouncilVoteMsgId).where(
@@ -434,15 +366,11 @@ class ElectionCycle:
         vote_msg: nextcord.Message = await election_thread.fetch_message(vote_msg_id)
         await vote_msg.edit(view=None)
 
-        highcouncil_msg: str = (
+        highcouncil_msg: str = f"Congratulations for our high council members!\nClan Leader: <@{cl_winner}>\n"
-            f"Congratulations for our high council members!\nClan Leader: <@{cl_winner}>\n"
-        )
         highcouncil_msg += f"Discord Manager: <@{dm_winner}>"
         await election_thread.send(highcouncil_msg)
 
-        await election_thread.send(
+        await election_thread.send("This election cycle is now over. Thank you everyone for participating!")
-            "This election cycle is now over. Thank you everyone for participating!"
-        )
 
         await election_thread.edit(archived=True, locked=True)
         await edit_clan_council_info(self.guild, self.config)
@@ -454,7 +382,6 @@ class ElectionCycle:
         Returns:
             ElectionInformation: The information from the database about the current election.
         """
-
         with Session(engine) as session:
             stmt = select(ElectionInformation).where(
                 ElectionInformation.ElectionCycle == get_election_name(self.config)
@@ -462,13 +389,8 @@ class ElectionCycle:
             return session.scalar(stmt)
 
     async def election_reminder(self) -> None:
-        """
+        """Sends a message to general chat reminder clan about election."""
-        Sends a message to general chat reminder clan about election.
+        general: nextcord.TextChannel = self.guild.get_channel(self.config.params.general_channel_id)
-        """
-
-        general: nextcord.TextChannel = self.guild.get_channel(
-            self.config.params.general_channel_id
-        )
 
         message = f"Reminder to <@&{self.config.params.clan_member_role_id}>! Clan elections are happening! Head over "
         message += f"to <#{self.get_election_info().ThreadId}> to cast your vote!"

classes/gitea_webhook.py

@@ -4,8 +4,6 @@
 
 from __future__ import annotations
 
-from typing import List
-
 from pydantic import BaseModel
 
 
@@ -29,9 +27,9 @@ class Commit(BaseModel):
     committer: Committer
     verification: None
     timestamp: str
-    added: List[str]
+    added: list[str]
-    removed: List[str]
+    removed: list[str]
-    modified: List[str]
+    modified: list[str]
 
 
 class HeadCommit(BaseModel):
@@ -42,9 +40,9 @@ class HeadCommit(BaseModel):
     committer: Committer
     verification: None
     timestamp: str
-    added: List[str]
+    added: list[str]
-    removed: List[str]
+    removed: list[str]
-    modified: List[str]
+    modified: list[str]
 
 
 class Owner(BaseModel):
@@ -187,7 +185,7 @@ class GiteaWebhook(BaseModel):
     before: str
     after: str
     compare_url: str
-    commits: List[Commit]
+    commits: list[Commit]
     total_commits: int
     head_commit: HeadCommit
     repository: Repository

classes/nominate_highcouncil_views.py

@@ -1,14 +1,11 @@
-"""
+"""Contains various views to be used in the high council nomination process."""
-Contains various views to be used in the high council nomination process.
-"""
 
 import nextcord
+from config import DakinyConfig
+from database_setup.sql_data_classes import CouncilMembers, engine
 from nextcord.interactions import Interaction
 from sqlalchemy import select
 from sqlalchemy.orm import Session
-
-from config import DakinyConfig
-from database_setup.sql_data_classes import CouncilMembers, engine
 from utils import (
     NOMINEE_SPLITTER,
     decorate_cl_nomination,
@@ -19,14 +16,16 @@ from utils import (
 
 class NominateDMModal(nextcord.ui.Modal):
     """
-    Modal for nominating oneself. User writes a speech and then the callback sends the speech into the correct channel.
+    Modal for nominating oneself.
+
+    User writes a speech and then the callback sends the speech into the correct channel.
     """
 
     def __init__(
         self,
         config: DakinyConfig,
         usr_id: int,
-        usr_nominated: bool,
+        usr_nominated: bool,  # noqa: FBT001
         speech_content: str,
     ):
         super().__init__(
@@ -55,7 +54,6 @@ class NominateDMModal(nextcord.ui.Modal):
             interaction (Interaction): Interaction with user.
 
         """
-
         speech = decorate_dm_nomination(interaction.user.id, self.speech.value)
 
         with Session(engine) as session:
@@ -74,26 +72,22 @@ class NominateDMModal(nextcord.ui.Modal):
                 council_elect.DiscordManagerSpeechId = msg.id
                 session.commit()
             else:
-                msg: nextcord.Message = await interaction.channel.fetch_message(
+                msg: nextcord.Message = await interaction.channel.fetch_message(council_elect.DiscordManagerSpeechId)
-                    council_elect.DiscordManagerSpeechId
+                await msg.edit(content=decorate_dm_nomination(interaction.user.id, self.speech.value))
-                )
-                await msg.edit(
-                    content=decorate_dm_nomination(
-                        interaction.user.id, self.speech.value
-                    )
-                )
 
 
 class NominateCLModal(nextcord.ui.Modal):
     """
-    Modal for nominating oneself. User writes a speech and then the callback sends the speech into the correct channel.
+    Modal for nominating oneself.
+
+    User writes a speech and then the callback sends the speech into the correct channel.
     """
 
     def __init__(
         self,
         config: DakinyConfig,
         usr_id: int,
-        usr_nominated: bool,
+        usr_nominated: bool,  # noqa: FBT001
         speech_content: str,
     ):
         super().__init__(
@@ -122,7 +116,6 @@ class NominateCLModal(nextcord.ui.Modal):
             interaction (Interaction): Interaction with user.
 
         """
-
         speech = decorate_cl_nomination(interaction.user.id, self.speech.value)
 
         with Session(engine) as session:
@@ -141,20 +134,12 @@ class NominateCLModal(nextcord.ui.Modal):
                 council_elect.ClanLeaderSpeechId = msg.id
                 session.commit()
             else:
-                msg: nextcord.Message = await interaction.channel.fetch_message(
+                msg: nextcord.Message = await interaction.channel.fetch_message(council_elect.ClanLeaderSpeechId)
-                    council_elect.ClanLeaderSpeechId
+                await msg.edit(content=decorate_cl_nomination(interaction.user.id, self.speech.value))
-                )
-                await msg.edit(
-                    content=decorate_cl_nomination(
-                        interaction.user.id, self.speech.value
-                    )
-                )
 
 
 class NominateHighCouncilView(nextcord.ui.View):
-    """
+    """The buttons to press to start your High Council nomination."""
-    The buttons to press to start your High Council nomination.
-    """
 
     def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
@@ -166,10 +151,10 @@ class NominateHighCouncilView(nextcord.ui.View):
         style=nextcord.ButtonStyle.primary,
         custom_id="nominate-dm",
     )
-    async def nominate_dm(
+    async def nominate_dm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
         """
+        Button for nominating oneself for Discord Manager.
+
         Gathers previous information about the user if they have already nominated themselves, then launches
         the nomination modal to get their speech.
 
@@ -177,12 +162,8 @@ class NominateHighCouncilView(nextcord.ui.View):
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
-
         # enforce council elect only
-        if (
+        if self.guild.get_role(self.config.params.clan_council_elect_role_id) not in interaction.user.roles:
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
             await interaction.response.send_message(
                 f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
@@ -203,15 +184,11 @@ class NominateHighCouncilView(nextcord.ui.View):
             # user needs to exist to get here anyways...
             if obj.DiscordManagerSpeechId is not None:
                 usr_nominated = True
-                msg = await interaction.channel.fetch_message(
+                msg = await interaction.channel.fetch_message(obj.DiscordManagerSpeechId)
-                    obj.DiscordManagerSpeechId
-                )
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
         await interaction.response.send_modal(
-            NominateDMModal(
+            NominateDMModal(self.config, interaction.user.id, usr_nominated, speech_content)
-                self.config, interaction.user.id, usr_nominated, speech_content
-            )
         )
 
     @nextcord.ui.button(
@@ -219,10 +196,10 @@ class NominateHighCouncilView(nextcord.ui.View):
         style=nextcord.ButtonStyle.primary,
         custom_id="nominate-cl",
     )
-    async def nominate_cl(
+    async def nominate_cl(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
         """
+        Button for nominating oneself for Clan Leader.
+
         Gathers previous information about the user if they have already nominated themselves, then launches
         the nomination modal to get their speech.
 
@@ -230,12 +207,8 @@ class NominateHighCouncilView(nextcord.ui.View):
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
-
         # enforce council elect only
-        if (
+        if self.guild.get_role(self.config.params.clan_council_elect_role_id) not in interaction.user.roles:
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
             await interaction.response.send_message(
                 f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
@@ -260,7 +233,5 @@ class NominateHighCouncilView(nextcord.ui.View):
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
         await interaction.response.send_modal(
-            NominateCLModal(
+            NominateCLModal(self.config, interaction.user.id, usr_nominated, speech_content)
-                self.config, interaction.user.id, usr_nominated, speech_content
-            )
         )

classes/nominate_views.py

@@ -1,27 +1,26 @@
-"""
+"""Contains various views to be used in the nomination process."""
-Contains various views to be used in the nomination process.
-"""
 
 import nextcord
+from config import DakinyConfig
+from database_setup.sql_data_classes import CouncilMembers, engine
 from nextcord.interactions import Interaction
 from sqlalchemy import select
 from sqlalchemy.orm import Session
-
-from config import DakinyConfig
-from database_setup.sql_data_classes import CouncilMembers, engine
 from utils import NOMINEE_SPLITTER, decorate_nomination, get_election_name
 
 
 class NominateModal(nextcord.ui.Modal):
     """
-    Modal for nominating oneself. User writes a speech and then the callback sends the speech into the correct channel.
+    Modal for nominating oneself.
+
+    User writes a speech and then the callback sends the speech into the correct channel.
     """
 
     def __init__(
         self,
         config: DakinyConfig,
         usr_id: int,
-        usr_nominated: bool,
+        usr_nominated: bool,  # noqa: FBT001
         speech_content: str,
     ):
         super().__init__(
@@ -50,7 +49,6 @@ class NominateModal(nextcord.ui.Modal):
             interaction (Interaction): Interaction with user.
 
         """
-
         speech = decorate_nomination(interaction.user.id, self.speech.value)
 
         with Session(engine) as session:
@@ -74,18 +72,12 @@ class NominateModal(nextcord.ui.Modal):
                 )
                 obj = session.scalar(stmt)
 
-                msg: nextcord.Message = await interaction.channel.fetch_message(
+                msg: nextcord.Message = await interaction.channel.fetch_message(obj.SpeechMsgId)
-                    obj.SpeechMsgId
+                await msg.edit(content=decorate_nomination(interaction.user.id, self.speech.value))
-                )
-                await msg.edit(
-                    content=decorate_nomination(interaction.user.id, self.speech.value)
-                )
 
 
 class NominateView(nextcord.ui.View):
-    """
+    """The button to press to start your nomination."""
-    The button to press to start your nomination.
-    """
 
     def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
@@ -97,10 +89,10 @@ class NominateView(nextcord.ui.View):
         style=nextcord.ButtonStyle.primary,
         custom_id="nominate",
     )
-    async def nominate(
+    async def nominate(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
         """
+        Button to nominate onself for Clan Council.
+
         Gathers previous information about the user if they have already nominated themselves, then launches
         the nomination modal to get their speech.
 
@@ -108,12 +100,8 @@ class NominateView(nextcord.ui.View):
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
-
         # enforce members only
-        if (
+        if self.guild.get_role(self.config.params.clan_member_role_id) not in interaction.user.roles:
-            self.guild.get_role(self.config.params.clan_member_role_id)
-            not in interaction.user.roles
-        ):
             await interaction.response.send_message(
                 f"You must have the <@&{self.config.params.clan_member_role_id}> role to vote.",
                 ephemeral=True,
@@ -136,7 +124,5 @@ class NominateView(nextcord.ui.View):
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
         await interaction.response.send_modal(
-            NominateModal(
+            NominateModal(self.config, interaction.user.id, usr_nominated, speech_content)
-                self.config, interaction.user.id, usr_nominated, speech_content
-            )
         )

classes/pyproject.toml

@@ -0,0 +1,10 @@
+[tool.ruff]
+# Extend the `pyproject.toml` file in the parent directory...
+extend = "../pyproject.toml"
+
+# Exclude a variety of commonly ignored directories.
+exclude = ["gitea_webhook.py"]
+
+[tool.ruff.lint]
+# ignore implicit-namespace-package in this directory.
+ignore = ["INP001"]

classes/voting_highcouncil_views.py

@@ -1,15 +1,6 @@
-"""
+"""Contains various views to be used while voting for high council. Controls the logic when performing the vote."""
-Contains various views to be used while voting for high council. Controls the logic when performing the vote.
-"""
-
-from typing import List
 
 import nextcord
-from nextcord import SelectOption
-from nextcord.interactions import Interaction
-from sqlalchemy import exc, select, update
-from sqlalchemy.orm import Session
-
 from config import DakinyConfig
 from database_setup.sql_data_classes import (
     CouncilMembers,
@@ -17,13 +8,17 @@ from database_setup.sql_data_classes import (
     Votes,
     engine,
 )
+from nextcord import SelectOption
+from nextcord.interactions import Interaction
+from sqlalchemy import exc, select, update
+from sqlalchemy.orm import Session
 from utils import VoteType, build_highcouncil_votes_str, get_election_name
 
 
 class VoteSelect(nextcord.ui.StringSelect):
-    def __init__(
+    """Vote view string select."""
-        self, options: List["SelectOption"], config: DakinyConfig, election_type: str
+
-    ) -> None:
+    def __init__(self, options: list["SelectOption"], config: DakinyConfig, election_type: str) -> None:
         super().__init__(
             placeholder="Choose 1",
             min_values=1,
@@ -33,7 +28,16 @@ class VoteSelect(nextcord.ui.StringSelect):
         self.config = config
         self.election_type = election_type
 
-    async def callback(self, interaction: Interaction):
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        Callback override for the StringSelect.
+
+        Submits the High Council vote to database if a user is selected. Handles adding vs editing a vote.
+        Returns message informing user that vote has been recorded.
+
+        Args:
+            interaction (Interaction): Interaction with this callback.
+        """
         election_name: str = get_election_name(self.config)
         with Session(engine) as session:
             stmt = select(ElectionInformation.HighCouncilVoteMsgId).where(
@@ -41,10 +45,7 @@ class VoteSelect(nextcord.ui.StringSelect):
             )
             vote_msg_id = session.scalar(stmt)
 
-            if self.values[0] == "Abstain":
+            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
-                voted_for = None
-            else:
-                voted_for = int(self.values[0])
 
             new_vote = Votes(
                 ElectionCycle=election_name,
@@ -71,23 +72,16 @@ class VoteSelect(nextcord.ui.StringSelect):
                 session.commit()
 
         vote_message_str = build_highcouncil_votes_str(self.config, interaction.guild)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
-            vote_msg_id
-        )
         await vote_msg.edit(content=vote_message_str)
 
-        if voted_for is not None:
+        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "You have abstained from voting."
-            msg = f"You have voted for <@{voted_for}>"
-        else:
-            msg = "You have abstained from voting."
 
         await interaction.edit(content=msg, view=None)
 
 
 class VoteHighcouncilView(nextcord.ui.View):
-    """
+    """The button to press to start voting for HighCouncil."""
-    The button to press to start voting for HighCouncil.
-    """
 
     def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
@@ -99,10 +93,10 @@ class VoteHighcouncilView(nextcord.ui.View):
         style=nextcord.ButtonStyle.primary,
         custom_id="vote-cl",
     )
-    async def vote_cl(
+    async def vote_cl(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
         """
+        Button to vote for Clan Leader.
+
         Enforces only council elect vote. Gets election cycle, creates voting
         options for clan leader (checking if user has voted already),
         then sends the voting view.
@@ -111,12 +105,8 @@ class VoteHighcouncilView(nextcord.ui.View):
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
-
         # enforce council elect only
-        if (
+        if self.guild.get_role(self.config.params.clan_council_elect_role_id) not in interaction.user.roles:
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
             await interaction.response.send_message(
                 f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
@@ -151,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(
@@ -162,11 +152,7 @@ class VoteHighcouncilView(nextcord.ui.View):
             )
 
         view = nextcord.ui.View()
-        view.add_item(
+        view.add_item(VoteSelect(options=options, config=self.config, election_type=VoteType.CLANLEADER))
-            VoteSelect(
-                options=options, config=self.config, election_type=VoteType.CLANLEADER
-            )
-        )
 
         await interaction.response.send_message(
             content="Please vote for a Clan Leader!",
@@ -179,10 +165,10 @@ class VoteHighcouncilView(nextcord.ui.View):
         style=nextcord.ButtonStyle.primary,
         custom_id="vote-dm",
     )
-    async def vote_dm(
+    async def vote_dm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
         """
+        Button to vote for Discord Manager.
+
         Enforces only council elect vote. Gets election cycle, creates voting
         options for discord manager (checking if user has voted already),
         then sends the voting view.
@@ -191,12 +177,8 @@ class VoteHighcouncilView(nextcord.ui.View):
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
-
         # enforce council elect only
-        if (
+        if self.guild.get_role(self.config.params.clan_council_elect_role_id) not in interaction.user.roles:
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
             await interaction.response.send_message(
                 f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
@@ -231,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

@@ -1,15 +1,6 @@
-"""
+"""Contains various views to be used while voting. Controls the logic when performing the vote."""
-Contains various views to be used while voting. Controls the logic when performing the vote.
-"""
-
-from typing import List
 
 import nextcord
-from nextcord import SelectOption
-from nextcord.interactions import Interaction
-from sqlalchemy import exc, select, update
-from sqlalchemy.orm import Session
-
 from config import DakinyConfig
 from database_setup.sql_data_classes import (
     CouncilMembers,
@@ -17,11 +8,17 @@ from database_setup.sql_data_classes import (
     Votes,
     engine,
 )
+from nextcord import SelectOption
+from nextcord.interactions import Interaction
+from sqlalchemy import exc, select, update
+from sqlalchemy.orm import Session
 from utils import VoteType, build_votes_str, get_election_name
 
 
 class VoteSelect(nextcord.ui.StringSelect):
-    def __init__(self, options: List["SelectOption"], config: DakinyConfig) -> None:
+    """Vote view string select."""
+
+    def __init__(self, options: list["SelectOption"], config: DakinyConfig) -> None:
         super().__init__(
             placeholder="Choose 1",
             min_values=1,
@@ -30,7 +27,16 @@ class VoteSelect(nextcord.ui.StringSelect):
         )
         self.config = config
 
-    async def callback(self, interaction: Interaction):
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        Callback override for the StringSelect.
+
+        Submits the vote to database if a user is selected. Handles adding vs editing a vote. Returns message
+        informing user that vote has been recorded.
+
+        Args:
+            interaction (Interaction): Interaction with this callback.
+        """
         election_name = get_election_name(self.config)
         with Session(engine) as session:
             stmt = select(ElectionInformation.CouncilVoteMsgId).where(
@@ -38,10 +44,7 @@ class VoteSelect(nextcord.ui.StringSelect):
             )
             vote_msg_id = session.scalar(stmt)
 
-            if self.values[0] == "Abstain":
+            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
-                voted_for = None
-            else:
-                voted_for = int(self.values[0])
 
             new_vote = Votes(
                 ElectionCycle=election_name,
@@ -67,49 +70,36 @@ class VoteSelect(nextcord.ui.StringSelect):
                 session.commit()
 
         vote_message_str = build_votes_str(self.config, interaction.guild)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
-            vote_msg_id
-        )
         await vote_msg.edit(content=vote_message_str)
 
-        if voted_for is not None:
+        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "You have abstained from voting."
-            msg = f"You have voted for <@{voted_for}>"
-        else:
-            msg = "You have abstained from voting."
 
         await interaction.edit(content=msg, view=None)
 
 
 class VoteView(nextcord.ui.View):
-    """
+    """The button to press to start your nomination."""
-    The button to press to start your nomination.
-    """
 
     def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
         self.config = config
         self.guild = guild
 
-    @nextcord.ui.button(
+    @nextcord.ui.button(label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote")
-        label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote"
+    async def vote(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-    )
-    async def vote(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
         """
-        Enforces only members vote. Gets election cycle, creates voting options (checking if user has voted already),
+        Enforces only members vote.
+
+        Gets election cycle, creates voting options (checking if user has voted already),
         then sends the voting view.
 
         Args:
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
-
         # enforce members only
-        if (
+        if self.guild.get_role(self.config.params.clan_member_role_id) not in interaction.user.roles:
-            self.guild.get_role(self.config.params.clan_member_role_id)
-            not in interaction.user.roles
-        ):
             await interaction.response.send_message(
                 f"You must have the <@&{self.config.params.clan_member_role_id}> role to vote.",
                 ephemeral=True,
@@ -127,9 +117,7 @@ class VoteView(nextcord.ui.View):
             )
             voted_for = session.scalar(stmt)
 
-            stmt = select(CouncilMembers.MemberId).where(
+            stmt = select(CouncilMembers.MemberId).where(CouncilMembers.ElectionCycle == election)
-                CouncilMembers.ElectionCycle == election
-            )
 
             options = [
                 SelectOption(
@@ -142,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,36 +34,28 @@ 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
+            file for files in [commit.modified + commit.added for commit in hook_info.commits] for file in files
-            for list in [commit.modified + commit.added for commit in hook_info.commits]
-            for file in list
         ]
 
-        template_updates = {
+        template_updates = {file.split("/")[1] for file in modified_files if "message_templates" in file}
-            file.split("/")[1] for file in modified_files if "message_templates" in file
+        channel_updates = {file.split("/")[1] for file in modified_files if file.split("/")[1] not in template_updates}
-        }
-        channel_updates = {
-            file.split("/")[1]
-            for file in modified_files
-            if file.split("/")[1] not in template_updates
-        }
 
         self.origin.pull()
         guild: nextcord.Guild = self.bot.get_guild(self.config.params.guild_id)
@@ -68,18 +64,14 @@ class ClanMessages(commands.Cog, name="Clan Messages"):
 
         # if the council members template has changed, update the message
         if "council_members.txt" in template_updates:
-            await edit_clan_council_info(
+            await edit_clan_council_info(self.bot.get_guild(self.config.params.guild_id), self.config)
-                self.bot.get_guild(self.config.params.guild_id), self.config
-            )
 
         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)
@@ -87,19 +79,15 @@ class ClanMessages(commands.Cog, name="Clan Messages"):
         self.origin = self.repo.remote("origin")
 
         if self.config.params.git_branch == "test":
-            self.repo.create_head("test", self.origin.refs.test).set_tracking_branch(
+            self.repo.create_head("test", self.origin.refs.test).set_tracking_branch(self.origin.refs.test).checkout()
-                self.origin.refs.test
-            ).checkout()
         else:
-            self.repo.create_head("main", self.origin.refs.main).set_tracking_branch(
+            self.repo.create_head("main", self.origin.refs.main).set_tracking_branch(self.origin.refs.main).checkout()
-                self.origin.refs.main
-            ).checkout()
 
         self.origin.pull()
 
 
 # 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,22 +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,36 +9,30 @@ 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(
         self,
         interaction: nextcord.Interaction,
-        name: str = nextcord.SlashOption(
+        name: str = nextcord.SlashOption(required=True, description="Name of the event that was hosted."),
-            required=True, description="Name of the event that was hosted."
-        ),
         host: nextcord.Member = nextcord.SlashOption(
             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.
 
@@ -49,12 +41,8 @@ class RecordCog(commands.Cog, name="Record Commands"):
             name (str): Name of the event.
             host (nextcord.Member, optional): Alternative host to user using command.
         """
-
         # check role
-        if (
+        if interaction.guild.get_role(self.bot.config.params.event_host_role_id) not in interaction.user.roles:
-            interaction.guild.get_role(self.bot.config.params.event_host_role_id)
-            not in interaction.user.roles
-        ):
             await interaction.response.send_message(
                 f"You must have the <@&{self.bot.config.params.event_host_role_id}> role to record an event.",
                 ephemeral=True,
@@ -79,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.
     """
 
@@ -95,45 +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(
+    async def cancel(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+        """Cancels event submission. Removes embed and view."""
-    ):
+        await interaction.response.edit_message("Canceled", ephemeral=True, embed=None, view=None)
-        """
-        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]))
-        """
-        await interaction.response.send_modal(
-            ParticipantModal(interaction.message.embeds[0])
-        )
 
     @nextcord.ui.button(label="Confirm", style=nextcord.ButtonStyle.green, row=1)
-    async def confirm(
+    async def confirm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
         """
-        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  # noqa: PD011 not a pandas object
-        discord_users = self.event_participants.values.members
         if discord_users:
-            discord_users_list: list[str] = [
+            discord_users_list: list[str] = [str(user.id) for user in discord_users if user.id is not self.host_id]
-                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
@@ -142,33 +119,28 @@ 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(
+        record_event_points(self.config, [self.host_id], self.config.params.event_host_points, is_member=True)
-            self.config, [self.host_id], True, self.config.params.event_host_points
-        )
 
-        event_channel: nextcord.TextChannel = interaction.guild.get_channel(
+        event_channel: nextcord.TextChannel = interaction.guild.get_channel(self.config.params.event_post_channel_id)
-            self.config.params.event_post_channel_id
-        )
         await event_channel.send(embed=interaction.message.embeds[0])
-        await interaction.response.edit_message(
+        await interaction.response.edit_message(content="Event has been submitted.", view=None, embed=None)
-            content="Event has been submitted.", view=None, embed=None
-        )
 
         self.stop()
 
 
 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,
@@ -198,20 +170,22 @@ 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(
+        self.embed.set_field_at(index=1, name="Non-Discord Participants", value=self.participants.value)
-            index=1, name="Non-Discord Participants", value=self.participants.value
-        )
 
         await interaction.response.edit_message(embed=self.embed)
 
 
 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__(
@@ -221,10 +195,14 @@ 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(
+        participants: str = "\n".join([f"<@{participant.id}>" for participant in self.values.members])
-            [f"<@{participant.id}>" for participant in self.values.members]
-        )
         embed.set_field_at(0, name="Participants", value=participants)
         await interaction.response.edit_message(embed=embed)

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,24 +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(
+    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
-        default_member_permissions=nextcord.Permissions(administrator=True)
+    async def refresh(self, interaction: nextcord.Interaction) -> None:
-    )
+        """Parent slash command for refresh. Never called."""
-    async def refresh(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for refresh. Never called.
-        """
 
     @refresh.subcommand(description="Force refresh all of the bot managed messages.")
     async def messages(
@@ -38,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:
@@ -50,9 +43,7 @@ class RefreshCog(commands.Cog, name="Refresh Commands"):
 
         if channel is None:
             channel_updates = [
-                dir_name
+                dir_name for dir_name in os.listdir(MESSAGES_DIR) if Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()
-                for dir_name in os.listdir(MESSAGES_DIR)
-                if os.path.isdir(f"{MESSAGES_DIR}/{dir_name}")
             ]
         else:
             channel_updates = [channel.name]
@@ -61,14 +52,14 @@ 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:
             interaction (nextcord.Interaction): Interaction with the command.
         """
         await edit_clan_council_info(interaction.guild, self.bot.config)
-        await interaction.response.send_message(
+        await interaction.response.send_message("Clan Council Info message updated.", ephemeral=True)
-            "Clan Council Info message updated.", ephemeral=True
-        )

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,39 +9,30 @@ 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(
+        presence_str: str = nextcord.SlashOption(description="The presence to remove", required=True),
-            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:
             stmt = delete(Presences).where(Presences.Id == presence_id)
@@ -53,34 +42,26 @@ 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(
+    async def presence_autocomplete(self, interaction: nextcord.Interaction, presence_str: str) -> None:
-        self, interaction: nextcord.Interaction, presence_str: str
-    ):
         """
         Collects all presences that start with the presence string.
+
         Sends autocomplete dict {Presence Name, Presence Id}
 
         Args:
             interaction (nextcord.Interaction): Interaction with command.
             presence_str (str): String to run autocomplete on.
         """
-
         with Session(engine) as session:
             stmt = select(Presences)
-            presences_dict: "dict[str,str]" = {
+            presences_dict: dict[str,str] = {pres.Presence: str(pres.Id) for pres in session.scalars(stmt)}
-                pres.Presence: str(pres.Id) for pres in session.scalars(stmt)
-            }
 
             # if empty compare string
             if not presence_str:
-                await interaction.response.send_autocomplete(
+                await interaction.response.send_autocomplete(dict(list(presences_dict.items())[:25]))
-                    dict(list(presences_dict.items())[:25])
-                )
                 return
 
-            autofilled_presences: "dict[str,str]" = {
+            autofilled_presences: dict[str,str] = {
-                pres: pres_id
+                pres: pres_id for pres, pres_id in presences_dict.items() if presence_str.lower() in pres.lower()
-                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,35 +1,29 @@
-"""
+"""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(
+    @request.subcommand(description="Request to add a presence to the bot's presence list.")
-        description="Request to add a presence to the bot's presence list."
-    )
     async def add_presence(
         self,
         interaction: nextcord.Interaction,
@@ -39,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.
 
@@ -47,16 +41,11 @@ class RequestCog(commands.Cog, name="Request Commands"):
             interaction (nextcord.Interaction): Interaction that invoked the command.
             presence (str): The presence to add.
         """
-
         config: DakinyConfig = self.bot.config
         content = f'<@{interaction.user.id}> would like to add presence "{presence}."'
         view = PresenceChange(presence)
-        await self.bot.get_channel(config.params.admin_channel_id).send(
+        await self.bot.get_channel(config.params.admin_channel_id).send(content=content, view=view)
-            content=content, view=view
+        await interaction.response.send_message("Request sent to admins.", ephemeral=True)
-        )
-        await interaction.response.send_message(
-            "Request sent to admins.", ephemeral=True
-        )
 
     @request.subcommand(description="Request to change your Dakiny nickname")
     async def change_nickname(
@@ -68,30 +57,23 @@ 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}."'
         view = UsernameRequest(interaction.user.id, new_nickname)
-        await self.bot.get_channel(config.params.admin_channel_id).send(
+        await self.bot.get_channel(config.params.admin_channel_id).send(content=content, view=view)
-            content=content, view=view
+        await interaction.response.send_message("Request sent to admins.", ephemeral=True)
-        )
-        await interaction.response.send_message(
-            "Request sent to admins.", ephemeral=True
-        )
 
 
 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,
@@ -103,11 +85,11 @@ class UsernameRequest(nextcord.ui.View):
         self.new_nickname = new_nickname
 
     @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
-    async def approve(
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
         """
-        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.
 
@@ -119,10 +101,7 @@ class UsernameRequest(nextcord.ui.View):
         if user is not None:
             try:
                 await user.edit(nick=self.new_nickname)
-                content = (
+                content = interaction.message.content + f"\nApproved by <@{interaction.user.id}>."
-                    interaction.message.content
-                    + f"\nApproved by <@{interaction.user.id}>."
-                )
                 await interaction.response.edit_message(content=content, view=None)
             except nextcord.errors.Forbidden:
                 await interaction.response.send_message(
@@ -133,9 +112,7 @@ class UsernameRequest(nextcord.ui.View):
                     interaction.message.content
                     + "\n\nFailed. User has too high permissions for bot to change nickname."
                 )
-                await interaction.followup.edit_message(
+                await interaction.followup.edit_message(interaction.message.id, content=content, view=None)
-                    interaction.message.id, content=content, view=None
-                )
         else:
             await interaction.response.edit_message(
                 content="An error occured while changing the user's nickname.",
@@ -143,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.
 
@@ -156,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,
@@ -168,29 +143,26 @@ class PresenceChange(nextcord.ui.View):
         self.presence = presence
 
     @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
-    async def approve(
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
         """
-        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:
             button (nextcord.ui.Button): Unused.
             interaction (nextcord.Interaction): The interaction of the user clicking the button.
         """
-
         with Session(engine) as session:
             session.add(Presences(Presence=self.presence))
             session.commit()
 
-        content = (
+        content = interaction.message.content + f"\nApproved by <@{interaction.user.id}>."
-            interaction.message.content + f"\nApproved by <@{interaction.user.id}>."
-        )
         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,8 +1,6 @@
-"""
+"""Contains commands and views for set commands."""
-Contains commands and views for set commands.
-"""
 
-from datetime import datetime
+from datetime import UTC, datetime
 
 import nextcord
 from nextcord.ext import commands
@@ -14,35 +12,23 @@ 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(
+    @set.subcommand(description="Sets your birth month and day for the Birthday Fun. Use 0/0 to remove yourself.")
-        description="Sets your birth month and day for the Birthday Fun. Use 0/0 to remove yourself."
-    )
     async def birthday(
         self,
         interaction: nextcord.Interaction,
-        month: int = nextcord.SlashOption(
+        month: int = nextcord.SlashOption(required=True, min_value=0, max_value=12, description="Your birth month."),
-            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:
-        day: int = nextcord.SlashOption(
-            required=True, min_value=0, max_value=31, description="Your birth day."
-        ),
-    ):
         """
         Sets a user's birthday in the database. Removes on input 0/0. If birthday is today, adds to the birthday_list.
 
@@ -51,14 +37,11 @@ class setCog(commands.Cog, name="Set Commands"):
             month (int, optional): The month a user was born. Is SlashOption.
             day (int, optional): The day a user was born. Is SlashOption.
         """
-
         # Must be deferred, apparently datetime takes a little bit on invalid dates.
         await interaction.response.defer(ephemeral=True)
 
         if month == 0 and day == 0:
-            stmt = delete(UserBirthday).where(
+            stmt = delete(UserBirthday).where(UserBirthday.UserId == interaction.user.id)
-                UserBirthday.UserId == interaction.user.id
-            )
             with Session(engine) as session:
                 session.execute(stmt)
                 session.commit()
@@ -66,22 +49,18 @@ class setCog(commands.Cog, name="Set Commands"):
                 return
 
         # check if valid day
-        today = datetime.today()
+        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(
+            await interaction.followup.send(f"Invalid date: {month}/{day}.", ephemeral=True)
-                f"Invalid date: {month}/{day}.", ephemeral=True
-            )
             return
 
         # If the birthday is today, add to birthday_list
         if today.date() == birthday.date():
             birthday_list.append(interaction.user.id)
 
-        new_birthday = UserBirthday(
+        new_birthday = UserBirthday(UserId=interaction.user.id, Birthday=f"{month}/{day}")
-            UserId=interaction.user.id, Birthday=f"{month}/{day}"
-        )
         with Session(engine) as session:
             try:
                 session.add(new_birthday)
@@ -89,13 +68,9 @@ class setCog(commands.Cog, name="Set Commands"):
             except IntegrityError:
                 # User already has birthday, change it instead.
                 session.rollback()
-                stmt = select(UserBirthday).where(
+                stmt = select(UserBirthday).where(UserBirthday.UserId == interaction.user.id)
-                    UserBirthday.UserId == interaction.user.id
-                )
                 new_birthday = session.scalar(stmt)
                 new_birthday.Birthday = f"{month}/{day}"
                 session.commit()
 
-        await interaction.followup.send(
+        await interaction.followup.send(f"Birthday set to {month}/{day}.", ephemeral=True)
-            f"Birthday set to {month}/{day}.", ephemeral=True
-        )

cogs/commands/test.py

@@ -1,53 +1,49 @@
-"""
+"""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(
             get_current_election_cycle(config),
@@ -55,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(
@@ -72,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(
@@ -89,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(
@@ -106,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),
@@ -117,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),
@@ -128,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),
@@ -139,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,65 +33,61 @@ 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(
+                await interaction.followup.send(f'Quarter "{quarter_name}" is invalid.', ephemeral=True)
-                    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(user_id)).display_name.lower() for user_id in user_ids]
-                            interaction.guild.get_member(int(id)).display_name
-                            for id in user_ids
-                        ]
                     ),
                 )
                 sorted_non_members = non_members.sort_values(by="UserId")
-                sorted_all = pd.concat(
+                sorted_all = pd.concat([sorted_members, sorted_non_members], ignore_index=True, sort=False)
-                    [sorted_members, sorted_non_members], ignore_index=True, sort=False
-                )
                 for row in sorted_all.itertuples():
                     userid = row.UserId
                     points = row.Points
                     discord_member = row.DiscordMember
-                    content += (
+                    content += f"<@{userid}>: {points}\n" if discord_member else f"{userid}: {points}\n"
-                        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(
+                await interaction.followup.send("Message length is too long, please select search to limit results.")
-                    "Message length is too long, please select search to limit results."
-                )
                 return
 
             await interaction.followup.send(content=content, ephemeral=True)
@@ -112,14 +100,14 @@ 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)
 
@@ -128,21 +116,13 @@ class ViewCog(commands.Cog, name="View Commands"):
             presences = session.scalars(stmt)
 
             if search:
-                message = "\n".join(
+                message = "\n".join([presence for presence in presences if search.lower() in presence.lower()])
-                    [
-                        presence
-                        for presence in presences
-                        if search.lower() in presence.lower()
-                    ]
-                )
             else:
                 message = "\n".join(list(presences))
 
         await interaction.followup.send(content=message, ephemeral=True)
 
-    @view.subcommand(
+    @view.subcommand(description="Shows all voters and who they voted for in a given election.")
-        description="Shows all voters and who they voted for in a given election."
-    )
     async def votes(
         self,
         interaction: nextcord.Interaction,
@@ -154,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.
@@ -163,20 +145,14 @@ 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)
-        stmt = (
-            select(Votes)
-            .where(Votes.ElectionCycle == election_name)
-            .where(Votes.Type == election_type)
-        )
 
         with Session(engine) as session:
             # Check if election exists.
             if session.scalar(stmt) is None:
-                await interaction.response.send_message(
+                await interaction.response.send_message(f"Invalid election: {election_name}.", ephemeral=True)
-                    f"Invalid election: {election_name}.", ephemeral=True
-                )
                 return
 
             votes = session.scalars(stmt)
@@ -191,9 +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(
+    async def election_autocomplete(self, interaction: nextcord.Interaction, election_name: str) -> None:
-        self, interaction: nextcord.Interaction, election_name: str
-    ):
         """
         Collects all elections that start with the election string.
 
@@ -201,7 +175,6 @@ class ViewCog(commands.Cog, name="View Commands"):
             interaction (nextcord.Interaction): Interaction with command.
             election_name (str): String to run autocomplete on.
         """
-
         with Session(engine) as session:
             stmt = select(Votes.ElectionCycle).distinct()
             elections = session.scalars(stmt)
@@ -211,17 +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
+                election for election in elections if election.lower().startswith(election_name.lower())
-                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(
+    async def event_points_autocomplete(self, interaction: nextcord.Interaction, quarter_name: str) -> None:
-        self, interaction: nextcord.Interaction, quarter_name: str
-    ):
         """
         Collects all elections that start with the election string.
 
@@ -229,7 +198,6 @@ class ViewCog(commands.Cog, name="View Commands"):
             interaction (nextcord.Interaction): Interaction with command.
             quarter_name (str): String to run autocomplete on.
         """
-
         with Session(engine) as session:
             stmt = select(ParticipationPoints.Cycle).distinct()
             quarters = session.scalars(stmt)
@@ -239,9 +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
+                quarter for quarter in quarters if quarter.lower().startswith(quarter_name.lower())
-                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,10 +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,32 +15,24 @@ class BotPresence(commands.Cog, name="Bot Presence"):
         self.bot = bot
 
     @commands.Cog.listener()
-    async def on_guild_join(
+    async def on_guild_join(self, guild: nextcord.Guild) -> None:  # noqa: ARG002
-        self, guild: nextcord.Guild
-    ):  # pylint: disable=unused-argument
         """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(
+            presence = session.scalar(select(Presences.Presence).order_by(func.random()))
-                select(Presences.Presence).order_by(func.random())
-            )
 
-        await self.bot.change_presence(
+        await self.bot.change_presence(activity=nextcord.CustomActivity(presence))
-            activity=nextcord.CustomActivity(name="Custom Status", state=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 datetime, time
+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,14 +33,15 @@ 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.
         """
-
         if self.current_election is None:
             self.current_election = self.get_election_cycle()
 
@@ -49,19 +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.
@@ -69,13 +69,13 @@ 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.
         """
-
         config: DakinyConfig = self.bot.config
         cycle = get_current_election_cycle(config)
 
@@ -86,16 +86,14 @@ 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.today()
+        today = datetime.now(tz=UTC).date()
         birthday = f"{today.month}/{today.day}"
 
         stmt = select(UserBirthday.UserId).where(UserBirthday.Birthday == birthday)
@@ -105,20 +103,16 @@ 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.
-        """
 
-        today = datetime.today()
+        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)
-        announce_channel: nextcord.TextChannel = guild.get_channel(
+        announce_channel: nextcord.TextChannel = guild.get_channel(self.bot.config.params.general_channel_id)
-            self.bot.config.params.general_channel_id
-        )
 
         cakedays: list[nextcord.Member] = [
-            human
+            human for human in guild.humans if human.joined_at.month == today.month and human.joined_at.day == today.day
-            for human in guild.humans
-            if human.joined_at.month == today.month and human.joined_at.day == today.day
         ]
 
         for member in cakedays:

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))
 
 
@@ -38,8 +36,5 @@ async def birthday_action(message: nextcord.Message) -> None:
     Args:
         message (nextcord.Message): The message to check for a birthday person.
     """
-
+    if message.author.id in birthday_list or bool(set(message.raw_mentions) & set(birthday_list)):
-    if message.author.id in birthday_list or bool(
-        set(message.raw_mentions) & set(birthday_list)
-    ):
         await message.add_reaction("🎂")

config.py

@@ -1,15 +1,11 @@
-"""
+"""File contains classes defining the Hydra configuraton structure."""
-File contains classes defining the Hydra configuraton structure.
-"""
 
 from dataclasses import dataclass
 
 
 @dataclass
 class Params:
-    """
+    """Class defines the various configuration parameters."""
-    Class defines the various configuration parameters.
-    """
 
     admin_channel_id: int  # might want to rename this...
     announcement_category_id: int
@@ -32,9 +28,7 @@ class Params:
 
 @dataclass
 class ElectionCycle:
-    """
+    """Class defines relevant election dates."""
-    Class defines relevant election dates.
-    """
 
     election_start: str
     highcouncil_election_announce: str
@@ -49,9 +43,7 @@ class ElectionCycle:
 
 @dataclass
 class DakinyConfig:
-    """
+    """Class defines all configs required for Dakiny Bot."""
-    Class defines all configs required for Dakiny Bot.
-    """
 
     election_cycles: list[ElectionCycle]
     params: Params

database_setup/create_database.py

@@ -1,15 +1,13 @@
-"""
+"""Small script to create the database if it doesn't already exist."""
-Small script to create the database if it doesn't already exist.
-"""
 
 import sqlite3
-from os.path import exists
+from pathlib import Path
 
-if not exists("database/dakiny.db"):
+if not Path("database/dakiny.db").exists():
     with sqlite3.connect("database/dakiny.db") as con:
         cur = con.cursor()
 
-        with open("database_setup/database.sql", mode="r", encoding="utf-8") as file:
+        with Path("database_setup/database.sql", encoding="utf-8").open() as file:
             database_script = file.read()
             cur.executescript(database_script)
             con.commit()

database_setup/pyproject.toml

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

database_setup/sql_data_classes.py

@@ -1,6 +1,4 @@
-"""
+"""Simple file to set up the sqlalchemy connection to database."""
-Simple file to set up the sqlalchemy connection to database.
-"""
 
 from sqlalchemy import create_engine
 from sqlalchemy.ext.automap import automap_base

main.py

@@ -1,3 +1,5 @@
+"""Main file for bot."""
+
 import logging
 import os
 import sys
@@ -7,12 +9,12 @@ import nextcord
 from hydra.core.config_store import ConfigStore
 from nextcord.ext import commands
 
-import database_setup.create_database as create_database
 from classes.nominate_highcouncil_views import NominateHighCouncilView
 from classes.nominate_views import NominateView
 from classes.voting_highcouncil_views import VoteHighcouncilView
 from classes.voting_views import VoteView
 from config import DakinyConfig
+from database_setup import create_database
 
 cs = ConfigStore.instance()
 cs.store(name="dakiny_config", node=DakinyConfig)
@@ -22,14 +24,18 @@ birthday_list: list[int] = []
 logger = logging.getLogger("nextcord")
 logger.setLevel(logging.DEBUG)
 handler = logging.FileHandler(filename="nextcord.log", encoding="utf-8", mode="w")
-handler.setFormatter(
+handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s"))
-    logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s")
-)
 logger.addHandler(handler)
 
 
 @hydra.main(config_path="conf", config_name="config")
-def main(cfg: DakinyConfig):
+def main(cfg: DakinyConfig) -> None:
+    """
+    Builds and runs bot.
+
+    Args:
+        cfg (DakinyConfig): Passed in hydra configuration.
+    """
     # Allows privledged intents for monitoring members joining, roles editing, and role assignments
     # These need to be enabled in the developer portal as well
     intents = nextcord.Intents.default()
@@ -37,9 +43,6 @@ def main(cfg: DakinyConfig):
     # Required in order to read messages (eg. prefix commands)
     intents.message_content = True
 
-    # To enable the guilds priveleged intent:
-    # intents.guilds = True
-
     # To enable the members priveleged intent:
     intents.members = True
 
@@ -51,15 +54,15 @@ def main(cfg: DakinyConfig):
         bot.load_extension(f"cogs.{folder}")
 
     @bot.listen()
-    async def on_ready():
+    async def on_ready() -> None:
-        """When Discord is connected"""
+        """When Discord is connected."""
-        assert bot.user is not None
+        assert bot.user is not None  # noqa: S101 documentation does this
-        create_database  # pylint: disable=pointless-statement
+        create_database  # noqa: B018
         bot.add_view(NominateView(cfg, bot.get_guild(cfg.params.guild_id)))
         bot.add_view(NominateHighCouncilView(cfg, bot.get_guild(cfg.params.guild_id)))
         bot.add_view(VoteView(cfg, bot.get_guild(cfg.params.guild_id)))
         bot.add_view(VoteHighcouncilView(cfg, bot.get_guild(cfg.params.guild_id)))
-        print(f"{bot.user.name} has connected to Discord!")
+        print(f"{bot.user.name} has connected to Discord!")  # noqa: T201 TODO make logging to print my stuff to console
 
     # Run Discord bot
     bot.run(bot.config.params.discord_token)

pyproject.toml

@@ -4,19 +4,131 @@ 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"
+
+[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",
+    "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"

runtime.txt

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

utils.py

@@ -1,12 +1,13 @@
-"""
+"""File contains util functions."""
-File contains util functions.
-"""
 
+import calendar
 import os
-from datetime import datetime
+from collections.abc import Sequence
+from datetime import UTC, datetime
 from enum import StrEnum
-from typing import Sequence
+from pathlib import Path
 
+import aiofiles
 import nextcord
 from sqlalchemy import select, true, update
 from sqlalchemy.orm import Session
@@ -25,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"])
 
@@ -39,23 +42,24 @@ def get_datetime(day: str) -> datetime:
     Returns:
         datetime: Datetime representation of Month/Day.
     """
-    year = datetime.today().year
+    today = datetime.now(tz=UTC).date()
+    year = today.year
     month = int(day.split("/")[0])
     day = int(day.split("/")[1])
 
     # ensure that year rolls over if current month is December and the next month is less than 12.
-    if datetime.today().month == 12 and month < 12:
+    if today.month == calendar.DECEMBER and month < calendar.DECEMBER:
         year += 1
 
-    if datetime.today().month == 1 and month > 1:
+    if today.month == calendar.JANUARY and month > calendar.JANUARY:
         year -= 1
 
-    return datetime(year, month, day)
+    return datetime(year, month, day, tzinfo=UTC)
 
 
 def get_election_name(config: DakinyConfig) -> str:
     """
-    Builds the unique name of the current election cycle
+    Builds the unique name of the current election cycle.
 
     Args:
         config (DakinyConfig): the config used to know the election cycle.
@@ -63,7 +67,6 @@ def get_election_name(config: DakinyConfig) -> str:
     Returns:
         str: the name of the election cycle
     """
-
     cycle = get_current_election_cycle(config)
     current_cycle = config.election_cycles[cycle]
     return f"vote-{get_datetime(current_cycle.term_start).year}-{current_cycle.name}"
@@ -71,7 +74,7 @@ def get_election_name(config: DakinyConfig) -> str:
 
 def get_quarter_name(config: DakinyConfig) -> str:
     """
-    Builds the name of the current cycle/quarter
+    Builds the name of the current cycle/quarter.
 
     Args:
         config (DakinyConfig): the config used to know the election cycle.
@@ -79,7 +82,6 @@ def get_quarter_name(config: DakinyConfig) -> str:
     Returns:
         str: the name of the cycle.
     """
-
     cycle = get_quarter_cycle(config)
     current_cycle = config.election_cycles[cycle]
 
@@ -96,8 +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)
-    today = datetime.today()
 
     for cycle, election in enumerate(config.election_cycles):
         if (
@@ -112,7 +113,7 @@ def get_current_election_cycle(config: DakinyConfig) -> int:
 
 def get_quarter_cycle(config: DakinyConfig) -> int:
     """
-    Returns the index for the current cycle/quarter. Defined as between term start and end. Shouldn't return none
+    Returns the index for the current cycle/quarter. Defined as between term start and end. Shouldn't return none.
 
     Args:
         config (DakinyConfig): Config object to use
@@ -120,8 +121,7 @@ def get_quarter_cycle(config: DakinyConfig) -> int:
     Returns:
         int: cycle index for current cycle.
     """
-
+    today = datetime.now(tz=UTC)
-    today = datetime.today()
     for cycle, election in enumerate(config.election_cycles):
         if (
             today.date() >= get_datetime(election.term_start).date()
@@ -143,27 +143,20 @@ def build_votes_str(config: DakinyConfig, guild: nextcord.Guild) -> str:
     Returns:
         str: String that contains all nominees and their votes.
     """
-
     votes: dict[int, int] = {}
 
     election_name = get_election_name(config)
 
     with Session(engine) as session:
-        stmt = select(CouncilMembers).where(
+        stmt = select(CouncilMembers).where(CouncilMembers.ElectionCycle == election_name)
-            CouncilMembers.ElectionCycle == election_name
-        )
 
         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
 
-        stmt = (
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name).where(Votes.Type == VoteType.COUNCIL)
-            select(Votes)
-            .where(Votes.ElectionCycle == election_name)
-            .where(Votes.Type == VoteType.COUNCIL)
-        )
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -181,12 +174,11 @@ def build_highcouncil_votes_str(config: DakinyConfig, guild: nextcord.Guild) ->
 
     Args:
         config (DakinyConfig): Daking config object
+        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
 
     Returns:
         str: String that contains all nominees and their votes.
-        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
     """
-
     cl_votes: dict[int, int] = {}
     dm_votes: dict[int, int] = {}
 
@@ -201,15 +193,11 @@ 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
 
-        stmt = (
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name).where(Votes.Type == VoteType.CLANLEADER)
-            select(Votes)
-            .where(Votes.ElectionCycle == election_name)
-            .where(Votes.Type == VoteType.CLANLEADER)
-        )
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -223,15 +211,11 @@ 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
 
-        stmt = (
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name).where(Votes.Type == VoteType.DISCORDMANAGER)
-            select(Votes)
-            .where(Votes.ElectionCycle == election_name)
-            .where(Votes.Type == VoteType.DISCORDMANAGER)
-        )
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -318,20 +302,19 @@ def decorate_dm_nomination(user_id: int, speech: str) -> str:
     return msg
 
 
-def record_event_points(
+def record_event_points(config: DakinyConfig, users: Sequence[str], add_points: int, *, is_member: bool) -> None:
-    config: DakinyConfig, users: Sequence[str], is_member: bool, add_points: int
-):
     """
-    Adds event points to all users listed. Checks if they don't exist in order to make a new entry, otherwise
+    Adds event points to all users listed.
+
+    Checks if they don't exist in order to make a new entry, otherwise
     adds points to the existing value. Can be used for hosting or participating.
 
     Args:
         config (DakinyConfig): Dakiny config for getting points
         users (Sequence[int]): users that participated and need points.
+        add_points (int): number of points to add
         is_member (bool): whether the users are a discord member or not
-        points (int): number of points to add
     """
-
     quarter_name = get_quarter_name(config)
     with Session(engine) as session:
         for user in users:
@@ -343,9 +326,7 @@ def record_event_points(
 
             points = session.scalar(stmt)
             if points is None:
-                add_points = get_allowed_points(
+                add_points = get_allowed_points(session, config.params.event_points_weekly_limit, user, add_points)
-                    session, config.params.event_points_weekly_limit, user, add_points
-                )
                 new_points = ParticipationPoints(
                     Cycle=quarter_name,
                     UserId=user,
@@ -354,19 +335,17 @@ def record_event_points(
                 )
                 session.add(new_points)
             else:
-                add_points = get_allowed_points(
+                add_points = get_allowed_points(session, config.params.event_points_weekly_limit, user, add_points)
-                    session, config.params.event_points_weekly_limit, user, add_points
-                )
                 points.Points += add_points
 
         session.commit()
 
 
-def get_allowed_points(
+def get_allowed_points(session: Session, points_limit: int, user: str, points: int) -> int:
-    session: Session, points_limit: int, user: str, points: int
-) -> int:
     """
-    Gets the maximum number of points a user can be given. Searches how many points they have been given
+    Gets the maximum number of points a user can be given.
+
+    Searches how many points they have been given
     this week and subtracts that from the weekly limit. If under, returns up to "points" number of points (will not
     go over points_limit) otherwise returns 0. Updates the limit object or creates a new one if one isn't found.
 
@@ -380,14 +359,9 @@ def get_allowed_points(
         int: how many points are allowed to be given to the user.
     """
     # check for limit
-    this_week = (
+    today = datetime.now(tz=UTC).date()
-        f"{datetime.today().isocalendar().year}-{datetime.today().isocalendar().week}"
+    this_week = f"{today.isocalendar().year}-{today.isocalendar().week}"
-    )
+    stmt = select(EventPointsLimit).where(EventPointsLimit.UserId == user).where(EventPointsLimit.Week == this_week)
-    stmt = (
-        select(EventPointsLimit)
-        .where(EventPointsLimit.UserId == user)
-        .where(EventPointsLimit.Week == this_week)
-    )
 
     # if under limit, can add up to however many points would make the current limit equal to the
     # allowed limit.
@@ -409,12 +383,13 @@ def get_allowed_points(
     return add_points
 
 
-async def update_clan_messages(guild: nextcord.Guild, channel_updates: Sequence[str]):
+async def update_clan_messages(guild: nextcord.Guild, channel_updates: Sequence[str]) -> None:
     """
     Updates all clan messages to contents in MESSAGES_DIR.
+
     Does not to any git work. Is expected to be called after git is pulled.
 
-    for ever directory, sort the files by number then edits/sends the message.
+    For every directory, sort the files by number then edits/sends the message.
 
     Channel fetching/management is handled by another function.
     Message editing and sending is handled by another function.
@@ -423,12 +398,7 @@ async def update_clan_messages(guild: nextcord.Guild, channel_updates: Sequence[
         guild (nextcord.Guild): Guild object that all channels and messages belong to.
         channel_updates: (Sequence[str]): a sequence of the channels to update.
     """
-
+    dirs = [dir_name for dir_name in channel_updates if Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()]
-    dirs = [
-        dir_name
-        for dir_name in channel_updates
-        if os.path.isdir(f"{MESSAGES_DIR}/{dir_name}")
-    ]
 
     with Session(engine) as session:
         for dir_name in dirs:
@@ -442,17 +412,17 @@ 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 open(file_path, "r", 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)
+                        session, channel, message_name, await reader.read(MAX_DISCORD_MESSAGE_LENGTH)
                     )
 
 
-async def get_clan_message_channel(
+async def get_clan_message_channel(session: Session, channel_name: str, guild: nextcord.Guild) -> nextcord.TextChannel:
-    session: Session, channel_name: str, guild: nextcord.Guild
-) -> nextcord.TextChannel:
     """
-    Used to obtain a channel from the guild object. Searches database for an id to get the channel. If that is not
+    Used to obtain a channel from the guild object.
+
+    Searches database for an id to get the channel. If that is not
     found, then searches through all channels in the guild to find one with a matching name. If that also doesn't
     turn up a channel, then creates it. Adds an entry into database for last two paths.
     Assumes that there is an open session to the database.
@@ -472,10 +442,7 @@ async def get_clan_message_channel(
         # channel is not tracked. see if it exists
         channels = await guild.fetch_channels()
         for channel in channels:
-            if (
+            if channel.name == channel_name and channel.__class__ is nextcord.TextChannel:
-                channel.name == channel_name
-                and channel.__class__ is nextcord.TextChannel
-            ):
                 ret_channel = channel
 
         if ret_channel is None:
@@ -499,11 +466,7 @@ async def get_clan_message_channel(
             channel_name,
             reason="Creating channel as required for by design of Dakiny-Messages repo.",
         )
-        stmt = (
+        stmt = update(Messages).where(Messages.Path == channel_name).values(Id=ret_channel.id)
-            update(Messages)
-            .where(Messages.Path == channel_name)
-            .values(Id=ret_channel.id)
-        )
         session.execute(stmt)
         session.commit()
         return ret_channel
@@ -514,9 +477,11 @@ async def edit_clan_message(
     channel: nextcord.TextChannel,
     message_name: str,
     message_content: str,
-):
+) -> None:
     """
-    Obtains a message id from database. If no id, then need to send a new message and record the id.
+    Obtains a message id from database.
+
+    If no id, then need to send a new message and record the id.
     If there is a message, then edit the message. If that message is not found in discord, then need to
     send a new message and record the id in the database.
 
@@ -540,14 +505,12 @@ async def edit_clan_message(
             await msg.edit(message_content)
         except nextcord.NotFound:
             msg = await channel.send(message_content)
-            stmt = (
+            stmt = update(Messages).where(Messages.Path == message_name).values(Id=msg.id)
-                update(Messages).where(Messages.Path == message_name).values(Id=msg.id)
-            )
             session.execute(stmt)
             session.commit()
 
 
-async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig):
+async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig) -> None:
     """
     Gets the winners of the elections and updates the perminant message that states the current council.
 
@@ -555,9 +518,7 @@ async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig):
         guild (nextcord.Guild): Guild object that to use to get channel.
         config (DakinyConfig): Configs
     """
-    clan_info_channel: nextcord.TextChannel = await guild.fetch_channel(
+    clan_info_channel: nextcord.TextChannel = await guild.fetch_channel(config.params.clan_info_channel_id)
-        config.params.clan_info_channel_id
-    )
 
     election = get_election_name(config)
     with Session(engine) as session:
@@ -579,18 +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"<@{id}>"
+            f"<@{user_id}>" for user_id in council_member_ids if user_id not in (discord_manager, clan_leader)
-            for id in session.scalars(stmt)
-            if id not in (discord_manager, clan_leader)
         ]
 
         quarter = get_quarter_name(config)
 
-        with open(
+        async with aiofiles.open(f"{TEMPLATES_DIR}/council_members.txt", encoding="utf8") as file:
-            f"{TEMPLATES_DIR}/council_members.txt", mode="r", encoding="utf8"
+            message = await file.read()
-        ) as file:
-            message = file.read()
             message = message.format(
                 quarter=quarter,
                 council="\n".join(council_members_strs),
@@ -598,6 +559,4 @@ async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig):
                 discord_manager=discord_manager,
             )
 
-        await edit_clan_message(
+        await edit_clan_message(session, clan_info_channel, "council_members.txt", message)
-            session, clan_info_channel, "council_members.txt", message
-        )