Merge branch '52-update-packages'

Add a discord max message length constant.
Move boolean argument to not be positional.

.gitignore

@@ -105,6 +105,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+poetry.lock
 
 # Spyder project settings
 .spyderproject
@@ -124,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,23 +1,19 @@
-FROM python:3.10.6-slim
+FROM python:3.11.9-slim
 
 # install dependencies
-RUN apt-get update && apt-get -y upgrade && apt-get -y install git
-
-RUN pip install --upgrade pip
+RUN apt-get update && apt-get -y upgrade && apt-get -y install git sqlite3
 
 WORKDIR /home
 
-COPY requirements.txt requirements.txt
-
 COPY config.py config.py
 COPY main.py main.py
 COPY utils.py utils.py
+COPY pyproject.toml pyproject.toml
 
-COPY bot_messages bot_messages/
 COPY classes classes/
 COPY cogs cogs/
 COPY database_setup database_setup/
 
-RUN pip install -r requirements.txt
+RUN pip install --upgrade pip && pip install poetry && poetry export -f requirements.txt --output requirements.txt && pip install -r requirements.txt
 
 CMD ["python3", "-u", "./main.py"]

README.md

@@ -6,4 +6,5 @@ Dakiny clan's own discord bot!
 ### Assumptions
 - 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.
+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,20 +16,25 @@ 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,
     build_highcouncil_votes_str,
     build_votes_str,
     edit_clan_council_info,
-    get_cl_election_name,
     get_datetime,
-    get_dm_election_name,
-    get_election_cycle_name,
+    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.
     """
@@ -47,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]
@@ -56,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.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_announce: datetime = get_datetime(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.guild: nextcord.Guild = guild
         self.election_over: bool = False
 
@@ -76,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 open(
-            f"{TEMPLATES_DIR}/election_announcement.txt", mode="r", encoding="utf8"
-        ) as file:
+        with Path(f"{TEMPLATES_DIR}/election_announcement.txt", encoding="utf8").open() as file:
             message = file.read()
 
             next_election = get_datetime(
-                self.config.election_cycles[
-                    (self.cycle + 1) % len(self.config.election_cycles)
-                ].election_start
+                self.config.election_cycles[(self.cycle + 1) % len(self.config.election_cycles)].election_start
             )
 
             message = message.format(
@@ -109,23 +98,14 @@ class ElectionCycle:
         Returns:
             str: Message to send.
         """
-
-        with open(
-            f"{TEMPLATES_DIR}/highcouncil_election.txt", mode="r", encoding="utf8"
-        ) as file:
+        with Path(f"{TEMPLATES_DIR}/highcouncil_election.txt", encoding="utf8").open() 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(
-                    "%B %d"
-                ),
-                highcouncil_election_start=self.highcouncil_election_start.strftime(
-                    "%B %d"
-                ),
-                highcouncil_election_end=self.highcouncil_election_end.strftime(
-                    "%B %d"
-                ),
+                highcouncil_election_announce=self.highcouncil_election_announce.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"),
             )
 
@@ -136,10 +116,7 @@ class ElectionCycle:
         Returns:
             str: Message to send.
         """
-
-        with open(
-            f"{TEMPLATES_DIR}/highcouncil_vote.txt", mode="r", encoding="utf8"
-        ) as file:
+        with Path(f"{TEMPLATES_DIR}/highcouncil_vote.txt", encoding="utf8").open() as file:
             message = file.read()
 
             return message.format(
@@ -154,12 +131,9 @@ class ElectionCycle:
         Returns:
             str: Message to send
         """
-
-        with open(f"{TEMPLATES_DIR}/vote_start.txt", mode="r", encoding="utf8") as file:
+        with Path(f"{TEMPLATES_DIR}/vote_start.txt", encoding="utf8").open() as file:
             message = file.read()
-            vote_end: datetime = get_datetime(
-                self.config.election_cycles[self.cycle].voting_end
-            )
+            vote_end: datetime = get_datetime(self.config.election_cycles[self.cycle].voting_end)
 
             return message.format(
                 clan_member_id=self.config.params.clan_member_role_id,
@@ -168,21 +142,15 @@ class ElectionCycle:
             )
 
     async def check_date(self) -> None:
-        """
-        Function checks current date to see if something needs to be run.
-        """
-        today = datetime.today()
+        """Function checks current date to see if something needs to be run."""
+        today = datetime.now(tz=UTC)
 
         # 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 (
-            (self.voting_end - timedelta(3)).date()
-            <= today.date()
-            < self.voting_end.date()
-        ):
+        elif (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()
@@ -192,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(
-            self.config.params.voting_parent_id
-        )
-        quarter_name: str = get_election_cycle_name(self.config)
+        parent: nextcord.TextChannel = self.guild.get_channel(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(
-            name=quarter_name, message=thread_msg
-        )
+        thread: nextcord.Thread = await parent.create_thread(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
@@ -214,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(
-                    message, view=NominateView(self.config, self.guild)
-                )
+                nominate_msg: nextcord.Message = await thread.send(message, view=NominateView(self.config, self.guild))
             else:
                 await thread.send(message)
 
@@ -232,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(
-            self.get_election_info().ThreadId
-        )
+        election_thread: nextcord.Thread = self.guild.get_thread(self.get_election_info().ThreadId)
         await election_thread.send(message)
         vote_msg = await election_thread.send(
             build_votes_str(self.config, self.guild),
@@ -247,47 +207,33 @@ class ElectionCycle:
 
         with Session(engine) as session:
             stmt = select(ElectionInformation).where(
-                ElectionInformation.ElectionCycle
-                == get_election_cycle_name(self.config)
+                ElectionInformation.ElectionCycle == get_election_name(self.config)
             )
             info = session.scalar(stmt)
             info.CouncilVoteMsgId = vote_msg.id
             session.commit()
 
             thread: nextcord.Thread = self.guild.get_thread(info.ThreadId)
-            nominate_msg: nextcord.Message = await thread.fetch_message(
-                info.CouncilNominationMsgId
-            )
+            nominate_msg: nextcord.Message = await thread.fetch_message(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(
-            self.config.params.clan_council_elect_role_id
-        )
-        election_thread: nextcord.Thread = self.guild.get_thread(
-            self.get_election_info().ThreadId
-        )
+        council_elect_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_elect_role_id)
+        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)
         )
 
-        election_name = get_election_cycle_name(self.config)
+        election_name = get_election_name(self.config)
 
         with Session(engine) as session:
             # remove vote button from vote message
-            stmt = select(ElectionInformation).where(
-                ElectionInformation.ElectionCycle == election_name
-            )
+            stmt = select(ElectionInformation).where(ElectionInformation.ElectionCycle == election_name)
             info = session.scalar(stmt)
-            vote_msg: nextcord.Message = await election_thread.fetch_message(
-                info.CouncilVoteMsgId
-            )
+            vote_msg: nextcord.Message = await election_thread.fetch_message(info.CouncilVoteMsgId)
             await vote_msg.edit(view=None)
 
             # add the highcouncil nomination message to election information
@@ -295,11 +241,15 @@ class ElectionCycle:
             session.commit()
 
             # add the highcouncil role to everyone with 3 or more votes. set elected to true in database
-            stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == election_name)
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionCycle == election_name)
+                .where(Votes.Type == VoteType.COUNCIL)
+            )
             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)
@@ -317,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(
-            self.get_election_info().ThreadId
-        )
+        election_thread: nextcord.Thread = self.guild.get_thread(self.get_election_info().ThreadId)
         await election_thread.send(message)
         vote_msg = await election_thread.send(
             build_highcouncil_votes_str(self.config, self.guild),
@@ -333,40 +278,30 @@ class ElectionCycle:
 
         with Session(engine) as session:
             stmt = select(ElectionInformation).where(
-                ElectionInformation.ElectionCycle
-                == get_election_cycle_name(self.config)
+                ElectionInformation.ElectionCycle == get_election_name(self.config)
             )
             info = session.scalar(stmt)
             info.HighCouncilVoteMsgId = vote_msg.id
             session.commit()
 
             # remove highcouncil nomination view
-            nomination_msg: nextcord.Message = await election_thread.fetch_message(
-                info.HighCouncilNominationMsgId
-            )
+            nomination_msg: nextcord.Message = await election_thread.fetch_message(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(
-            self.config.params.clan_council_elect_role_id
-        )
-        council_role: nextcord.Role = self.guild.get_role(
-            self.config.params.clan_council_role_id
-        )
+        elect_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_elect_role_id)
+        council_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_role_id)
+
+        election_cycle = get_election_name(self.config)
 
         with Session(engine) as session:
             # role management
             stmt = (
                 select(CouncilMembers.MemberId)
-                .where(
-                    CouncilMembers.ElectionCycle == get_election_cycle_name(self.config)
-                )
+                .where(CouncilMembers.ElectionCycle == election_cycle)
                 .where(CouncilMembers.Elected == true())
             )
 
@@ -383,14 +318,19 @@ class ElectionCycle:
 
             # announce high council members
             # ties are undefined behavior.
-            dm_election = get_dm_election_name(self.config)
-            cl_election = get_cl_election_name(self.config)
-            stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == dm_election)
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionCycle == election_cycle)
+                .where(Votes.Type == VoteType.DISCORDMANAGER)
+            )
             dm_votes = collections.Counter(session.scalars(stmt))
-            stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == cl_election)
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionCycle == election_cycle)
+                .where(Votes.Type == VoteType.CLANLEADER)
+            )
             cl_votes = collections.Counter(session.scalars(stmt))
 
-            election_cycle = get_election_cycle_name(self.config)
             try:
                 dm_winner = max(dm_votes, key=dm_votes.get)
                 stmt = (
@@ -416,27 +356,21 @@ class ElectionCycle:
 
             session.commit()
 
-        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)
 
         # clear view from vote message
         stmt = select(ElectionInformation.HighCouncilVoteMsgId).where(
-            ElectionInformation.ElectionCycle == get_election_cycle_name(self.config)
+            ElectionInformation.ElectionCycle == get_election_name(self.config)
         )
         vote_msg_id = session.scalar(stmt)
         vote_msg: nextcord.Message = await election_thread.fetch_message(vote_msg_id)
         await vote_msg.edit(view=None)
 
-        highcouncil_msg: str = (
-            f"Congratulations for our high council members!\n Clan Leader: <@{cl_winner}>\n"
-        )
+        highcouncil_msg: str = 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(
-            "This election cycle is now over. Thank you everyone for participating!"
-        )
+        await election_thread.send("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)
@@ -448,22 +382,15 @@ 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_cycle_name(self.config)
+                ElectionInformation.ElectionCycle == get_election_name(self.config)
             )
             return session.scalar(stmt)
 
     async def election_reminder(self) -> None:
-        """
-        Sends a message to general chat reminder clan about election.
-        """
-
-        general: nextcord.TextChannel = self.guild.get_channel(
-            self.config.params.general_channel_id
-        )
+        """Sends a message to general chat reminder clan about election."""
+        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

@@ -0,0 +1,193 @@
+# generated by datamodel-codegen:
+#   filename:  gitea_webhook.json
+#   timestamp: 2024-05-16T21:15:27+00:00
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Author(BaseModel):
+    name: str
+    email: str
+    username: str
+
+
+class Committer(BaseModel):
+    name: str
+    email: str
+    username: str
+
+
+class Commit(BaseModel):
+    id: str
+    message: str
+    url: str
+    author: Author
+    committer: Committer
+    verification: None
+    timestamp: str
+    added: list[str]
+    removed: list[str]
+    modified: list[str]
+
+
+class HeadCommit(BaseModel):
+    id: str
+    message: str
+    url: str
+    author: Author
+    committer: Committer
+    verification: None
+    timestamp: str
+    added: list[str]
+    removed: list[str]
+    modified: list[str]
+
+
+class Owner(BaseModel):
+    id: int
+    login: str
+    login_name: str
+    full_name: str
+    email: str
+    avatar_url: str
+    language: str
+    is_admin: bool
+    last_login: str
+    created: str
+    restricted: bool
+    active: bool
+    prohibit_login: bool
+    location: str
+    website: str
+    description: str
+    visibility: str
+    followers_count: int
+    following_count: int
+    starred_repos_count: int
+    username: str
+
+
+class Permissions(BaseModel):
+    admin: bool
+    push: bool
+    pull: bool
+
+
+class Repository(BaseModel):
+    id: int
+    owner: Owner
+    name: str
+    full_name: str
+    description: str
+    empty: bool
+    private: bool
+    fork: bool
+    template: bool
+    parent: None
+    mirror: bool
+    size: int
+    language: str
+    languages_url: str
+    html_url: str
+    url: str
+    link: str
+    ssh_url: str
+    clone_url: str
+    original_url: str
+    website: str
+    stars_count: int
+    forks_count: int
+    watchers_count: int
+    open_issues_count: int
+    open_pr_counter: int
+    release_counter: int
+    default_branch: str
+    archived: bool
+    created_at: str
+    updated_at: str
+    archived_at: str
+    permissions: Permissions
+    has_issues: bool
+    has_wiki: bool
+    has_pull_requests: bool
+    has_projects: bool
+    has_releases: bool
+    has_packages: bool
+    has_actions: bool
+    ignore_whitespace_conflicts: bool
+    allow_merge_commits: bool
+    allow_rebase: bool
+    allow_rebase_explicit: bool
+    allow_squash_merge: bool
+    allow_rebase_update: bool
+    default_delete_branch_after_merge: bool
+    default_merge_style: str
+    default_allow_maintainer_edit: bool
+    avatar_url: str
+    internal: bool
+    mirror_interval: str
+    mirror_updated: str
+    repo_transfer: None
+
+
+class Pusher(BaseModel):
+    id: int
+    login: str
+    login_name: str
+    full_name: str
+    email: str
+    avatar_url: str
+    language: str
+    is_admin: bool
+    last_login: str
+    created: str
+    restricted: bool
+    active: bool
+    prohibit_login: bool
+    location: str
+    website: str
+    description: str
+    visibility: str
+    followers_count: int
+    following_count: int
+    starred_repos_count: int
+    username: str
+
+
+class Sender(BaseModel):
+    id: int
+    login: str
+    login_name: str
+    full_name: str
+    email: str
+    avatar_url: str
+    language: str
+    is_admin: bool
+    last_login: str
+    created: str
+    restricted: bool
+    active: bool
+    prohibit_login: bool
+    location: str
+    website: str
+    description: str
+    visibility: str
+    followers_count: int
+    following_count: int
+    starred_repos_count: int
+    username: str
+
+
+class GiteaWebhook(BaseModel):
+    ref: str
+    before: str
+    after: str
+    compare_url: str
+    commits: list[Commit]
+    total_commits: int
+    head_commit: HeadCommit
+    repository: Repository
+    pusher: Pusher
+    sender: Sender

classes/nominate_highcouncil_views.py

@@ -1,32 +1,31 @@
-"""
-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,
     decorate_dm_nomination,
-    get_election_cycle_name,
+    get_election_name,
 )
 
 
 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,12 +54,11 @@ 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:
             # user already in table
-            cycle = get_election_cycle_name(self.config)
+            cycle = get_election_name(self.config)
             stmt = (
                 select(CouncilMembers)
                 .where(CouncilMembers.ElectionCycle == cycle)
@@ -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(
-                    council_elect.DiscordManagerSpeechId
-                )
-                await msg.edit(
-                    content=decorate_dm_nomination(
-                        interaction.user.id, self.speech.value
-                    )
-                )
+                msg: nextcord.Message = await interaction.channel.fetch_message(council_elect.DiscordManagerSpeechId)
+                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,12 +116,11 @@ 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:
             # user already in table
-            cycle = get_election_cycle_name(self.config)
+            cycle = get_election_name(self.config)
             stmt = (
                 select(CouncilMembers)
                 .where(CouncilMembers.ElectionCycle == cycle)
@@ -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(
-                    council_elect.ClanLeaderSpeechId
-                )
-                await msg.edit(
-                    content=decorate_cl_nomination(
-                        interaction.user.id, self.speech.value
-                    )
-                )
+                msg: nextcord.Message = await interaction.channel.fetch_message(council_elect.ClanLeaderSpeechId)
+                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(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
+    async def nominate_dm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
+        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,19 +162,15 @@ 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 (
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
+        if 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,
             )
             return
 
-        cycle = get_election_cycle_name(self.config)
+        cycle = get_election_name(self.config)
         usr_nominated = False
         speech_content = ""
         with Session(engine) as session:
@@ -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(
-                    obj.DiscordManagerSpeechId
-                )
+                msg = await interaction.channel.fetch_message(obj.DiscordManagerSpeechId)
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
         await interaction.response.send_modal(
-            NominateDMModal(
-                self.config, interaction.user.id, usr_nominated, speech_content
-            )
+            NominateDMModal(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(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
+    async def nominate_cl(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
+        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,19 +207,15 @@ 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 (
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
+        if 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,
             )
             return
 
-        cycle = get_election_cycle_name(self.config)
+        cycle = get_election_name(self.config)
         usr_nominated = False
         speech_content = ""
         with Session(engine) as session:
@@ -260,7 +233,5 @@ class NominateHighCouncilView(nextcord.ui.View):
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
         await interaction.response.send_modal(
-            NominateCLModal(
-                self.config, interaction.user.id, usr_nominated, speech_content
-            )
+            NominateCLModal(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_cycle_name
+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:
@@ -58,7 +56,7 @@ class NominateModal(nextcord.ui.Modal):
                 msg = await interaction.channel.send(speech)
 
                 council_member = CouncilMembers(
-                    ElectionCycle=get_election_cycle_name(self.config),
+                    ElectionCycle=get_election_name(self.config),
                     MemberId=interaction.user.id,
                     SpeechMsgId=msg.id,
                 )
@@ -66,7 +64,7 @@ class NominateModal(nextcord.ui.Modal):
                 session.commit()
             else:
                 # user already nominated, just need to update the election speech
-                cycle = get_election_cycle_name(self.config)
+                cycle = get_election_name(self.config)
                 stmt = (
                     select(CouncilMembers)
                     .where(CouncilMembers.ElectionCycle == cycle)
@@ -74,18 +72,12 @@ class NominateModal(nextcord.ui.Modal):
                 )
                 obj = session.scalar(stmt)
 
-                msg: nextcord.Message = await interaction.channel.fetch_message(
-                    obj.SpeechMsgId
-                )
-                await msg.edit(
-                    content=decorate_nomination(interaction.user.id, self.speech.value)
-                )
+                msg: nextcord.Message = await interaction.channel.fetch_message(obj.SpeechMsgId)
+                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(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
+    async def nominate(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
+        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,19 +100,15 @@ 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 (
-            self.guild.get_role(self.config.params.clan_member_role_id)
-            not in interaction.user.roles
-        ):
+        if 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,
             )
             return
 
-        cycle = get_election_cycle_name(self.config)
+        cycle = get_election_name(self.config)
         usr_nominated = False
         speech_content = ""
         with Session(engine) as session:
@@ -136,7 +124,5 @@ class NominateView(nextcord.ui.View):
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
         await interaction.response.send_modal(
-            NominateModal(
-                self.config, interaction.user.id, usr_nominated, speech_content
-            )
+            NominateModal(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.
-"""
-
-from typing import List
+"""Contains various views to be used while voting for high council. Controls the logic when performing the vote."""
 
 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,18 +8,17 @@ from database_setup.sql_data_classes import (
     Votes,
     engine,
 )
-from utils import (
-    build_highcouncil_votes_str,
-    get_cl_election_name,
-    get_dm_election_name,
-    get_election_cycle_name,
-)
+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__(
-        self, options: List["SelectOption"], config: DakinyConfig, election_type: str
-    ) -> None:
+    """Vote view string select."""
+
+    def __init__(self, options: list["SelectOption"], config: DakinyConfig, election_type: str) -> None:
         super().__init__(
             placeholder="Choose 1",
             min_values=1,
@@ -38,33 +28,30 @@ class VoteSelect(nextcord.ui.StringSelect):
         self.config = config
         self.election_type = election_type
 
-    async def callback(self, interaction: Interaction):
-        # decide on election type
-        match self.election_type:
-            case "cl":
-                election_name: str = get_cl_election_name(self.config)
-            case "dm":
-                election_name: str = get_dm_election_name(self.config)
-            case _:
-                # should never happen
-                raise ValueError('election type was not "cl" or "dm"')
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        Callback override for the StringSelect.
 
-        cycle: str = get_election_cycle_name(self.config)
+        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(
-                ElectionInformation.ElectionCycle == cycle
+                ElectionInformation.ElectionCycle == election_name
             )
             vote_msg_id = session.scalar(stmt)
 
-            if self.values[0] == "Abstain":
-                voted_for = None
-            else:
-                voted_for = int(self.values[0])
+            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
 
             new_vote = Votes(
                 ElectionCycle=election_name,
                 VoterId=interaction.user.id,
                 VotedForId=voted_for,
+                Type=self.election_type,
             )
 
             try:
@@ -72,34 +59,29 @@ class VoteSelect(nextcord.ui.StringSelect):
                 session.commit()
 
             except exc.IntegrityError:
+                # user already has a vote in the election and election type
                 session.rollback()
                 stmt = (
                     update(Votes)
                     .where(Votes.ElectionCycle == election_name)
                     .where(Votes.VoterId == interaction.user.id)
+                    .where(Votes.Type == self.election_type)
                     .values(VotedForId=voted_for)
                 )
                 session.execute(stmt)
                 session.commit()
 
         vote_message_str = build_highcouncil_votes_str(self.config, interaction.guild)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
-            vote_msg_id
-        )
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(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}>"
-        else:
-            msg = "You have abstained from voting."
+        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "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)
@@ -111,10 +93,10 @@ class VoteHighcouncilView(nextcord.ui.View):
         style=nextcord.ButtonStyle.primary,
         custom_id="vote-cl",
     )
-    async def vote_cl(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
+    async def vote_cl(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
+        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.
@@ -123,40 +105,38 @@ 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 (
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
+        if 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,
             )
             return
 
-        cycle: str = get_election_cycle_name(self.config)
-        election: str = get_cl_election_name(self.config)
+        election_name: str = get_election_name(self.config)
 
         with Session(engine) as session:
             stmt = (
                 select(Votes.VotedForId)
-                .where(Votes.ElectionCycle == election)
+                .where(Votes.ElectionCycle == election_name)
                 .where(Votes.VoterId == interaction.user.id)
+                .where(Votes.Type == VoteType.CLANLEADER)
             )
             voted_for = session.scalar(stmt)
 
             stmt = (
                 select(CouncilMembers.MemberId)
-                .where(CouncilMembers.ElectionCycle == cycle)
+                .where(CouncilMembers.ElectionCycle == election_name)
                 .filter(CouncilMembers.ClanLeaderSpeechId.is_not(None))
             )
 
             options = [
                 SelectOption(
-                    label=f"{self.guild.get_member(nominee).display_name} ☑️"
-                    if voted_for == nominee
-                    else f"{self.guild.get_member(nominee).display_name}",
+                    label=(
+                        f"{self.guild.get_member(nominee).display_name} ☑️"
+                        if voted_for == nominee
+                        else f"{self.guild.get_member(nominee).display_name}"
+                    ),
                     value=str(nominee),
                 )
                 for nominee in sorted(
@@ -172,9 +152,7 @@ class VoteHighcouncilView(nextcord.ui.View):
             )
 
         view = nextcord.ui.View()
-        view.add_item(
-            VoteSelect(options=options, config=self.config, election_type="cl")
-        )
+        view.add_item(VoteSelect(options=options, config=self.config, election_type=VoteType.CLANLEADER))
 
         await interaction.response.send_message(
             content="Please vote for a Clan Leader!",
@@ -187,10 +165,10 @@ class VoteHighcouncilView(nextcord.ui.View):
         style=nextcord.ButtonStyle.primary,
         custom_id="vote-dm",
     )
-    async def vote_dm(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
+    async def vote_dm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
+        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.
@@ -199,40 +177,38 @@ 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 (
-            self.guild.get_role(self.config.params.clan_council_elect_role_id)
-            not in interaction.user.roles
-        ):
+        if 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,
             )
             return
 
-        cycle: str = get_election_cycle_name(self.config)
-        election: str = get_dm_election_name(self.config)
+        election_name: str = get_election_name(self.config)
 
         with Session(engine) as session:
             stmt = (
                 select(Votes.VotedForId)
-                .where(Votes.ElectionCycle == election)
+                .where(Votes.ElectionCycle == election_name)
                 .where(Votes.VoterId == interaction.user.id)
+                .where(Votes.Type == VoteType.DISCORDMANAGER)
             )
             voted_for = session.scalar(stmt)
 
             stmt = (
                 select(CouncilMembers.MemberId)
-                .where(CouncilMembers.ElectionCycle == cycle)
+                .where(CouncilMembers.ElectionCycle == election_name)
                 .filter(CouncilMembers.DiscordManagerSpeechId.is_not(None))
             )
 
             options = [
                 SelectOption(
-                    label=f"{self.guild.get_member(nominee).display_name} ☑️"
-                    if voted_for == nominee
-                    else f"{self.guild.get_member(nominee).display_name}",
+                    label=(
+                        f"{self.guild.get_member(nominee).display_name} ☑️"
+                        if voted_for == nominee
+                        else f"{self.guild.get_member(nominee).display_name}"
+                    ),
                     value=str(nominee),
                 )
                 for nominee in sorted(
@@ -249,7 +225,11 @@ class VoteHighcouncilView(nextcord.ui.View):
 
         view = nextcord.ui.View()
         view.add_item(
-            VoteSelect(options=options, config=self.config, election_type="dm")
+            VoteSelect(
+                options=options,
+                config=self.config,
+                election_type=VoteType.DISCORDMANAGER,
+            )
         )
 
         await interaction.response.send_message(

classes/voting_views.py

@@ -1,15 +1,6 @@
-"""
-Contains various views to be used while voting. Controls the logic when performing the vote.
-"""
-
-from typing import List
+"""Contains various views to be used while voting. Controls the logic when performing the vote."""
 
 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 utils import build_votes_str, get_election_cycle_name
+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,23 +27,30 @@ class VoteSelect(nextcord.ui.StringSelect):
         )
         self.config = config
 
-    async def callback(self, interaction: Interaction):
-        election_name = get_election_cycle_name(self.config)
+    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(
                 ElectionInformation.ElectionCycle == election_name
             )
             vote_msg_id = session.scalar(stmt)
 
-            if self.values[0] == "Abstain":
-                voted_for = None
-            else:
-                voted_for = int(self.values[0])
+            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
 
             new_vote = Votes(
                 ElectionCycle=election_name,
                 VoterId=interaction.user.id,
                 VotedForId=voted_for,
+                Type=VoteType.COUNCIL,
             )
 
             try:
@@ -59,80 +63,69 @@ class VoteSelect(nextcord.ui.StringSelect):
                     update(Votes)
                     .where(Votes.ElectionCycle == election_name)
                     .where(Votes.VoterId == interaction.user.id)
+                    .where(Votes.Type == VoteType.COUNCIL)
                     .values(VotedForId=voted_for)
                 )
                 session.execute(stmt)
                 session.commit()
 
         vote_message_str = build_votes_str(self.config, interaction.guild)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
-            vote_msg_id
-        )
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(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}>"
-        else:
-            msg = "You have abstained from voting."
+        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "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(
-        label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote"
-    )
-    async def vote(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
+    @nextcord.ui.button(label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote")
+    async def vote(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
-        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 (
-            self.guild.get_role(self.config.params.clan_member_role_id)
-            not in interaction.user.roles
-        ):
+        if 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,
             )
             return
 
-        election: str = get_election_cycle_name(self.config)
+        election: str = get_election_name(self.config)
 
         with Session(engine) as session:
             stmt = (
                 select(Votes.VotedForId)
                 .where(Votes.ElectionCycle == election)
                 .where(Votes.VoterId == interaction.user.id)
+                .where(Votes.Type == VoteType.COUNCIL)
             )
             voted_for = session.scalar(stmt)
 
-            stmt = select(CouncilMembers.MemberId).where(
-                CouncilMembers.ElectionCycle == election
-            )
+            stmt = select(CouncilMembers.MemberId).where(CouncilMembers.ElectionCycle == election)
 
             options = [
                 SelectOption(
-                    label=f"{self.guild.get_member(nominee).display_name} ☑️"
-                    if voted_for == nominee
-                    else f"{self.guild.get_member(nominee).display_name}",
+                    label=(
+                        f"{self.guild.get_member(nominee).display_name} ☑️"
+                        if voted_for == nominee
+                        else f"{self.guild.get_member(nominee).display_name}"
+                    ),
                     value=str(nominee),
                 )
                 for nominee in sorted(

cogs/clan_messages/__init__.py

@@ -1,17 +1,20 @@
-"""
-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 config import DakinyConfig
-from utils import REPO_DIR, update_clan_messages
+from classes.gitea_webhook import GiteaWebhook
+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"
@@ -19,7 +22,9 @@ 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.
     """
 
@@ -29,34 +34,44 @@ class ClanMessages(commands.Cog, name="Clan Messages"):
         self.repo_setup()
 
     @commands.Cog.listener()
-    async def on_ready(self):
-        """
-        Triggers when the bot is in ready state. Adds the webhook listener to FastAPI and serves.
-        """
+    async def on_ready(self) -> None:
+        """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):
+    async def update_messages(self, hook_info: GiteaWebhook) -> dict:
         """
+        Triggered by webhook.
+
         Pulls from git and then calls method to update all the discord messages as described by the
         files in the git repo.
         """
+        # Get all modified/added files
+        modified_files: list[str] = [
+            file for files in [commit.modified + commit.added for commit in hook_info.commits] for file in files
+        ]
+
+        template_updates = {file.split("/")[1] for file in modified_files if "message_templates" in file}
+        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)
 
-        await update_clan_messages(guild)
+        await update_clan_messages(guild, channel_updates)
+
+        # if the council members template has changed, update the message
+        if "council_members.txt" in template_updates:
+            await edit_clan_council_info(self.bot.get_guild(self.config.params.guild_id), self.config)
 
         return {"message": "Successfully updated all discord messages."}
 
-    def repo_setup(self):
-        """
-        Checks if the repo exists and creates repo object, clones if it does not.
-        """
+    def repo_setup(self) -> None:
+        """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)
@@ -64,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.origin.refs.test
-            ).checkout()
+            self.repo.create_head("test", self.origin.refs.test).set_tracking_branch(self.origin.refs.test).checkout()
         else:
-            self.repo.create_head("main", self.origin.refs.main).set_tracking_branch(
-                self.origin.refs.main
-            ).checkout()
+            self.repo.create_head("main", self.origin.refs.main).set_tracking_branch(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):
-    """Adds function to bot"""
+def setup(bot: commands.Bot) -> None:
+    """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,19 @@ 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.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):
-    """
-    Adds all command classes to bot.
-    """
-
+def setup(bot: commands.Bot) -> None:
+    """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(TestCog(bot))
     bot.add_cog(ViewCog())
-    bot.add_cog(setCog())
+    bot.add_cog(SetCog())

cogs/commands/record.py

@@ -1,46 +1,38 @@
-"""
-Contained commands and views for record commands.
-"""
+"""Contained commands and views for record commands."""
 
 import nextcord
 from discord import TextInputStyle
 from nextcord.ext import commands
 
 from config import DakinyConfig
-from utils import record_event_host, record_event_participation
+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:
-        """
-        Default constructor for RecordCog class. Does nothing.
-        """
+    def __init__(self, bot: commands.Bot) -> None:
+        """Default constructor for RecordCog class. Does nothing."""
         super().__init__()
         self.bot: commands.Bot = bot
 
     @nextcord.slash_command()
-    async def record(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for record. Never called.
-        """
+    async def record(self, interaction: nextcord.Interaction) -> None:
+        """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(
-            required=True, description="Name of the event that was hosted."
-        ),
+        name: str = nextcord.SlashOption(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 (
-            interaction.guild.get_role(self.bot.config.params.event_host_role_id)
-            not in interaction.user.roles
-        ):
+        if 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,68 +85,62 @@ class EventView(nextcord.ui.View):
         self.add_item(self.event_participants)
 
     @nextcord.ui.button(label="Cancel", style=nextcord.ButtonStyle.red, row=1)
-    async def cancel(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
-        """
-        Cancels event submission. Removes embed and view.
-        """
-        await interaction.response.edit_message(
-            "Canceled", ephemeral=True, embed=None, view=None
-        )
+    async def cancel(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
+        """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):
-        """
-        Calls modal to update the text input information of the event.
-        """
-        await interaction.response.send_modal(
-            ParticipantModal(interaction.message.embeds[0])
-        )
+    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."""
+        await interaction.response.send_modal(ParticipantModal(interaction.message.embeds[0]))
 
     @nextcord.ui.button(label="Confirm", style=nextcord.ButtonStyle.green, row=1)
-    async def confirm(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
+    async def confirm(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
-        Submits the event embed to the event channel. Removes view and embed from recording message.
+        Submits the event embed to the event channel.
+
+        Removes view and embed from recording message.
         Sends point information to database.
         """
-
-        discord_users = self.event_participants.values.members
+        discord_users = self.event_participants.values.members  # noqa: PD011 not a pandas object
         if discord_users:
-            discord_users_list: list[str] = [
-                str(user.id) for user in discord_users if user.id is not self.host_id
-            ]
-            record_event_participation(self.config, discord_users_list, True)
+            discord_users_list: list[str] = [str(user.id) for user in discord_users if user.id is not self.host_id]
+            record_event_points(
+                self.config,
+                discord_users_list,
+                True,  # noqa: FBT003
+                self.config.params.event_participate_points,
+            )
 
         non_discord_users = interaction.message.embeds[0].fields[1].value
         if non_discord_users:
             non_discord_users_list: list[str] = non_discord_users.split("\n")
-            record_event_participation(self.config, non_discord_users_list, False)
+            record_event_points(
+                self.config,
+                non_discord_users_list,
+                self.config.params.event_participate_points,
+                is_member=False,
+            )
 
-        record_event_host(self.config, self.host_id)
+        record_event_points(self.config, [self.host_id], self.config.params.event_host_points, is_member=True)
 
-        event_channel: nextcord.TextChannel = interaction.guild.get_channel(
-            self.config.params.event_post_channel_id
-        )
+        event_channel: nextcord.TextChannel = interaction.guild.get_channel(self.config.params.event_post_channel_id)
         await event_channel.send(embed=interaction.message.embeds[0])
-        await interaction.response.edit_message(
-            content="Event has been submitted.", view=None, embed=None
-        )
+        await interaction.response.edit_message(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
-    of participants who are not in the discord.
+    This modal contains all the text edits for an event.
+
+    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
-    def __init__(self, embed):
+    # consider turning this embed into a dict
+    def __init__(self, embed: nextcord.Embed):
         super().__init__(
             "Edit the event.",
             timeout=5 * 60,
@@ -186,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(
-            index=1, name="Non-Discord Participants", value=self.participants.value
-        )
+        self.embed.set_field_at(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__(
@@ -209,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(
-            [f"<@{participant.id}>" for participant in self.values.members]
-        )
+        participants: str = "\n".join([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,54 +1,65 @@
-"""
-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
 
-from utils import edit_clan_council_info, update_clan_messages
+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:
-        """
-        Default constructor for RefreshCog class. Does nothing.
-        """
+    def __init__(self, bot: commands.Bot) -> None:
+        """Default constructor for RefreshCog class. Does nothing."""
         super().__init__()
         self.bot: commands.Bot = bot
 
-    @nextcord.slash_command(
-        default_member_permissions=nextcord.Permissions(administrator=True)
-    )
-    async def refresh(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for refresh. Never called.
-        """
+    @nextcord.slash_command(default_member_permissions=nextcord.Permissions(administrator=True))
+    async def refresh(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for refresh. Never called."""
 
     @refresh.subcommand(description="Force refresh all of the bot managed messages.")
-    async def messages(self, interaction: nextcord.Interaction):
+    async def messages(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.TextChannel = nextcord.SlashOption(
+            description="Channel to refresh messages in.",
+            required=False,
+        ),
+    ) -> None:
         """
+        Updates all messages.
+
         Calls update_clan_messages() to update all messages.
 
         Args:
             interaction (nextcord.Interaction): Interaction with the command.
+            channel (nextcord.TextChannel): channel to refresh messages in.
         """
         await interaction.response.defer(ephemeral=True)
-        await update_clan_messages(interaction.guild)
+
+        if channel is None:
+            channel_updates = [
+                dir_name for dir_name in os.listdir(MESSAGES_DIR) if Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()
+            ]
+        else:
+            channel_updates = [channel.name]
+
+        await update_clan_messages(interaction.guild, channel_updates)
         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(
-            "Clan Council Info message updated.", ephemeral=True
-        )
+        await interaction.response.send_message("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):
-        """
-        Parent slash command for set. Never called.
-        """
+    async def remove(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for set. Never called."""
 
     @remove.subcommand(description="Remove a presence from the database.")
     async def presence(
         self,
         interaction: nextcord.Interaction,
-        presence_str: str = nextcord.SlashOption(
-            description="The presence to remove", required=True
-        ),
-    ):
+        presence_str: str = nextcord.SlashOption(description="The presence to remove", required=True),
+    ) -> None:
         """
         Deletes the given presence id from the database.
 
         Args:
             interaction (nextcord.Interaction): Interaction that invoked the command.
-            presence (str): Is SlashOption. The presence to remove. Is the ID of the presence.
+            presence_str (str): Is SlashOption. The presence to remove. Is the ID of the presence.
         """
-
         presence_id = int(presence_str)
         with Session(engine) as session:
             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(
-        self, interaction: nextcord.Interaction, presence_str: str
-    ):
+    async def presence_autocomplete(self, interaction: nextcord.Interaction, presence_str: str) -> None:
         """
         Collects all presences that start with the presence string.
+
         Sends autocomplete dict {Presence Name, Presence Id}
 
         Args:
             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]" = {
-                pres.Presence: str(pres.Id) for pres in session.scalars(stmt)
-            }
+            presences_dict: dict[str,str] = {pres.Presence: str(pres.Id) for pres in session.scalars(stmt)}
 
             # if empty compare string
             if not presence_str:
-                await interaction.response.send_autocomplete(
-                    dict(list(presences_dict.items())[:25])
-                )
+                await interaction.response.send_autocomplete(dict(list(presences_dict.items())[:25]))
                 return
 
-            autofilled_presences: "dict[str,str]" = {
-                pres: pres_id
-                for pres, pres_id in presences_dict.items()
-                if presence_str.lower() in pres.lower()
+            autofilled_presences: dict[str,str] = {
+                pres: pres_id for pres, pres_id in presences_dict.items() if presence_str.lower() in pres.lower()
             }
             await interaction.response.send_autocomplete(autofilled_presences[:25])

cogs/commands/request.py

@@ -1,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:
-        """
-        Default constructor for RequestCog class. Does nothing.
-        """
+    def __init__(self, bot: commands.Bot) -> None:
+        """Default constructor for RequestCog class. Does nothing."""
         self.bot: commands.Bot = bot
 
     @nextcord.slash_command()
-    async def request(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for request. Never called.
-        """
+    async def request(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for request. Never called."""
 
-    @request.subcommand(
-        description="Request to add a presence to the bot's presence list."
-    )
+    @request.subcommand(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(
-            content=content, view=view
-        )
-        await interaction.response.send_message(
-            "Request sent to admins.", ephemeral=True
-        )
+        await self.bot.get_channel(config.params.admin_channel_id).send(content=content, view=view)
+        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(
-            content=content, view=view
-        )
-        await interaction.response.send_message(
-            "Request sent to admins.", ephemeral=True
-        )
+        await self.bot.get_channel(config.params.admin_channel_id).send(content=content, view=view)
+        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(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
-        Approve button for a nickname change request. Changes the target's nickname to self.new_nickname.
+        Approve button for a nickname change request.
+
+        Changes the target's nickname to self.new_nickname.
         Catches an error if the target as a higher role than the bot.
         Removes the view from the interaction message.
 
@@ -119,10 +101,7 @@ class UsernameRequest(nextcord.ui.View):
         if user is not None:
             try:
                 await user.edit(nick=self.new_nickname)
-                content = (
-                    interaction.message.content
-                    + f"\nApproved by <@{interaction.user.id}>."
-                )
+                content = 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(
-                    interaction.message.id, content=content, view=None
-                )
+                await interaction.followup.edit_message(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(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
         """
-        Approve button for a presence add request. Adds the presence to the database.
+        Approve button for a presence add request.
+
+        Adds the presence to the database.
         Removes the view from the interaction message.
 
         Args:
             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 = (
-            interaction.message.content + f"\nApproved by <@{interaction.user.id}>."
-        )
+        content = 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 holds set commands.
-    """
+class SetCog(commands.Cog, name="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):
-        """
-        Parent slash command for set. Never called.
-        """
+    async def set(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for set. Never called."""
 
-    @set.subcommand(
-        description="Sets your birth month and day for the Birthday Fun. Use 0/0 to remove yourself."
-    )
+    @set.subcommand(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(
-            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."
-        ),
-    ):
+        month: int = nextcord.SlashOption(required=True, min_value=0, max_value=12, description="Your birth month."),
+        day: int = nextcord.SlashOption(required=True, min_value=0, max_value=31, description="Your birth day."),
+    ) -> None:
         """
         Sets a user's birthday in the database. Removes on input 0/0. If birthday is today, adds to the birthday_list.
 
@@ -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(
-                UserBirthday.UserId == interaction.user.id
-            )
+            stmt = delete(UserBirthday).where(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(
-                f"Invalid date: {month}/{day}.", ephemeral=True
-            )
+            await interaction.followup.send(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(
-            UserId=interaction.user.id, Birthday=f"{month}/{day}"
-        )
+        new_birthday = UserBirthday(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(
-                    UserBirthday.UserId == interaction.user.id
-                )
+                stmt = select(UserBirthday).where(UserBirthday.UserId == interaction.user.id)
                 new_birthday = session.scalar(stmt)
                 new_birthday.Birthday = f"{month}/{day}"
                 session.commit()
 
-        await interaction.followup.send(
-            f"Birthday set to {month}/{day}.", ephemeral=True
-        )
+        await interaction.followup.send(f"Birthday set to {month}/{day}.", ephemeral=True)

cogs/commands/test.py

@@ -1,53 +1,50 @@
-"""
-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 get_current_election_cycle
 
+if TYPE_CHECKING:
+    from config import DakinyConfig
 
-def is_me():
-    """
-    predicate that makes sure only I can run the test commands.
-    """
 
-    def predicate(interaction: nextcord.Interaction):
-        return interaction.user.id == 206602713511886849
+ME = 206602713511886849
+GUILDS = [1000247361639030804]
+
+
+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:
-        """
-        Default constructor for HelpCog class. Does nothing.
-        """
-        self.bot = bot
+    def __init__(self, bot: commands.Bot) -> None:
+        """Default constructor for HelpCog class. Does nothing."""
+        self.bot: commands.Bot = bot
 
-    @nextcord.slash_command(guild_ids=[1000247361639030804])
-    async def test(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for help. Never called.
-        """
+    @nextcord.slash_command(guild_ids=GUILDS)
+    async def test(self, interaction: nextcord.Interaction) -> None:
+        """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 +52,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 +70,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 +88,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 +106,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 +124,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 +142,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 +160,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/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,23 +12,18 @@ from database_setup.sql_data_classes import (
     Votes,
     engine,
 )
+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):
-        """
-        Parent slash command for set. Never called.
-        """
+    async def view(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for set. Never called."""
 
     @view.subcommand(description="Show event points.")
     async def event_points(
@@ -40,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:
-                await interaction.followup.send(
-                    f'Quarter "{quarter_name}" is invalid.', ephemeral=True
-                )
+            if ppdf.empty:
+                await interaction.followup.send(f'Quarter "{quarter_name}" is invalid.', ephemeral=True)
                 return
 
-            cycles = df.groupby("Cycle")
+            cycles = ppdf.groupby("Cycle")
             content = ""
             for cycle in cycles.groups:
                 content += f"**{cycle}**\n"
                 unsorted_all = cycles.get_group(cycle).groupby("DiscordMember")
-                members = unsorted_all.get_group(True)
-                non_members = unsorted_all.get_group(False)
+                members = unsorted_all.get_group(name=True)
+                non_members = unsorted_all.get_group(name=False)
                 sorted_members = members.sort_values(
                     by="UserId",
                     key=lambda user_ids: (
-                        [
-                            interaction.guild.get_member(int(id)).display_name
-                            for id in user_ids
-                        ]
+                        [interaction.guild.get_member(int(user_id)).display_name for user_id in user_ids]
                     ),
                 )
                 sorted_non_members = non_members.sort_values(by="UserId")
-                sorted_all = pd.concat(
-                    [sorted_members, sorted_non_members], ignore_index=True, sort=False
-                )
+                sorted_all = pd.concat([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 += (
-                        f"<@{userid}>: {points}\n"
-                        if discord_member
-                        else f"{userid}: {points}\n"
-                    )
+                    content += f"<@{userid}>: {points}\n" if discord_member else f"{userid}: {points}\n"
                 content += "\n"
 
-            if len(content) > 2000:
-                await interaction.followup.send(
-                    "Message length is too long, please select search to limit results."
-                )
+            if len(content) > MAX_DISCORD_MESSAGE_LENGTH:
+                await interaction.followup.send("Message length is too long, please select search to limit results.")
                 return
 
             await interaction.followup.send(content=content, ephemeral=True)
@@ -111,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)
 
@@ -127,29 +116,28 @@ class ViewCog(commands.Cog, name="View Commands"):
             presences = session.scalars(stmt)
 
             if search:
-                message = "\n".join(
-                    [
-                        presence
-                        for presence in presences
-                        if search.lower() in presence.lower()
-                    ]
-                )
+                message = "\n".join([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(
-        description="Shows all voters and who they voted for in a given election."
-    )
+    @view.subcommand(description="Shows all voters and who they voted for in a given election.")
     async def votes(
         self,
         interaction: nextcord.Interaction,
         election_name: str = nextcord.SlashOption(
             required=True, description="The election you want to view votes for."
         ),
-    ):
+        election_type: str = nextcord.SlashOption(
+            required=True,
+            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.
@@ -157,16 +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)
+        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(
-                    f"Invalid election: {election_name}.", ephemeral=True
-                )
+                await interaction.response.send_message(f"Invalid election: {election_name}.", ephemeral=True)
                 return
 
             votes = session.scalars(stmt)
@@ -181,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(
-        self, interaction: nextcord.Interaction, election_name: str
-    ):
+    async def election_autocomplete(self, interaction: nextcord.Interaction, election_name: str) -> None:
         """
         Collects all elections that start with the election string.
 
@@ -191,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)
@@ -201,17 +184,13 @@ class ViewCog(commands.Cog, name="View Commands"):
                 await interaction.response.send_autocomplete(list(elections)[:25])
                 return
 
-            autofilled_elections: "list[str]" = [
-                election
-                for election in elections
-                if election.lower().startswith(election_name.lower())
+            autofilled_elections: list[str] = [
+                election for election in elections if election.lower().startswith(election_name.lower())
             ]
             await interaction.response.send_autocomplete(autofilled_elections[:25])
 
     @event_points.on_autocomplete("quarter_name")
-    async def event_points_autocomplete(
-        self, interaction: nextcord.Interaction, quarter_name: str
-    ):
+    async def event_points_autocomplete(self, interaction: nextcord.Interaction, quarter_name: str) -> None:
         """
         Collects all elections that start with the election string.
 
@@ -219,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)
@@ -229,9 +207,7 @@ class ViewCog(commands.Cog, name="View Commands"):
                 await interaction.response.send_autocomplete(list(quarters)[:25])
                 return
 
-            autofilled_quarters: "list[str]" = [
-                quarter
-                for quarter in quarters
-                if quarter.lower().startswith(quarter_name.lower())
+            autofilled_quarters: list[str] = [
+                quarter for quarter in quarters if quarter.lower().startswith(quarter_name.lower())
             ]
             await interaction.response.send_autocomplete(autofilled_quarters[:25])

cogs/loops/__init__.py

@@ -1,6 +1,4 @@
-"""
-Initializing code for all loops.
-"""
+"""Initializing code for all loops."""
 
 from nextcord.ext import commands
 
@@ -8,10 +6,7 @@ from cogs.loops.bot_presence import BotPresence
 from cogs.loops.daily_loop import DailyLoop
 
 
-def setup(bot: commands.Bot):
-    """
-    Adds functions to bot.
-    """
-
+def setup(bot: commands.Bot) -> None:
+    """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(
-        self, guild: nextcord.Guild
-    ):  # pylint: disable=unused-argument
+    async def on_guild_join(self, guild: nextcord.Guild) -> None:  # noqa: ARG002
         """Listener for Guild Join. Updated presence on guild join."""
         await self.change_presence()
 
     @commands.Cog.listener()
-    async def on_ready(self):
+    async def on_ready(self) -> None:
         """Starts the loop when bot is ready."""
         await self.bot.wait_until_ready()
-        # pylint doesn't recognize that periodic_change_presense is subclassed from tasks.loop.
-        self.periodic_change_presence.start()  # pylint: disable=no-member
+        self.periodic_change_presence.start()
 
     @tasks.loop(minutes=5)
-    async def periodic_change_presence(self):
+    async def periodic_change_presence(self) -> None:
         """Loops every 5 minutes and changes presence."""
         await self.change_presence()
 
-    async def change_presence(self):
+    async def change_presence(self) -> None:
         """Randomly chooses a presence and updates bot's presence."""
-
         with Session(engine) as session:
-            presence = session.scalar(
-                select(Presences.Presence).order_by(func.random())
-            )
+            presence = session.scalar(select(Presences.Presence).order_by(func.random()))
 
-        await self.bot.change_presence(
-            activity=nextcord.CustomActivity(name="Custom Status", state=presence)
-        )
+        await self.bot.change_presence(activity=nextcord.CustomActivity(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")))
-    async def daily_loop(self):
+    @tasks.loop(time=time(hour=0, tzinfo=timezone("UTC")))
+    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):
-        """
-        Actions run before the loop starts. Want to wait for bot to be ready and get the current cycle.
-        """
-
+    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."""
         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
-        between the election start and the term start.
+        Creates an object for the current election cycle if one is active.
+
+        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
-        saying happy cakeday.
-        """
+        Loops through the guild's humans checking for joined_at dates that match today's date.
 
-        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(
-            self.bot.config.params.general_channel_id
-        )
+        announce_channel: nextcord.TextChannel = guild.get_channel(self.bot.config.params.general_channel_id)
 
         cakedays: list[nextcord.Member] = [
-            human
-            for human in guild.humans
-            if human.joined_at.month == today.month and human.joined_at.day == today.day
+            human 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):
-    """Adds function to bot"""
+def setup(bot: commands.Bot) -> None:
+    """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
@@ -21,6 +17,7 @@ class Params:
     event_host_points: int
     event_host_role_id: int
     event_participate_points: int
+    event_points_weekly_limit: int
     event_post_channel_id: int
     general_channel_id: int
     git_branch: str
@@ -31,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
@@ -48,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/database.sql

@@ -25,8 +25,9 @@ CREATE TABLE Votes(
     ElectionCycle varchar(30) not null,
     VoterId bigint unsigned not null,
     VotedForId bigint unsigned,
+    Type varchar(14) not null DEFAULT 'council' check("Type" in ('council', 'discordmanager', 'clanleader')),
     FOREIGN KEY (ElectionCycle) REFERENCES ElectionInformation(ElectionCycle),
-    PRIMARY KEY (ElectionCycle, VoterId)
+    PRIMARY KEY (ElectionCycle, VoterId, Type)
 );
 
 CREATE TABLE UserBirthday (
@@ -51,4 +52,11 @@ CREATE TABLE ParticipationPoints (
 CREATE TABLE Messages (
     Path varchar(100) PRIMARY KEY,
     Id bigint unsigned not null
+);
+
+CREATE TABLE EventPointsLimit (
+    UserId varchar(32) not null,
+    Points int unsigned DEFAULT 0,
+    Week varchar(7) not null,
+    PRIMARY KEY (UserId, Week)
 );

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
@@ -14,6 +12,7 @@ Base.prepare(autoload_with=engine)
 # define the classes
 CouncilMembers = Base.classes.CouncilMembers
 ElectionInformation = Base.classes.ElectionInformation
+EventPointsLimit = Base.classes.EventPointsLimit
 Messages = Base.classes.Messages
 ParticipationPoints = Base.classes.ParticipationPoints
 Presences = Base.classes.Presences

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(
-    logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s")
-)
+handler.setFormatter(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():
-        """When Discord is connected"""
-        assert bot.user is not None
-        create_database  # pylint: disable=pointless-statement
+    async def on_ready() -> None:
+        """When Discord is connected."""
+        assert bot.user is not None  # noqa: S101 documentation does this
+        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

@@ -0,0 +1,134 @@
+[tool.poetry]
+name = "dakiny-bot"
+version = "0.1.0"
+description = "Dakiny's Discord Bot."
+authors = ["imcompiling <[email protected]>"]
+readme = "README.md"
+package-mode = false
+
+[tool.poetry.dependencies]
+python = "^3.12"
+gitpython = "^3.1.43"
+fastapi = "^0.111.0"
+hydra-core = "^1.3.2"
+nextcord = "^2.6.0"
+pandas = "^2.2.2"
+python-dotenv = "^1.0.1"
+pytz = "^2024.1"
+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"

requirements.txt

@@ -1,8 +0,0 @@
-nextcord==2.4.2
-python-dotenv==1.0.0
-pytz==2022.7.1
-hydra-core==1.3.2
-sqlalchemy<2.0
-pandas==1.5.2
-fastapi==0.111.0
-GitPython==3.1.43

runtime.txt

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

utils.py

@@ -1,10 +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 pathlib import Path
 
+import aiofiles
 import nextcord
 from sqlalchemy import select, true, update
 from sqlalchemy.orm import Session
@@ -12,6 +15,7 @@ from sqlalchemy.orm import Session
 from config import DakinyConfig
 from database_setup.sql_data_classes import (
     CouncilMembers,
+    EventPointsLimit,
     Messages,
     ParticipationPoints,
     Votes,
@@ -22,6 +26,9 @@ 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
+
+VoteType = StrEnum("VoteType", ["COUNCIL", "DISCORDMANAGER", "CLANLEADER"])
 
 
 def get_datetime(day: str) -> datetime:
@@ -34,23 +41,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_cycle_name(config: DakinyConfig) -> str:
+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.
@@ -58,15 +66,14 @@ def get_election_cycle_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}"
 
 
-def get_cycle_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.
@@ -74,41 +81,12 @@ def get_cycle_name(config: DakinyConfig) -> str:
     Returns:
         str: the name of the cycle.
     """
-
-    cycle = get_current_cycle(config)
+    cycle = get_quarter_cycle(config)
     current_cycle = config.election_cycles[cycle]
 
     return f"{get_datetime(current_cycle.term_start).year}-{current_cycle.name}"
 
 
-def get_dm_election_name(config: DakinyConfig) -> str:
-    """
-    creates the name of the discord manager election
-
-    Args:
-        config (DakinyConfig): Config sent to get_election_cycle_name
-
-    Returns:
-        str: the name of the election
-    """
-
-    return f"{get_election_cycle_name(config)}-dm"
-
-
-def get_cl_election_name(config: DakinyConfig) -> str:
-    """
-    creates the name of the clan leader election
-
-    Args:
-        config (DakinyConfig): Config sent to get_election_cycle_name
-
-    Returns:
-        str: the name of the election
-    """
-
-    return f"{get_election_cycle_name(config)}-cl"
-
-
 def get_current_election_cycle(config: DakinyConfig) -> int:
     """
     Returns index for active election. An election is considered active between the election start and the term start.
@@ -119,8 +97,7 @@ def get_current_election_cycle(config: DakinyConfig) -> int:
     Returns:
         int: cycle index for active election. None for no active cycle
     """
-
-    today = datetime.today()
+    today = datetime.now(tz=UTC)
 
     for cycle, election in enumerate(config.election_cycles):
         if (
@@ -129,12 +106,13 @@ def get_current_election_cycle(config: DakinyConfig) -> int:
         ):
             return cycle
 
-    return None
+    # It isn't a current election, get the quarter
+    return get_quarter_cycle(config)
 
 
-def get_current_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
@@ -142,8 +120,7 @@ def get_current_cycle(config: DakinyConfig) -> int:
     Returns:
         int: cycle index for current cycle.
     """
-
-    today = datetime.today()
+    today = datetime.now(tz=UTC)
     for cycle, election in enumerate(config.election_cycles):
         if (
             today.date() >= get_datetime(election.term_start).date()
@@ -165,13 +142,12 @@ 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(
-            CouncilMembers.ElectionCycle == get_election_cycle_name(config)
-        )
+        stmt = select(CouncilMembers).where(CouncilMembers.ElectionCycle == election_name)
 
         for nominee in sorted(
             session.scalars(stmt),
@@ -179,9 +155,7 @@ def build_votes_str(config: DakinyConfig, guild: nextcord.Guild) -> str:
         ):
             votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(
-            Votes.ElectionCycle == get_election_cycle_name(config)
-        )
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name).where(Votes.Type == VoteType.COUNCIL)
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -199,19 +173,20 @@ 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] = {}
 
+    election_name = get_election_name(config)
+
     with Session(engine) as session:
         stmt = (
             select(CouncilMembers)
-            .where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
+            .where(CouncilMembers.ElectionCycle == election_name)
             .filter(CouncilMembers.ClanLeaderSpeechId.is_not(None))
         )
 
@@ -221,7 +196,7 @@ def build_highcouncil_votes_str(config: DakinyConfig, guild: nextcord.Guild) ->
         ):
             cl_votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(Votes.ElectionCycle == get_cl_election_name(config))
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name).where(Votes.Type == VoteType.CLANLEADER)
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -229,7 +204,7 @@ def build_highcouncil_votes_str(config: DakinyConfig, guild: nextcord.Guild) ->
 
         stmt = (
             select(CouncilMembers)
-            .where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
+            .where(CouncilMembers.ElectionCycle == election_name)
             .filter(CouncilMembers.DiscordManagerSpeechId.is_not(None))
         )
 
@@ -239,7 +214,7 @@ def build_highcouncil_votes_str(config: DakinyConfig, guild: nextcord.Guild) ->
         ):
             dm_votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(Votes.ElectionCycle == get_dm_election_name(config))
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name).where(Votes.Type == VoteType.DISCORDMANAGER)
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -326,94 +301,103 @@ def decorate_dm_nomination(user_id: int, speech: str) -> str:
     return msg
 
 
-def record_event_participation(config: DakinyConfig, users: list[str], is_member: bool):
+def record_event_points(config: DakinyConfig, users: Sequence[str], add_points: int, *, is_member: bool) -> None:
     """
-    Adds participation 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.
+    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 (list[int]): users that participated and need 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
     """
-
-    cycle = get_cycle_name(config)
-    participation_point_value = config.params.event_participate_points
+    quarter_name = get_quarter_name(config)
     with Session(engine) as session:
         for user in users:
             stmt = (
                 select(ParticipationPoints)
                 .where(ParticipationPoints.UserId == user)
-                .where(ParticipationPoints.Cycle == cycle)
+                .where(ParticipationPoints.Cycle == quarter_name)
             )
 
             points = session.scalar(stmt)
             if points is None:
+                add_points = get_allowed_points(session, config.params.event_points_weekly_limit, user, add_points)
                 new_points = ParticipationPoints(
-                    Cycle=cycle,
+                    Cycle=quarter_name,
                     UserId=user,
                     DiscordMember=is_member,
-                    Points=participation_point_value,
+                    Points=add_points,
                 )
                 session.add(new_points)
             else:
-                points.Points += participation_point_value
+                add_points = get_allowed_points(session, config.params.event_points_weekly_limit, user, add_points)
+                points.Points += add_points
 
         session.commit()
 
 
-def record_event_host(config: DakinyConfig, user: int):
+def get_allowed_points(session: Session, points_limit: int, user: str, points: int) -> int:
     """
-    Adds host points to the given user. Checks if they don't exist in order to make a new entry, otherwise adds points
-    to the existing value.
+    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.
 
     Args:
-        config (DakinyConfig): Dakiny config for getting points
-        user (int): Id of user that hosted.
+        session (Session): Open connection to database.
+        points_limit (int): Maximum number of points a user can be given in a week.
+        user (str): user to be given points. Used to check a user's limit.
+        points (int): maximum number of points to give to user.
+
+    Returns:
+        int: how many points are allowed to be given to the user.
     """
-    cycle = get_cycle_name(config)
-    host_point_value = config.params.event_host_points
-    with Session(engine) as session:
-        stmt = (
-            select(ParticipationPoints)
-            .where(ParticipationPoints.UserId == str(user))
-            .where(ParticipationPoints.Cycle == cycle)
+    # check for limit
+    today = datetime.now(tz=UTC).date()
+    this_week = f"{today.isocalendar().year}-{today.isocalendar().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.
+    limit = session.scalar(stmt)
+    if limit is None:
+        new_limit = EventPointsLimit(UserId=user, Points=points, Week=this_week)
+        add_points = points
+        session.add(new_limit)
+    else:
+        add_points = (
+            points
+            if limit.Points + points <= points_limit
+            else (points_limit - limit.Points if points_limit - limit.Points > 0 else 0)
         )
+        limit.Points += add_points
 
-        points = session.scalar(stmt)
-        if points is None:
-            new_points = ParticipationPoints(
-                Cycle=cycle,
-                UserId=str(user),
-                DiscordMember=True,
-                Points=host_point_value,
-            )
-            session.add(new_points)
-        else:
-            points.Points += host_point_value
+    session.commit()
 
-        session.commit()
+    return add_points
 
 
-async def update_clan_messages(guild: nextcord.Guild):
+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.
 
     Args:
         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 os.listdir(MESSAGES_DIR)
-        if os.path.isdir(f"{MESSAGES_DIR}/{dir_name}")
-    ]
+    dirs = [dir_name for dir_name in channel_updates if Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()]
 
     with Session(engine) as session:
         for dir_name in dirs:
@@ -427,17 +411,17 @@ async def update_clan_messages(guild: nextcord.Guild):
             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(
-    session: Session, channel_name: str, guild: nextcord.Guild
-) -> nextcord.TextChannel:
+async def get_clan_message_channel(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.
@@ -457,10 +441,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 (
-                channel.name == channel_name
-                and channel.__class__ is nextcord.TextChannel
-            ):
+            if channel.name == channel_name and channel.__class__ is nextcord.TextChannel:
                 ret_channel = channel
 
         if ret_channel is None:
@@ -484,11 +465,7 @@ async def get_clan_message_channel(
             channel_name,
             reason="Creating channel as required for by design of Dakiny-Messages repo.",
         )
-        stmt = (
-            update(Messages)
-            .where(Messages.Path == channel_name)
-            .values(Id=ret_channel.id)
-        )
+        stmt = update(Messages).where(Messages.Path == channel_name).values(Id=ret_channel.id)
         session.execute(stmt)
         session.commit()
         return ret_channel
@@ -499,9 +476,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.
 
@@ -525,14 +504,12 @@ async def edit_clan_message(
             await msg.edit(message_content)
         except nextcord.NotFound:
             msg = await channel.send(message_content)
-            stmt = (
-                update(Messages).where(Messages.Path == message_name).values(Id=msg.id)
-            )
+            stmt = 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.
 
@@ -540,11 +517,9 @@ 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(
-        config.params.clan_info_channel_id
-    )
+    clan_info_channel: nextcord.TextChannel = await guild.fetch_channel(config.params.clan_info_channel_id)
 
-    election = get_election_cycle_name(config)
+    election = get_election_name(config)
     with Session(engine) as session:
         stmt = (
             select(CouncilMembers.MemberId)
@@ -565,17 +540,13 @@ async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig):
         )
 
         council_members_strs = [
-            f"<@{id}>"
-            for id in session.scalars(stmt)
-            if id not in (discord_manager, clan_leader)
+            f"<@{user_id}>" for user_id in session.scalars(stmt) if user_id not in (discord_manager, clan_leader)
         ]
 
-        quarter = get_cycle_name(config)
+        quarter = get_quarter_name(config)
 
-        with open(
-            f"{TEMPLATES_DIR}/council_members.txt", mode="r", encoding="utf8"
-        ) as file:
-            message = file.read()
+        async with aiofiles.open(f"{TEMPLATES_DIR}/council_members.txt", encoding="utf8") as file:
+            message = await file.read()
             message = message.format(
                 quarter=quarter,
                 council="\n".join(council_members_strs),
@@ -583,6 +554,4 @@ async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig):
                 discord_manager=discord_manager,
             )
 
-        await edit_clan_message(
-            session, clan_info_channel, "council_members.txt", message
-        )
+        await edit_clan_message(session, clan_info_channel, "council_members.txt", message)