Correct date being used for getting the election cycle name.

.gitignore

@@ -105,7 +105,6 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-poetry.lock
 
 # Spyder project settings
 .spyderproject
@@ -125,10 +124,13 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
+# IDE
+.vscode/
+
 # logging
 nextcord.log
 
-# bot files
+# data file for bot
 highscores_data.json
 highscores_config.json
 deleted_backups/
@@ -138,4 +140,3 @@ sql_tester.py
 conf
 outputs
 database
-dakiny-messages/

.vscode/extensions.json

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

.vscode/launch.json

@@ -1,15 +0,0 @@
-{
-    // 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
-        }
-    ]
-}

.vscode/settings.json

@@ -1,11 +0,0 @@
-{
-    "cSpell.words": [
-        "aiofiles",
-        "autofilled",
-        "blurple",
-        "CLANLEADER",
-        "Dakiny",
-        "DISCORDMANAGER",
-        "highcouncil"
-    ]
-}

DakinySettings.py

@@ -1,86 +0,0 @@
-"""File contains classes defining Dakiny settings structure."""
-
-from dataclasses import dataclass
-
-from dataclass_wizard import YAMLWizard
-
-CONFIG_LOCATION = "conf/config.yaml"
-
-
-@dataclass
-class ChannelIds:
-    """Class holds all channel ids needed by bot."""
-
-    admin: int  # might want to rename this...
-    announcement: int
-    clan_info: int
-    event_post: int
-    general: int
-    voting: int
-
-
-@dataclass
-class Election:
-    """Class defines relevant election dates."""
-
-    active: bool
-    election_start: str
-    highcouncil_election_announce: str
-    highcouncil_election_end: str
-    highcouncil_election_start: str
-    name: str
-    term_end: str
-    term_start: str
-    voting_end: str
-    voting_start: str
-
-
-@dataclass
-class Params:
-    """Class defines start parameters that shouldn't be changed."""
-
-    discord_token: str
-    git_branch: str
-    guild_id: int
-
-
-@dataclass
-class PointSettings:
-    """Class defines point settings editable by Clan Council."""
-
-    clan_points: int
-    clan_points_weekly_limit: int
-    events_weekly_limit: int
-    host_points: int
-    participate_points: int
-    verify_clan_points: bool
-    verify_events: bool
-
-
-@dataclass
-class RoleIds:
-    """Class holds all role ids needed by bot."""
-
-    clan_council: int
-    clan_council_elect: int
-    clan_member: int
-    event_host: int
-    high_council: int
-
-
-@dataclass
-class DakinySettings(YAMLWizard):
-    """Class defines all configs required for Dakiny Bot."""
-
-    channel_ids: ChannelIds
-    election_cycles: list[Election]
-    params: Params
-    point_settings: PointSettings
-    role_ids: RoleIds
-
-    def save(self) -> None:
-        """Saves settings to the yaml file."""
-        self.to_yaml_file(CONFIG_LOCATION)
-
-
-settings = DakinySettings.from_yaml_file(CONFIG_LOCATION)

Dockerfile

@@ -1,19 +1,26 @@
-FROM python:3.12.3-slim
+FROM python:3.10.6-slim
 
-# install dependencies
-RUN apt-get update && apt-get -y upgrade && apt-get -y install git sqlite3
+# install dependencies for mysqlclient
+# RUN apt-get update && apt-get -y upgrade && apt-get -y install python3-dev default-libmysqlclient-dev build-essential
+
+RUN pip install --upgrade pip
 
 WORKDIR /home
 
-COPY DakinySettings.py DakinySettings.py
-COPY main.py main.py
-COPY utils.py utils.py
-COPY pyproject.toml pyproject.toml
+COPY requirements.txt requirements.txt
 
+COPY config.py config.py
+COPY dakiny_bot.py dakiny_bot.py
+COPY utils.py utils.py
+
+COPY bot_messages bot_messages/
 COPY classes classes/
 COPY cogs cogs/
 COPY database_setup database_setup/
 
-RUN pip install --upgrade pip && pip install poetry==1.8.3 && poetry export -f requirements.txt --output requirements.txt && pip install -r requirements.txt
+RUN pip install -r requirements.txt
 
-CMD ["python3", "-u", "./main.py"]
+# remove build deps that aren't needed to run
+# RUN apt-get -y remove python3-dev build-essential && apt-get -y autoremove
+
+CMD ["python3", "-u", "./dakiny_bot.py"]

README.md

@@ -1,10 +1,5 @@
 # Dakiny Bot
 
-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.
+Bot assumes that it always did the step before it. If the step before an action didn't happen, behavior is undefined.
 Object creation in the middle of a cycle is only there for restarting the bot. All relevant information should already
 exist in the database.
-- Bot is running on machine that is usint UTC time. All today() calls specify UTC time zone.

bot_messages/council_members.txt

@@ -0,0 +1,7 @@
+Here's the {quarter} Clan Council:
+
+Dakiny Council: 
+{council}
+
+Dakiny High Council:
+{high_council}

bot_messages/election_announcement.txt

@@ -0,0 +1,54 @@
+```fix
+Dakiny's Clan Council election
+```
+Dakiny is an organization built by and for its members. We are a community of people who come together to support each other in the creation of this magical and unique experience. To sustain what we've created here, and to grow and involve into the future, we vote in our leadership every 3 months to provide an opportunity for new clan members to represent their faction of Dakiny in the Clan Council.
+
+This clan is about human interaction, and the Clan Council positions serve to prop up certain voices within our community, in an effort to shape it as a force for good. Our mission here is to spread love. The more loving Council Members (CMs) we have on the team, the greater the community will grow for all of us to enjoy. There are no term limits, but if you go inactive on RS or become uninterested in pouring your effort into this community, request to step down so that others may contribute where you are no longer able to.
+
+We want all CMs to grow and succeed. Please, reach out for assistance and advice if you find yourself going even a few days without taking real, actionable steps towards the prosperity of Dakiny. Recruiting, hosting events, participating in the Clan Council Discord, and demonstrating the Core Elements of the position are required from each and every CM to grow a happy and healthy clan.
+
+__So here's how it works:__
+---message_break---
+Each quarter, a channel is created here on Discord for clan members to cast their vote to determine the Clan Council for that 3-month period. 
+
+**Only clan members can vote and all clan members are granted exactly one equally weighted vote.** If you vote twice for different people, your vote will be annulled. 
+
+All clan members are permitted to run for a seat on the Clan Council as long as they:
+
+**i)** have been in the clan for at least 13 weeks (enough time to have participated in at least one election);
+
+**ii)** have no warnings under their name in the last 6 months and
+
+**iii)** have been active in the clan for the past 13 weeks prior to the first day of elections. To be considered active in that timeframe, one must fulfill the following criteria: hosted/participated in at least three clan events, each one in a different week;
+
+**iv)** are not running under aliases that hide their true identity.
+
+Candidates are permitted to vote for themselves. Once a candidate reaches 3 votes from clan members, they have earned their seat, meaning no more votes can be cast for them.
+
+Then, the new Clan Council Elect will come together to select the 2 High Council positions:
+RuneScape 3 Clan Leader
+Discord Server Manager
+
+The Clan Council will be denoted by the Discord ranks of <@&{clan_council_id}> and <@&{high_council_id}> and in-game with the following ranks.
+<:Rank_Admin:479008185240518656> Admin
+<:Rank_Organiser:479008215024009216> Organizer
+<:Rank_Coordinator:479008238654849045> Coordinator
+<:Rank_Overseer:479008269382451201> Overseer
+<:Rank_Deputy:479008295319896064> Deputy Owner
+<:Rank_Owner:479008325137072155> Clan Leader
+---message_break---
+__Here's the timeline:__
+Election begins: {election_start}
+Term: {term_start} - {term_end}
+
+**{election_start}**: Post here to announce candidacy
+**{voting_start}**: Voting begins
+**{voting_end}**: Votes are tallied and winners are announced
+**{highcouncil_election}**: The new Clan Council votes who among them shall receive the two High Council positions of: Clan Leader and Discord Server Manager.
+**{term_start}**: The new Clan Council is officially inaugurated and a drop party (or a giveaway event) begins to commemorate the new leadership.
+
+This process will begin again next quarter on {next_election_start} with the inauguration scheduled for {term_end}.
+---message_break---
+**You may now announce your candidacy for a seat on the Dakiny Clan Council!
+**
+You may include a speech with your announcement, as well as specific pertinent facts such as total recruits, time in the clan, past Clan Council experience, and donations made. This data is available upon request via <@&{clan_council_id}>.

bot_messages/highcouncil_election.txt

@@ -0,0 +1,12 @@
+`Leadership Elections - candidacy time`
+
+
+<@&{clan_council_elect_role_id}>, welcome. We are starting the second part of our elections.  On {highcouncil_election_announce} this channel will be open to write for all of you. Everyone else will be able to read this channel, but not write in it. Only members of the  Clan Council Elected (CCE) can vote now. Any votes from others will be annulled.
+
+From {highcouncil_election_announce} to {highcouncil_election_start}, you will be able to announce your candidacy for High Council. The positions are:
+ Clan Leader
+ Discord Server Manager
+
+Each member of the CCE can vote once in each category (Discord Server Manager and Clan Leader). Alternatively, you may choose to intentionally abstain.
+
+Votes can be cast until {highcouncil_election_end}, so we can announce and have everyone set up to start the term by {term_start}.

bot_messages/highcouncil_vote.txt

@@ -0,0 +1 @@
+<@&{clan_council_elect_role_id}> it is now time to vote for the high council! You have until {term_start} to complete the vote.

bot_messages/vote_start.txt

@@ -0,0 +1,14 @@
+====================
+<@&{clan_member_id}>, it's time to vote for clan council.
+
+Press the Vote button to vote!
+Voting ends next {voting_end_day}, {voting_end}.
+Results will then be announced.
+
+After a candidate receives 3 votes, their spot is secured in the new council, but you can still vote for them to show your support.
+
+**Just a reminder:** only the people listed below are eligible to vote, and each clan member may **only vote for one person**. Votes from guests, diplomats, or allies will be annulled.
+Votes for multiple candidates from the same person will not be counted. 
+
+RS3 Clan Members
+OSRS Clan Members

classes/election_cycle.py

@@ -1,63 +1,68 @@
-"""Contains the election cycle class."""
+"""
+Contains the election cycle class
+"""
 
 import collections
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
+from datetime import datetime, timedelta
 
 import nextcord
+from sqlalchemy import select, true
+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
 from classes.voting_views import VoteView
-from DakinySettings import settings
+from config import DakinyConfig
 from database_setup.sql_data_classes import (
     CouncilMembers,
     ElectionInformation,
     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_election_name,
+    get_dm_election_name,
+    get_election_cycle_name,
 )
 
-REQUIRED_VOTES_TO_BE_ELECTED = 3
 
-
-class Election:
+class ElectionCycle:
     """
-    Election class.
-
     This class represents all the dates required for an election cycle along with all the functions needed to operate
     the cycle.
     """
 
-    def __init__(self, cycle: int, guild: nextcord.Guild) -> None:
+    def __init__(self, cycle: int, config: DakinyConfig, guild: nextcord.Guild) -> None:
         """
         Generates all dates relevant to the election cycle determined by the config and cycle.
 
         Args:
             cycle (int): Which election cycle this cycle is.
+            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 = settings.election_cycles[self.cycle]
-        self.active = self.election_cycle.active
+        self.election_cycle = self.config.election_cycles[self.cycle]
         self.election_start: datetime = get_datetime(self.election_cycle.election_start)
         self.term_start: datetime = get_datetime(self.election_cycle.term_start)
         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
 
@@ -69,16 +74,21 @@ class Election:
             list[str]: A list of message contents in the correct order. Must be a string because the message is too
             long.
         """
-        with Path(f"{TEMPLATES_DIR}/election_announcement.txt", encoding="utf8").open() as file:
+
+        with open(
+            "bot_messages/election_announcement.txt", mode="r", encoding="utf8"
+        ) as file:
             message = file.read()
 
             next_election = get_datetime(
-                settings.election_cycles[(self.cycle + 1) % len(settings.election_cycles)].election_start
+                self.config.election_cycles[
+                    (self.cycle + 1) % len(self.config.election_cycles)
+                ].election_start
             )
 
             message = message.format(
-                clan_council_id=settings.role_ids.clan_council,
-                high_council_id=settings.role_ids.high_council,
+                clan_council_id=self.config.params.clan_council_role_id,
+                high_council_id=self.config.params.high_council_role_id,
                 election_start=self.election_start.strftime("%B %d"),
                 term_start=self.term_start.strftime("%B %d"),
                 term_end=self.term_end.strftime("%B %d"),
@@ -97,14 +107,23 @@ class Election:
         Returns:
             str: Message to send.
         """
-        with Path(f"{TEMPLATES_DIR}/highcouncil_election.txt", encoding="utf8").open() as file:
+
+        with open(
+            "bot_messages/highcouncil_election.txt", mode="r", encoding="utf8"
+        ) as file:
             message = file.read()
 
             return message.format(
-                clan_council_elect_role_id=settings.role_ids.clan_council_elect,
-                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"),
+                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"
+                ),
                 term_start=self.term_start.strftime("%B %d"),
             )
 
@@ -115,11 +134,14 @@ class Election:
         Returns:
             str: Message to send.
         """
-        with Path(f"{TEMPLATES_DIR}/highcouncil_vote.txt", encoding="utf8").open() as file:
+
+        with open(
+            "bot_messages/highcouncil_vote.txt", mode="r", encoding="utf8"
+        ) as file:
             message = file.read()
 
             return message.format(
-                clan_council_elect_role_id=settings.role_ids.clan_council_elect,
+                clan_council_elect_role_id=self.config.params.clan_council_elect_role_id,
                 term_start=self.term_start.strftime("%B %d"),
             )
 
@@ -130,26 +152,35 @@ class Election:
         Returns:
             str: Message to send
         """
-        with Path(f"{TEMPLATES_DIR}/vote_start.txt", encoding="utf8").open() as file:
+
+        with open("bot_messages/vote_start.txt", mode="r", encoding="utf8") as file:
             message = file.read()
-            vote_end: datetime = get_datetime(settings.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=settings.role_ids.clan_member,
+                clan_member_id=self.config.params.clan_member_role_id,
                 voting_end=vote_end.strftime("%B %d"),
                 voting_end_day=vote_end.strftime("%A"),
             )
 
     async def check_date(self) -> None:
-        """Function checks current date to see if something needs to be run."""
-        today = datetime.now(tz=UTC)
+        """
+        Function checks current date to see if something needs to be run.
+        """
+        today = datetime.today()
 
         # check all dates if action is needed
         if today.date() == self.election_start.date():
             await self.election_start_action()
         elif today.date() == self.voting_start.date():
             await self.voting_start_action()
-        elif (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()
@@ -159,14 +190,20 @@ class Election:
             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(settings.channel_ids.voting)
-        quarter_name: str = get_election_name()
+        parent: nextcord.TextChannel = self.guild.get_channel(
+            self.config.params.voting_parent_id
+        )
+        quarter_name: str = get_election_cycle_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
@@ -175,14 +212,16 @@ class Election:
         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.guild))
+                nominate_msg: nextcord.Message = await thread.send(
+                    message, view=NominateView(self.config, self.guild)
+                )
             else:
                 await thread.send(message)
 
         # create new entry into database.
         with Session(engine) as session:
             new_cycle = ElectionInformation(
-                ElectionName=quarter_name,
+                ElectionCycle=quarter_name,
                 ThreadId=thread.id,
                 CouncilNominationMsgId=nominate_msg.id,
             )
@@ -191,44 +230,61 @@ class Election:
 
     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.guild),
-            view=VoteView(self.guild),
+            build_votes_str(self.config), view=VoteView(self.config, self.guild)
         )
 
         with Session(engine) as session:
-            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == get_election_name())
+            stmt = select(ElectionInformation).where(
+                ElectionInformation.ElectionCycle
+                == get_election_cycle_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(settings.role_ids.clan_council_elect)
-        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.guild))
+        nominate_msg: nextcord.Message = await election_thread.send(
+            message, view=NominateHighCouncilView(self.config, self.guild)
+        )
 
-        election_name = get_election_name()
+        election_name = get_election_cycle_name(self.config)
 
         with Session(engine) as session:
             # remove vote button from vote message
-            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == 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
@@ -236,18 +292,14 @@ class Election:
             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.ElectionName == election_name)
-                .where(Votes.Type == VoteType.COUNCIL)
-            )
+            stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == election_name)
             vote_count = collections.Counter(session.scalars(stmt))
 
             for user_id, votes in vote_count.items():
-                if votes >= REQUIRED_VOTES_TO_BE_ELECTED:
+                if votes >= 3:
                     stmt = (
                         select(CouncilMembers)
-                        .where(CouncilMembers.ElectionName == election_name)
+                        .where(CouncilMembers.ElectionCycle == election_name)
                         .where(CouncilMembers.MemberId == user_id)
                     )
                     council_member = session.scalar(stmt)
@@ -262,39 +314,56 @@ class Election:
                     )
 
     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.guild),
-            view=VoteHighcouncilView(self.guild),
+            build_highcouncil_votes_str(self.config),
+            view=VoteHighcouncilView(self.config, self.guild),
         )
 
         with Session(engine) as session:
-            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == get_election_name())
+            stmt = select(ElectionInformation).where(
+                ElectionInformation.ElectionCycle
+                == get_election_cycle_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(settings.role_ids.clan_council_elect)
-        council_role: nextcord.Role = self.guild.get_role(settings.role_ids.clan_council)
-
-        election_name = get_election_name()
+        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
+        )
 
         with Session(engine) as session:
             # role management
             stmt = (
                 select(CouncilMembers.MemberId)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(
+                    CouncilMembers.ElectionCycle == get_election_cycle_name(self.config)
+                )
                 .where(CouncilMembers.Elected == true())
             )
 
@@ -311,62 +380,43 @@ class Election:
 
             # announce high council members
             # ties are undefined behavior.
-            stmt = (
-                select(Votes.VotedForId)
-                .where(Votes.ElectionName == election_name)
-                .where(Votes.Type == VoteType.DISCORDMANAGER)
-            )
+            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)
             dm_votes = collections.Counter(session.scalars(stmt))
-            stmt = (
-                select(Votes.VotedForId)
-                .where(Votes.ElectionName == election_name)
-                .where(Votes.Type == VoteType.CLANLEADER)
-            )
+            stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == cl_election)
             cl_votes = collections.Counter(session.scalars(stmt))
 
             try:
                 dm_winner = max(dm_votes, key=dm_votes.get)
-                stmt = (
-                    update(CouncilMembers)
-                    .where(CouncilMembers.ElectionName == election_name)
-                    .where(CouncilMembers.MemberId == dm_winner)
-                    .values(DiscordManager=True)
-                )
-                session.execute(stmt)
             except ValueError:
                 dm_winner = "No winner"
             try:
                 cl_winner = max(cl_votes, key=cl_votes.get)
-                stmt = (
-                    update(CouncilMembers)
-                    .where(CouncilMembers.ElectionName == election_name)
-                    .where(CouncilMembers.MemberId == cl_winner)
-                    .values(ClanLeader=True)
-                )
-                session.execute(stmt)
             except ValueError:
                 cl_winner = "No winner"
 
-            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.ElectionName == get_election_name()
+            ElectionInformation.ElectionCycle == get_election_cycle_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!\nClan Leader: <@{cl_winner}>\n"
+        highcouncil_msg: str = f"Congratulations for our high council members!\n Clan 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)
 
     def get_election_info(self) -> ElectionInformation:
         """
@@ -375,15 +425,24 @@ class Election:
         Returns:
             ElectionInformation: The information from the database about the current election.
         """
+
         with Session(engine) as session:
-            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == get_election_name())
+            stmt = select(ElectionInformation).where(
+                ElectionInformation.ElectionCycle
+                == get_election_cycle_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(settings.channel_ids.general)
+        """
+        Sends a message to general chat reminder clan about election.
+        """
 
-        message = f"Reminder to <@&{settings.role_ids.clan_member}>! Clan elections are happening! Head over "
+        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!"
 
         await general.send(content=message)

classes/gitea_webhook.py

@@ -1,193 +0,0 @@
-# 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,30 +1,32 @@
-"""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 DakinySettings import settings
-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_name,
+    get_election_cycle_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,  # noqa: FBT001
+        usr_nominated: bool,
         speech_content: str,
     ):
         super().__init__(
@@ -32,6 +34,7 @@ class NominateDMModal(nextcord.ui.Modal):
             timeout=5 * 60,  # 5 minutes
         )
         self.usr_id: int = usr_id
+        self.config: DakinyConfig = config
         self.usr_nominated = usr_nominated
 
         self.speech = nextcord.ui.TextInput(
@@ -52,14 +55,15 @@ 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
-            election_name = get_election_name()
+            cycle = get_election_cycle_name(self.config)
             stmt = (
                 select(CouncilMembers)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(CouncilMembers.ElectionCycle == cycle)
                 .where(CouncilMembers.MemberId == self.usr_id)
             )
             council_elect = session.scalar(stmt)
@@ -70,21 +74,26 @@ 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,  # noqa: FBT001
+        usr_nominated: bool,
         speech_content: str,
     ):
         super().__init__(
@@ -92,6 +101,7 @@ class NominateCLModal(nextcord.ui.Modal):
             timeout=5 * 60,  # 5 minutes
         )
         self.usr_id: int = usr_id
+        self.config: DakinyConfig = config
         self.usr_nominated = usr_nominated
 
         self.speech = nextcord.ui.TextInput(
@@ -112,14 +122,15 @@ 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
-            election_name = get_election_name()
+            cycle = get_election_cycle_name(self.config)
             stmt = (
                 select(CouncilMembers)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(CouncilMembers.ElectionCycle == cycle)
                 .where(CouncilMembers.MemberId == self.usr_id)
             )
             council_elect = session.scalar(stmt)
@@ -130,15 +141,24 @@ 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, guild: nextcord.Guild):
+    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
+        self.config: DakinyConfig = config
         self.guild: nextcord.Guild = guild
 
     @nextcord.ui.button(
@@ -146,10 +166,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:  # noqa: ARG002
+    async def nominate_dm(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
-        Button for nominating oneself for Discord Manager.
-
         Gathers previous information about the user if they have already nominated themselves, then launches
         the nomination modal to get their speech.
 
@@ -157,21 +177,25 @@ 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(settings.role_ids.clan_council_elect) 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 <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
             )
             return
 
-        election_name = get_election_name()
+        cycle = get_election_cycle_name(self.config)
         usr_nominated = False
         speech_content = ""
         with Session(engine) as session:
             stmt = (
                 select(CouncilMembers)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(CouncilMembers.ElectionCycle == cycle)
                 .where(CouncilMembers.MemberId == interaction.user.id)
             )
             obj = session.scalar(stmt)
@@ -179,20 +203,26 @@ 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(interaction.user.id, usr_nominated, speech_content))
+        await interaction.response.send_modal(
+            NominateDMModal(
+                self.config, interaction.user.id, usr_nominated, speech_content
+            )
+        )
 
     @nextcord.ui.button(
         label="Nominate for Clan Leader",
         style=nextcord.ButtonStyle.primary,
         custom_id="nominate-cl",
     )
-    async def nominate_cl(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
+    async def nominate_cl(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
-        Button for nominating oneself for Clan Leader.
-
         Gathers previous information about the user if they have already nominated themselves, then launches
         the nomination modal to get their speech.
 
@@ -200,21 +230,25 @@ 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(settings.role_ids.clan_council_elect) 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 <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
             )
             return
 
-        election_name = get_election_name()
+        cycle = get_election_cycle_name(self.config)
         usr_nominated = False
         speech_content = ""
         with Session(engine) as session:
             stmt = (
                 select(CouncilMembers)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(CouncilMembers.ElectionCycle == cycle)
                 .where(CouncilMembers.MemberId == interaction.user.id)
             )
             obj = session.scalar(stmt)
@@ -225,4 +259,8 @@ class NominateHighCouncilView(nextcord.ui.View):
                 msg = await interaction.channel.fetch_message(obj.ClanLeaderSpeechId)
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
-        await interaction.response.send_modal(NominateCLModal(interaction.user.id, usr_nominated, speech_content))
+        await interaction.response.send_modal(
+            NominateCLModal(
+                self.config, interaction.user.id, usr_nominated, speech_content
+            )
+        )

classes/nominate_views.py

@@ -1,25 +1,27 @@
-"""Contains various views to be used in the nomination process."""
+"""
+Contains various views to be used in the nomination process.
+"""
 
 import nextcord
-from DakinySettings import settings
-from database_setup.sql_data_classes import CouncilMembers, engine
 from nextcord.interactions import Interaction
 from sqlalchemy import select
 from sqlalchemy.orm import Session
-from utils import NOMINEE_SPLITTER, decorate_nomination, get_election_name
+
+from config import DakinyConfig
+from database_setup.sql_data_classes import CouncilMembers, engine
+from utils import NOMINEE_SPLITTER, decorate_nomination, get_election_cycle_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,  # noqa: FBT001
+        usr_nominated: bool,
         speech_content: str,
     ):
         super().__init__(
@@ -27,6 +29,7 @@ class NominateModal(nextcord.ui.Modal):
             timeout=5 * 60,  # 5 minutes
         )
         self.usr_id: int = usr_id
+        self.config: DakinyConfig = config
         self.usr_nominated = usr_nominated
 
         self.speech = nextcord.ui.TextInput(
@@ -47,15 +50,15 @@ class NominateModal(nextcord.ui.Modal):
             interaction (Interaction): Interaction with user.
 
         """
+
         speech = decorate_nomination(interaction.user.id, self.speech.value)
-        election_name = get_election_name()
 
         with Session(engine) as session:
             if not self.usr_nominated:
                 msg = await interaction.channel.send(speech)
 
                 council_member = CouncilMembers(
-                    ElectionName=election_name,
+                    ElectionCycle=get_election_cycle_name(self.config),
                     MemberId=interaction.user.id,
                     SpeechMsgId=msg.id,
                 )
@@ -63,22 +66,30 @@ 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)
                 stmt = (
                     select(CouncilMembers)
-                    .where(CouncilMembers.ElectionName == election_name)
+                    .where(CouncilMembers.ElectionCycle == cycle)
                     .where(CouncilMembers.MemberId == self.usr_id)
                 )
                 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, guild: nextcord.Guild):
+    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
+        self.config: DakinyConfig = config
         self.guild: nextcord.Guild = guild
 
     @nextcord.ui.button(
@@ -86,10 +97,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:  # noqa: ARG002
+    async def nominate(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
-        Button to nominate oneself for Clan Council.
-
         Gathers previous information about the user if they have already nominated themselves, then launches
         the nomination modal to get their speech.
 
@@ -97,21 +108,25 @@ 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(settings.role_ids.clan_member) 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 <@&{settings.role_ids.clan_member}> role to vote.",
+                f"You must have the <@&{self.config.params.clan_member_role_id}> role to vote.",
                 ephemeral=True,
             )
             return
 
-        election_name = get_election_name()
+        cycle = get_election_cycle_name(self.config)
         usr_nominated = False
         speech_content = ""
         with Session(engine) as session:
             stmt = (
                 select(CouncilMembers)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(CouncilMembers.ElectionCycle == cycle)
                 .where(CouncilMembers.MemberId == interaction.user.id)
             )
             obj = session.scalar(stmt)
@@ -120,4 +135,8 @@ class NominateView(nextcord.ui.View):
                 msg = await interaction.channel.fetch_message(obj.SpeechMsgId)
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
-        await interaction.response.send_modal(NominateModal(interaction.user.id, usr_nominated, speech_content))
+        await interaction.response.send_modal(
+            NominateModal(
+                self.config, interaction.user.id, usr_nominated, speech_content
+            )
+        )

classes/pyproject.toml

@@ -1,10 +0,0 @@
-[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,56 +1,70 @@
-"""Contains various views to be used while voting for high council. Controls the logic when performing the vote."""
+"""
+Contains various views to be used while voting for high council. Controls the logic when performing the vote.
+"""
+
+from typing import List
 
 import nextcord
-from DakinySettings import settings
+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,
     ElectionInformation,
     Votes,
     engine,
 )
-from nextcord import SelectOption
-from nextcord.interactions import Interaction
-from sqlalchemy import exc, select, update
-from sqlalchemy.orm import Session
-from utils import VoteType, build_highcouncil_votes_str, get_election_name
+from utils import (
+    build_highcouncil_votes_str,
+    get_cl_election_name,
+    get_dm_election_name,
+    get_election_cycle_name,
+)
 
 
 class VoteSelect(nextcord.ui.StringSelect):
-    """Vote view string select."""
-
-    def __init__(self, options: list["SelectOption"], election_type: str) -> None:
+    def __init__(
+        self, options: List["SelectOption"], config: DakinyConfig, election_type: str
+    ) -> None:
         super().__init__(
             placeholder="Choose 1",
             min_values=1,
             max_values=1,
             options=options,
         )
+        self.config = config
         self.election_type = election_type
 
-    async def callback(self, interaction: Interaction) -> None:
-        """
-        Callback override for the StringSelect.
+    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"')
 
-        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()
+        cycle: str = get_election_cycle_name(self.config)
         with Session(engine) as session:
             stmt = select(ElectionInformation.HighCouncilVoteMsgId).where(
-                ElectionInformation.ElectionName == election_name
+                ElectionInformation.ElectionCycle == cycle
             )
             vote_msg_id = session.scalar(stmt)
 
-            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
+            if self.values[0] == "Abstain":
+                voted_for = None
+            else:
+                voted_for = int(self.values[0])
 
             new_vote = Votes(
-                ElectionName=election_name,
+                ElectionCycle=election_name,
                 VoterId=interaction.user.id,
                 VotedForId=voted_for,
-                Type=self.election_type,
             )
 
             try:
@@ -58,32 +72,38 @@ 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.ElectionName == election_name)
+                    .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(interaction.guild)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
+        vote_message_str = build_highcouncil_votes_str(self.config)
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
+            vote_msg_id
+        )
         await vote_msg.edit(content=vote_message_str)
 
-        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "You have abstained from voting."
+        if voted_for is not None:
+            msg = f"You have voted for <@{voted_for}>"
+        else:
+            msg = "You have abstained from voting."
 
         await interaction.edit(content=msg, view=None)
 
 
 class VoteHighcouncilView(nextcord.ui.View):
-    """The button to press to start voting for HighCouncil."""
+    """
+    The button to press to start voting for HighCouncil.
+    """
 
-    def __init__(self, guild: nextcord.Guild):
+    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
+        self.config = config
         self.guild = guild
 
     @nextcord.ui.button(
@@ -91,10 +111,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:  # noqa: ARG002
+    async def vote_cl(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
-        Button to vote for Clan Leader.
-
         Enforces only council elect vote. Gets election cycle, creates voting
         options for clan leader (checking if user has voted already),
         then sends the voting view.
@@ -103,44 +123,43 @@ 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(settings.role_ids.clan_council_elect) 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 <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
             )
             return
 
-        election_name: str = get_election_name()
+        cycle: str = get_election_cycle_name(self.config)
+        election: str = get_cl_election_name(self.config)
 
         with Session(engine) as session:
             stmt = (
                 select(Votes.VotedForId)
-                .where(Votes.ElectionName == election_name)
+                .where(Votes.ElectionCycle == election)
                 .where(Votes.VoterId == interaction.user.id)
-                .where(Votes.Type == VoteType.CLANLEADER)
             )
             voted_for = session.scalar(stmt)
 
             stmt = (
                 select(CouncilMembers.MemberId)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(CouncilMembers.ElectionCycle == cycle)
                 .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(
-                    session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name.lower(),
-                )
+                for nominee in session.scalars(stmt)
             ]
             options.append(
                 SelectOption(
@@ -150,7 +169,9 @@ class VoteHighcouncilView(nextcord.ui.View):
             )
 
         view = nextcord.ui.View()
-        view.add_item(VoteSelect(options=options, election_type=VoteType.CLANLEADER))
+        view.add_item(
+            VoteSelect(options=options, config=self.config, election_type="cl")
+        )
 
         await interaction.response.send_message(
             content="Please vote for a Clan Leader!",
@@ -163,10 +184,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:  # noqa: ARG002
+    async def vote_dm(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
-        Button to vote for Discord Manager.
-
         Enforces only council elect vote. Gets election cycle, creates voting
         options for discord manager (checking if user has voted already),
         then sends the voting view.
@@ -175,44 +196,43 @@ 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(settings.role_ids.clan_council_elect) 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 <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
                 ephemeral=True,
             )
             return
 
-        election_name: str = get_election_name()
+        cycle: str = get_election_cycle_name(self.config)
+        election: str = get_dm_election_name(self.config)
 
         with Session(engine) as session:
             stmt = (
                 select(Votes.VotedForId)
-                .where(Votes.ElectionName == election_name)
+                .where(Votes.ElectionCycle == election)
                 .where(Votes.VoterId == interaction.user.id)
-                .where(Votes.Type == VoteType.DISCORDMANAGER)
             )
             voted_for = session.scalar(stmt)
 
             stmt = (
                 select(CouncilMembers.MemberId)
-                .where(CouncilMembers.ElectionName == election_name)
+                .where(CouncilMembers.ElectionCycle == cycle)
                 .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(
-                    session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name.lower(),
-                )
+                for nominee in session.scalars(stmt)
             ]
             options.append(
                 SelectOption(
@@ -223,10 +243,7 @@ class VoteHighcouncilView(nextcord.ui.View):
 
         view = nextcord.ui.View()
         view.add_item(
-            VoteSelect(
-                options=options,
-                election_type=VoteType.DISCORDMANAGER,
-            )
+            VoteSelect(options=options, config=self.config, election_type="dm")
         )
 
         await interaction.response.send_message(

classes/voting_views.py

@@ -1,53 +1,52 @@
-"""Contains various views to be used while voting. Controls the logic when performing the vote."""
+"""
+Contains various views to be used while voting. Controls the logic when performing the vote.
+"""
+
+from typing import List
 
 import nextcord
-from DakinySettings import settings
+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,
     ElectionInformation,
     Votes,
     engine,
 )
-from nextcord import SelectOption
-from nextcord.interactions import Interaction
-from sqlalchemy import exc, select, update
-from sqlalchemy.orm import Session
-from utils import VoteType, build_votes_str, get_election_name
+from utils import build_votes_str, get_election_cycle_name
 
 
 class VoteSelect(nextcord.ui.StringSelect):
-    """Vote view string select."""
-
-    def __init__(self, options: list["SelectOption"]) -> None:
+    def __init__(self, options: List["SelectOption"], config: DakinyConfig) -> None:
         super().__init__(
             placeholder="Choose 1",
             min_values=1,
             max_values=1,
             options=options,
         )
+        self.config = 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()
+    async def callback(self, interaction: Interaction):
+        election_name = get_election_cycle_name(self.config)
         with Session(engine) as session:
-            stmt = select(ElectionInformation.CouncilVoteMsgId).where(ElectionInformation.ElectionName == election_name)
+            stmt = select(ElectionInformation.CouncilVoteMsgId).where(
+                ElectionInformation.ElectionCycle == election_name
+            )
             vote_msg_id = session.scalar(stmt)
 
-            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
+            if self.values[0] == "Abstain":
+                voted_for = None
+            else:
+                voted_for = int(self.values[0])
 
             new_vote = Votes(
-                ElectionName=election_name,
+                ElectionCycle=election_name,
                 VoterId=interaction.user.id,
                 VotedForId=voted_for,
-                Type=VoteType.COUNCIL,
             )
 
             try:
@@ -58,76 +57,85 @@ class VoteSelect(nextcord.ui.StringSelect):
                 session.rollback()
                 stmt = (
                     update(Votes)
-                    .where(Votes.ElectionName == election_name)
+                    .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(interaction.guild)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
+        vote_message_str = build_votes_str(self.config)
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
+            vote_msg_id
+        )
         await vote_msg.edit(content=vote_message_str)
 
-        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "You have abstained from voting."
+        if voted_for is not None:
+            msg = f"You have voted for <@{voted_for}>"
+        else:
+            msg = "You have abstained from voting."
 
         await interaction.edit(content=msg, view=None)
 
 
 class VoteView(nextcord.ui.View):
-    """The button to press to start your nomination."""
+    """
+    The button to press to start your nomination.
+    """
 
-    def __init__(self, guild: nextcord.Guild):
+    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:  # noqa: ARG002
+    @nextcord.ui.button(
+        label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote"
+    )
+    async def vote(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
-        Enforces only members vote.
-
-        Gets election cycle, creates voting options (checking if user has voted already),
+        Enforces only members vote. Gets election cycle, creates voting options (checking if user has voted already),
         then sends the voting view.
 
         Args:
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
+
         # enforce members only
-        if self.guild.get_role(settings.role_ids.clan_member) 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 <@&{settings.role_ids.clan_member}> role to vote.",
+                f"You must have the <@&{self.config.params.clan_member_role_id}> role to vote.",
                 ephemeral=True,
             )
             return
 
-        election_name: str = get_election_name()
+        election: str = get_election_cycle_name(self.config)
 
         with Session(engine) as session:
             stmt = (
                 select(Votes.VotedForId)
-                .where(Votes.ElectionName == election_name)
+                .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.ElectionName == election_name)
+            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(
-                    session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name.lower(),
-                )
+                for nominee in session.scalars(stmt)
             ]
             options.append(
                 SelectOption(
@@ -137,7 +145,7 @@ class VoteView(nextcord.ui.View):
             )
 
         view = nextcord.ui.View()
-        view.add_item(VoteSelect(options))
+        view.add_item(VoteSelect(options=options, config=self.config))
 
         await interaction.response.send_message(
             content="Please vote for a clan member!",

cogs/clan_messages/__init__.py

@@ -1,91 +0,0 @@
-"""File contains logic for creating a webhook listener, pulling from git, and updating all messages."""
-
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import uvicorn
-from fastapi import FastAPI
-from git import Repo
-from nextcord.ext import commands
-
-from classes.gitea_webhook import GiteaWebhook
-from DakinySettings import settings
-from utils import REPO_DIR, edit_clan_council_info, update_clan_messages
-
-if TYPE_CHECKING:
-    import nextcord
-
-app = FastAPI()
-REPO_URL = "https://gitea.cheezers.org/imcompiling/dakiny-messages.git"
-
-
-class ClanMessages(commands.Cog, name="Clan Messages"):
-    """
-    Cog to be loaded into the bot.
-
-    Used to be able to have a fastapi post listener and access to the bot at
-    the same time.
-    """
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-        self.repo_setup()
-
-    @commands.Cog.listener()
-    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"])
-        # Bind to all interfaces, don't know the docker interface ahead of time.
-        config = uvicorn.Config(app=app, host="0.0.0.0", port=5000, log_level="info")  # noqa: S104
-        server = uvicorn.Server(config)
-        await server.serve()
-
-    async def update_messages(self, hook_info: GiteaWebhook) -> 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(settings.params.guild_id)
-
-        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(settings.params.guild_id))
-
-        return {"message": "Successfully updated all discord messages."}
-
-    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 Path(REPO_DIR).is_dir():
-            self.repo = Repo(REPO_DIR)
-        else:
-            self.repo = Repo.clone_from(REPO_URL, REPO_DIR)
-
-        self.origin = self.repo.remote("origin")
-
-        if settings.params.git_branch == "test":
-            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.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) -> None:
-    """Adds function to bot."""
-    bot.add_cog(ClanMessages(bot))

cogs/commands/__init__.py

@@ -1,28 +1,25 @@
-"""Cog loader. Adds all command cogs to the bot."""
+"""
+Cog loader. Adds all command cogs to the bot.
+"""
 
 from nextcord.ext import commands
 
-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.settings import SettingsCog
+from cogs.commands.set import setCog
 from cogs.commands.test import TestCog
-from cogs.commands.time import TimeCog
 from cogs.commands.view import ViewCog
 
 
 # This function will be called when this extension is loaded.
 # It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot) -> None:
-    """Adds all command classes to bot."""
-    bot.add_cog(RecordCog(bot))
-    bot.add_cog(RefreshCog(bot))
+def setup(bot: commands.Bot):
+    """
+    Adds all command classes to bot.
+    """
+
     bot.add_cog(RemoveCog())
     bot.add_cog(RequestCog(bot))
-    bot.add_cog(SetCog())
-    bot.add_cog(SettingsCog())
     bot.add_cog(TestCog(bot))
-    bot.add_cog(TimeCog())
     bot.add_cog(ViewCog())
+    bot.add_cog(setCog())

cogs/commands/record.py

@@ -1,358 +0,0 @@
-"""Contained commands and views for record commands."""
-
-import nextcord
-from discord import TextInputStyle
-from nextcord.ext import commands
-
-from DakinySettings import settings
-from utils import GUILDS, MAX_DISCORD_MESSAGE_LENGTH, PointType, record_points
-
-
-class RecordCog(commands.Cog, name="Record Commands"):
-    """Class holds record commands."""
-
-    def __init__(self, bot: commands.Bot) -> None:
-        """Default constructor for RecordCog class. Does nothing."""
-        super().__init__()
-        self.bot: commands.Bot = bot
-
-    @nextcord.slash_command(guild_ids=GUILDS)
-    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."),
-        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.
-
-        Args:
-            interaction (nextcord.Interaction): interaction with this command.
-            name (str): Name of the event.
-            host (nextcord.Member, optional): Alternative host to user using command.
-        """
-        # check role
-        if interaction.guild.get_role(settings.role_ids.event_host) not in interaction.user.roles:
-            await interaction.response.send_message(
-                f"You must have the <@&{settings.role_ids.event_host}> role to record an event.",
-                ephemeral=True,
-            )
-            return
-
-        if host is None:
-            host = interaction.user
-
-        embed: nextcord.Embed = nextcord.Embed(title=name, description="")
-        embed.add_field(name="Participants", value="")
-        embed.add_field(name="Non-Discord Participants", value="")
-        embed.add_field(name="Hosted by", value=f"<@{host.id}>", inline=False)
-
-        await interaction.response.send_message(
-            "Fill out event details and select all members who participated!",
-            view=EventView(name, host.id),
-            ephemeral=True,
-            embed=embed,
-        )
-
-    @record.subcommand(description="Record a miscellaneous point for a clan member.")
-    async def point(
-        self,
-        interaction: nextcord.Interaction,
-        activity: str = nextcord.SlashOption(
-            description="The type of activity to receive points for.",
-            required=True,
-            choices=[
-                "Clan chat activity",
-                "Teaching or sharing in-game tips",
-                "Recruiting efforts",
-                "Successful recruitment",
-            ],
-        ),
-        justification: str = nextcord.SlashOption(
-            required=True,
-            description="Reason to give the recipient a point.",
-            max_length=int(MAX_DISCORD_MESSAGE_LENGTH / 2),
-        ),
-        recipient: nextcord.Member = nextcord.SlashOption(
-            required=False,
-            description="Discord user to give point to.",
-        ),
-        non_discord_recipient: str = nextcord.SlashOption(
-            required=False, description="Non Discord user to give point to.", max_length=32
-        ),
-    ) -> None:
-        """
-        Gives a point to the provided recipient. Sends recording message to event participation channel.
-
-        Only one recipient should be given point/provided to the command. Fails if not exactly one recipient
-        is given.
-
-        Args:
-            interaction (nextcord.Interaction): interaction with this command.
-            activity (str): Choice list of activities to give point for.
-            justification (str): Reason to give point.
-            recipient (nextcord.Member): Discord member to give point to.
-            non_discord_recipient (str): Non Discord member to give point to.
-        """
-        # role check
-        if interaction.guild.get_role(settings.role_ids.clan_member) not in interaction.user.roles:
-            await interaction.response.send_message(
-                f"You must have the <@&{settings.role_ids.clan_member}> role to record points.",
-                ephemeral=True,
-            )
-            return
-
-        # pylint or whatever seems to think that there are lines of unreachable code. That is false.
-        if recipient and non_discord_recipient:
-            await interaction.response.send_message("Please only provide 1 recipient.", ephemeral=True)
-            return
-        elif recipient is not None:  # noqa: RET505
-            record_points(
-                [str(recipient.id)],
-                settings.point_settings.clan_points,
-                PointType.CLAN,
-                is_member=True,
-            )
-            recipient_str = f"<@{recipient.id}>"
-        elif non_discord_recipient is not None:
-            record_points(
-                [non_discord_recipient],
-                settings.point_settings.clan_points,
-                PointType.CLAN,
-                is_member=False,
-            )
-            recipient_str = f'"{non_discord_recipient}"'
-        else:
-            await interaction.response.send_message("You must provide a recipient.", ephemeral=True)
-            return
-
-        event_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.event_post)
-
-        msg = f"<@{interaction.user.id}> has given {recipient_str} points for the {activity} activity. Justification: {justification}"  # noqa: E501
-        if not msg.endswith("."):
-            msg += "."
-        await event_channel.send(msg)
-        await interaction.response.send_message("Point has been added.", ephemeral=True)
-
-
-class EventView(nextcord.ui.View):
-    """
-    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.
-    """
-
-    def __init__(self, name: str, host_id: int):
-        super().__init__(timeout=60 * 60 * 2)  # timeout 2 hours
-
-        self.name: str = name
-        self.host_id: int = host_id
-
-        self.event_participants = ParticipantSelect()
-
-        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) -> 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) -> 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) -> None:  # noqa: ARG002
-        """
-        Submits the event embed to the event channel.
-
-        Removes view and embed from recording message.
-        Sends point information to database.
-        """
-        if settings.point_settings.verify_events:
-            verification_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.admin)
-            verification_view = EventVerification(
-                self.event_participants.values.members, interaction.message.embeds[0].fields[1].value, self.host_id
-            )
-            await verification_channel.send(
-                content="Event record request.", embed=interaction.message.embeds[0], view=verification_view
-            )
-            submission_response = "Event has been submitted to admins for approval."
-        else:
-            process_event(
-                self.event_participants.values.members,
-                interaction.message.embeds[0].fields[1].value,
-                self.host_id,
-            )
-
-            event_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.event_post)
-            await event_channel.send(embed=interaction.message.embeds[0])
-            submission_response = "Event has been submitted."
-
-        await interaction.response.edit_message(content=submission_response, view=None, embed=None)
-        self.stop()
-
-
-class EventVerification(nextcord.ui.View):
-    """Class contains code to approve/deny event submissions."""
-
-    def __init__(
-        self,
-        discord_users: list[nextcord.Member],
-        non_discord_users: str,
-        host_id: int,
-    ):
-        super().__init__(timeout=None, auto_defer=True)
-        self.discord_users: list[nextcord.Member] = discord_users
-        self.non_discord_users: str = non_discord_users
-        self.host_id: int = host_id
-
-    @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
-    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
-        """
-        Approve button for an event submission.
-
-        Calls the process event function. Records who approved the event.
-        Removes the view from the interaction message.
-
-        Args:
-            button (nextcord.ui.Button): Unused.
-            interaction (nextcord.Interaction): The interaction of the user clicking the button.
-        """
-        process_event(self.discord_users, self.non_discord_users, self.host_id)
-        event_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.event_post)
-        await event_channel.send(embed=interaction.message.embeds[0])
-
-        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) -> None:  # noqa: ARG002
-        """
-        Deny button for an event submission. Just removes the view and logs who denied the request.
-
-        Args:
-            button (nextcord.ui.Button): Unused.
-            interaction (nextcord.Interaction): The interaction of the user clicking the button.
-        """
-        content = f"\nDenied by <@{interaction.user.id}>."
-        await interaction.response.edit_message(content=content, view=None)
-
-
-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.
-    """
-
-    # consider turning this embed into a dict
-    def __init__(self, embed: nextcord.Embed):
-        super().__init__(
-            "Edit the event.",
-            timeout=5 * 60,
-        )
-        self.embed: nextcord.Embed = embed
-        self.name: nextcord.ui.TextInput = nextcord.ui.TextInput(
-            required=True,
-            label="Event Name",
-            default_value=self.embed.title,
-        )
-        self.description: nextcord.ui.TextInput = nextcord.ui.TextInput(
-            required=False,
-            label="Event Description",
-            default_value=self.embed.description,
-            style=TextInputStyle.paragraph,
-            placeholder="Add a description if desired.",
-            max_length=1000,
-        )
-        self.participants: nextcord.ui.TextInput = nextcord.ui.TextInput(
-            required=False,
-            label="Non-Discord Usernames",
-            style=TextInputStyle.paragraph,
-            placeholder="Please separate usernames with a new line.",
-            default_value=self.embed.fields[1].value,
-        )
-        self.add_item(self.name)
-        self.add_item(self.description)
-        self.add_item(self.participants)
-
-    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)
-
-        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."""
-
-    def __init__(self) -> None:
-        super().__init__(
-            min_values=1,
-            max_values=25,
-            placeholder="Select all participants",
-            row=0,
-        )
-
-    async def callback(self, interaction: nextcord.Interaction) -> None:
-        """
-        Edits the interaction message to contain the Discord participants.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction of the callback.
-        """
-        embed: nextcord.Embed = interaction.message.embeds[0]
-        participants: str = "\n".join([f"<@{participant.id}>" for participant in self.values.members])
-        embed.set_field_at(0, name="Participants", value=participants)
-        await interaction.response.edit_message(embed=embed)
-
-
-def process_event(discord_users: list[nextcord.Member], non_discord_users: str, host_id: int) -> None:
-    """
-    Processes all points to give to participants and host for an event.
-
-    Args:
-        discord_users (list[nextcord.Member]): List of discord members that participated in event.
-        non_discord_users (str): Newline separated list of non discord members that participated in event.
-        host_id (int): Discord ID of host.
-    """
-    if discord_users:
-        discord_users_list: list[str] = [str(user.id) for user in discord_users if user.id is not host_id]
-        record_points(
-            discord_users_list,
-            settings.point_settings.participate_points,
-            PointType.EVENT,
-            is_member=True,
-        )
-
-    if non_discord_users:
-        non_discord_users_list: list[str] = non_discord_users.split("\n")
-        record_points(
-            non_discord_users_list,
-            settings.point_settings.participate_points,
-            PointType.EVENT,
-            is_member=False,
-        )
-
-    record_points([host_id], settings.point_settings.host_points, PointType.EVENT, is_member=True)

cogs/commands/refresh.py

@@ -1,65 +0,0 @@
-"""Contained commands and views for refresh commands."""
-
-import os
-from pathlib import Path
-
-import nextcord
-from nextcord.ext import commands
-
-from utils import MESSAGES_DIR, edit_clan_council_info, update_clan_messages
-
-
-class RefreshCog(commands.Cog, name="Refresh Commands"):
-    """Class holds refresh commands."""
-
-    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) -> 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,
-        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)
-
-        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) -> 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)
-        await interaction.response.send_message("Clan Council Info message updated.", ephemeral=True)

cogs/commands/remove.py

@@ -1,4 +1,6 @@
-"""Commands for removing information in the database."""
+"""
+Commands for removing information in the database.
+"""
 
 import nextcord
 from nextcord.ext import commands
@@ -9,30 +11,39 @@ 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) -> None:
-        """Parent slash command for set. Never called."""
+    async def remove(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for set. Never called.
+        """
 
     @remove.subcommand(description="Remove a presence from the database.")
     async def presence(
         self,
         interaction: nextcord.Interaction,
-        presence_str: str = nextcord.SlashOption(description="The presence to remove", required=True),
-    ) -> None:
+        presence_str: str = nextcord.SlashOption(
+            description="The presence to remove", required=True
+        ),
+    ):
         """
         Deletes the given presence id from the database.
 
         Args:
             interaction (nextcord.Interaction): Interaction that invoked the command.
-            presence_str (str): Is SlashOption. The presence to remove. Is the ID of the presence.
+            presence (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)
@@ -42,26 +53,34 @@ 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) -> None:
+    async def presence_autocomplete(
+        self, interaction: nextcord.Interaction, presence_str: str
+    ):
         """
         Collects all presences that start with the presence string.
-
         Sends autocomplete dict {Presence Name, Presence Id}
 
         Args:
             interaction (nextcord.Interaction): Interaction with command.
             presence_str (str): String to run autocomplete on.
         """
+
         with Session(engine) as session:
             stmt = select(Presences)
-            presences_dict: dict[str,str] = {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,25 +1,35 @@
-"""Contains commands and views for request commands."""
+"""
+Contains commands and views for request commands.
+"""
 
 import nextcord
 from nextcord.ext import commands
 from sqlalchemy.orm import Session
 
-from DakinySettings import settings
+from config import DakinyConfig
 from database_setup.sql_data_classes import Presences, engine
 
 
 class RequestCog(commands.Cog, name="Request Commands"):
-    """Class holds request commands."""
+    """
+    Class holds request commands.
+    """
 
-    def __init__(self, bot: commands.Bot) -> None:
-        """Default constructor for RequestCog class. Does nothing."""
+    def __init__(self, bot) -> None:
+        """
+        Default constructor for RequestCog class. Does nothing.
+        """
         self.bot: commands.Bot = bot
 
     @nextcord.slash_command()
-    async def request(self, interaction: nextcord.Interaction) -> None:
-        """Parent slash command for request. Never called."""
+    async def request(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for help. 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,
@@ -29,7 +39,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.
 
@@ -37,10 +47,16 @@ 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(settings.channel_ids.admin).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(
@@ -52,22 +68,30 @@ 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_nickname(str): The username to change to.
+            new_username(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(settings.channel_ids.admin).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,
@@ -79,11 +103,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) -> None:  # noqa: ARG002
+    async def approve(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):
         """
-        Approve button for a nickname change request.
-
-        Changes the target's nickname to self.new_nickname.
+        Approve button for a nickname change request. Changes the target's nickname to self.new_nickname.
         Catches an error if the target as a higher role than the bot.
         Removes the view from the interaction message.
 
@@ -95,7 +119,10 @@ 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(
@@ -106,15 +133,17 @@ 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 occurred while changing the user's nickname.",
+                content="An error occured while changing the user's nickname.",
                 view=None,
             )
 
     @nextcord.ui.button(label="Deny", style=nextcord.ButtonStyle.red)
-    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
+    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
         """
         Deny button for a nickname request. Just removes the view and logs who denied the request.
 
@@ -127,7 +156,9 @@ 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,
@@ -137,26 +168,29 @@ 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) -> None:  # noqa: ARG002
+    async def approve(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):
         """
-        Approve button for a presence add request.
-
-        Adds the presence to the database.
+        Approve button for a presence add request. Adds the presence to the database.
         Removes the view from the interaction message.
 
         Args:
             button (nextcord.ui.Button): Unused.
             interaction (nextcord.Interaction): The interaction of the user clicking the button.
         """
+
         with Session(engine) as session:
             session.add(Presences(Presence=self.presence))
             session.commit()
 
-        content = 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) -> None:  # noqa: ARG002
+    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
         """
         Deny button for a presence add request. Just removes the view and logs who denied the request.
 

cogs/commands/set.py

@@ -1,6 +1,8 @@
-"""Contains commands and views for set commands."""
+"""
+Contains commands and views for set commands.
+"""
 
-from datetime import UTC, datetime
+from datetime import datetime
 
 import nextcord
 from nextcord.ext import commands
@@ -8,19 +10,25 @@ from sqlalchemy import delete, select
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
+from dakiny_bot import birthday_list
 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) -> None:
-        """Parent slash command for set. Never called."""
+    async def set(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for set. Never called.
+        """
 
     @set.subcommand(description="Sets your birth month and day for the Birthday Fun. Use 0/0 to remove yourself.")
     async def birthday(
@@ -28,7 +36,7 @@ class SetCog(commands.Cog, name="Set Commands"):
         interaction: nextcord.Interaction,
         month: int = nextcord.SlashOption(required=True, min_value=0, max_value=12, description="Your birth month."),
         day: int = nextcord.SlashOption(required=True, min_value=0, max_value=31, description="Your birth day."),
-    ) -> None:
+    ):
         """
         Sets a user's birthday in the database. Removes on input 0/0. If birthday is today, adds to the birthday_list.
 
@@ -37,6 +45,7 @@ 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)
 
@@ -49,9 +58,9 @@ class SetCog(commands.Cog, name="Set Commands"):
                 return
 
         # check if valid day
-        today = datetime.now(tz=UTC)
+        today = datetime.today()
         try:
-            birthday = datetime(today.year, month, day, tzinfo=UTC)
+            birthday = datetime(today.year, month, day)
         except ValueError:
             await interaction.followup.send(f"Invalid date: {month}/{day}.", ephemeral=True)
             return

cogs/commands/settings.py

@@ -1,379 +0,0 @@
-"""Contains commands and views for settings commands."""
-
-import nextcord
-from nextcord.ext import commands
-
-from DakinySettings import settings
-from utils import GUILDS
-
-
-class SettingsCog(commands.Cog, name="Settings Commands"):
-    """Class holds settings commands."""
-
-    def __init__(self) -> None:
-        """Default constructor for SettingsCog class. Does nothing."""
-
-    @nextcord.slash_command(guild_ids=GUILDS, default_member_permissions=nextcord.Permissions(administrator=True))
-    async def settings(self, interaction: nextcord.Interaction) -> None:
-        """Parent slash command for settings. Never called."""
-
-    @settings.subcommand()
-    async def channel_ids(self, interaction: nextcord.Interaction) -> None:
-        """Subcommand parent. Never called."""
-
-    @channel_ids.subcommand(description="Sets channel that bot sends verification requests to admins.")
-    async def admin(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel = nextcord.SlashOption(
-            required=False, description="Channel to set to. If left blank, uses current channel."
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings channel_ids.admin value to given channel id or current channel id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            channel (nextcord.TextChannel, optional): Channel to set in settings.
-        """
-        channel_id = interaction.channel_id if channel is None else channel.id
-        settings.channel_ids.admin = channel_id
-        settings.save()
-        await interaction.response.send_message(f"Admin verification channel set to <#{channel_id}>.", ephemeral=True)
-
-    @channel_ids.subcommand(description="Sets announcement channel.")
-    async def announcement(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel = nextcord.SlashOption(
-            required=False, description="Channel to set to. If left blank, uses current channel."
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings channel_ids.announcement value to given channel id or current channel id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            channel (nextcord.TextChannel, optional): Channel to set in settings.
-        """
-        channel_id = interaction.channel_id if channel is None else channel.id
-        settings.channel_ids.announcement = channel_id
-        settings.save()
-        await interaction.response.send_message(f"Announcement channel set to <#{channel_id}>.", ephemeral=True)
-
-    @channel_ids.subcommand(description="Sets clan info channel. Channel used for tracking current council.")
-    async def clan_info(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel = nextcord.SlashOption(
-            required=False, description="Channel to set to. If left blank, uses current channel."
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings channel_ids.clan_info value to given channel id or current channel id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            channel (nextcord.TextChannel, optional): Channel to set in settings.
-        """
-        channel_id = interaction.channel_id if channel is None else channel.id
-        settings.channel_ids.clan_info = channel_id
-        settings.save()
-        await interaction.response.send_message(f"Clan information channel set to <#{channel_id}>.", ephemeral=True)
-
-    @channel_ids.subcommand(
-        description="Sets event post channel. Channel is where event tracking information is posted."
-    )
-    async def event_post(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel = nextcord.SlashOption(
-            required=False, description="Channel to set to. If left blank, uses current channel."
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings channel_ids.event_post value to given channel id or current channel id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            channel (nextcord.TextChannel, optional): Channel to set in settings.
-        """
-        channel_id = interaction.channel_id if channel is None else channel.id
-        settings.channel_ids.event_post = channel_id
-        settings.save()
-        await interaction.response.send_message(f"Event posting channel set to <#{channel_id}>.", ephemeral=True)
-
-    @channel_ids.subcommand(description="Sets general channel.")
-    async def general(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel = nextcord.SlashOption(
-            required=False, description="Channel to set to. If left blank, uses current channel."
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings channel_ids.general value to given channel id or current channel id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            channel (nextcord.TextChannel, optional): Channel to set in settings.
-        """
-        channel_id = interaction.channel_id if channel is None else channel.id
-        settings.channel_ids.general = channel_id
-        settings.save()
-        await interaction.response.send_message(f"General channel set to <#{channel_id}>.", ephemeral=True)
-
-    @channel_ids.subcommand(description="Sets voting channel. Channel used as parent for voting threads.")
-    async def voting(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel = nextcord.SlashOption(
-            required=False, description="Channel to set to. If left blank, uses current channel."
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings channel_ids.voting value to given channel id or current channel id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            channel (nextcord.TextChannel, optional): Channel to set in settings.
-        """
-        channel_id = interaction.channel_id if channel is None else channel.id
-        settings.channel_ids.voting = channel_id
-        settings.save()
-        await interaction.response.send_message(f"Voting channel set to <#{channel_id}>.", ephemeral=True)
-
-    @settings.subcommand()
-    async def point_settings(self, interaction: nextcord.Interaction) -> None:
-        """Subcommand parent. Never called."""
-
-    @point_settings.subcommand(description="Sets Points value.")
-    async def clan_points(
-        self,
-        interaction: nextcord.Interaction,
-        points: int = nextcord.SlashOption(
-            required=True, description="Number of Clan Points the recipient earns.", min_value=0
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings point_settings.clan_points to the given number of points.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            points (int): Number of points to assign to PointSettings.points.
-        """
-        settings.point_settings.clan_points = points
-        settings.save()
-        await interaction.response.send_message(f"Points set to {points}.", ephemeral=True)
-
-    @point_settings.subcommand(description="Sets Event Weekly Limit value for Clan Points.")
-    async def clan_points_weekly_limit(
-        self,
-        interaction: nextcord.Interaction,
-        points: int = nextcord.SlashOption(
-            required=True, description="Number of Clan Points a clan member can earn in a week.", min_value=0
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings point_settings.clan_points_weekly_limit to the given number of points.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            points (int): Number of points to set.
-        """
-        settings.point_settings.clan_points_weekly_limit = points
-        settings.save()
-        await interaction.response.send_message(f"Clan Points Weekly Limit set to {points}.", ephemeral=True)
-
-    @point_settings.subcommand(description="Sets Event Weekly Limit value.")
-    async def events_weekly_limit(
-        self,
-        interaction: nextcord.Interaction,
-        points: int = nextcord.SlashOption(
-            required=True, description="Number of Event Points a clan member can earn in a week.", min_value=0
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings point_settings.events_weekly_limit to the given number of points.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            points (int): Number of points to set.
-        """
-        settings.point_settings.events_weekly_limit = points
-        settings.save()
-        await interaction.response.send_message(f"Event Weekly Limit set to {points}.", ephemeral=True)
-
-    @point_settings.subcommand(description="Sets Event Host Points value.")
-    async def host_points(
-        self,
-        interaction: nextcord.Interaction,
-        points: int = nextcord.SlashOption(
-            required=True, description="Number of Event Points a host earns when hosting event.", min_value=0
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings point_settings.host_points to the given number of points.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            points (int): Number of points to set.
-        """
-        settings.point_settings.host_points = points
-        settings.save()
-        await interaction.response.send_message(f"Event Host Points set to {points}.", ephemeral=True)
-
-    @point_settings.subcommand(description="Sets Event Participation Points value.")
-    async def participate_points(
-        self,
-        interaction: nextcord.Interaction,
-        points: int = nextcord.SlashOption(
-            required=True,
-            description="Number of Event Points a participant earns when attending an event.",
-            min_value=0,
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings point_settings.participate_points to the given number of points.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            points (int): Number of points to set.
-        """
-        settings.point_settings.participate_points = points
-        settings.save()
-        await interaction.response.send_message(f"Event Participation Points set to {points}.", ephemeral=True)
-
-    @point_settings.subcommand(description="Sets whether to verify a clan point entry.")
-    async def verify_clan_points(
-        self,
-        interaction: nextcord.Interaction,
-        do_verification: bool = nextcord.SlashOption(  # noqa: FBT001
-            required=True,
-            description="Whether an event should be verified or not.",
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings point_settings.verify_clan_points to the given number of points.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            do_verification (bool): If the bot should verify events.
-        """
-        settings.point_settings.verify_clan_points = do_verification
-        settings.save()
-        await interaction.response.send_message(f"Event verification set to {do_verification}.", ephemeral=True)
-
-    @point_settings.subcommand(description="Sets whether an event.")
-    async def verify_events(
-        self,
-        interaction: nextcord.Interaction,
-        do_verification: bool = nextcord.SlashOption(  # noqa: FBT001
-            required=True,
-            description="Whether an event should be verified or not.",
-        ),
-    ) -> None:
-        """
-        Sets DakinySettings point_settings.verify_events to the given number of points.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            do_verification (bool): If the bot should verify events.
-        """
-        settings.point_settings.verify_events = do_verification
-        settings.save()
-        await interaction.response.send_message(f"Event verification set to {do_verification}.", ephemeral=True)
-
-    @settings.subcommand()
-    async def role_ids(self, interaction: nextcord.Interaction) -> None:
-        """Subcommand parent. Never called."""
-
-    @role_ids.subcommand(description="Sets Clan Council role id.")
-    async def clan_council(
-        self,
-        interaction: nextcord.Interaction,
-        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
-    ) -> None:
-        """
-        Sets DakinySettings role_ids.clan_council to the given role id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            role (nextcord.TextChannel): Role to set in settings.
-        """
-        role_id = role.id
-        settings.role_ids.clan_council = role_id
-        settings.save()
-        await interaction.response.send_message(f"Clan Council role set to <@&{role_id}>.", ephemeral=True)
-
-    @role_ids.subcommand(description="Sets Clan Council Elect role id.")
-    async def clan_council_elect(
-        self,
-        interaction: nextcord.Interaction,
-        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
-    ) -> None:
-        """
-        Sets DakinySettings role_ids.clan_council_elect to the given role id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            role (nextcord.TextChannel): Role to set in settings.
-        """
-        role_id = role.id
-        settings.role_ids.clan_council_elect = role_id
-        settings.save()
-        await interaction.response.send_message(f"Clan Council Elect role set to <@&{role_id}>.", ephemeral=True)
-
-    @role_ids.subcommand(description="Sets Clan Member role id.")
-    async def clan_member(
-        self,
-        interaction: nextcord.Interaction,
-        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
-    ) -> None:
-        """
-        Sets DakinySettings role_ids.clan_member to the given role id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            role (nextcord.TextChannel): Role to set in settings.
-        """
-        role_id = role.id
-        settings.role_ids.clan_member = role_id
-        settings.save()
-        await interaction.response.send_message(f"Clan Member role set to <@&{role_id}>.", ephemeral=True)
-
-    @role_ids.subcommand(description="Sets Event Host role id.")
-    async def event_host(
-        self,
-        interaction: nextcord.Interaction,
-        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
-    ) -> None:
-        """
-        Sets DakinySettings role_ids.event_host to the given role id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            role (nextcord.TextChannel): Role to set in settings.
-        """
-        role_id = role.id
-        settings.role_ids.event_host = role_id
-        settings.save()
-        await interaction.response.send_message(f"Event Host role set to <@&{role_id}>.", ephemeral=True)
-
-    @role_ids.subcommand(description="Sets High Council role id.")
-    async def high_council(
-        self,
-        interaction: nextcord.Interaction,
-        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
-    ) -> None:
-        """
-        Sets DakinySettings role_ids.high_council to the given role id.
-
-        Args:
-            interaction (nextcord.Interaction): Discord interaction of command.
-            role (nextcord.TextChannel): Role to set in settings.
-        """
-        role_id = role.id
-        settings.role_ids.high_council = role_id
-        settings.save()
-        await interaction.response.send_message(f"High Council role set to <@&{role_id}>.", ephemeral=True)

cogs/commands/test.py

@@ -1,155 +1,141 @@
-"""Commands for testing."""
+"""
+Commands for testing.
+"""
 
 import nextcord
 from nextcord.ext import application_checks, commands
 
-from classes.election import Election
-from DakinySettings import settings
-from utils import GUILDS, get_active_election_cycle, get_quarter_name
-
-ME = 206602713511886849
+from classes.election_cycle import ElectionCycle
+from config import DakinyConfig
+from utils import get_current_cycle
 
 
-def is_me():  # noqa: ANN201
-    """Predicate that makes sure only I can run the test commands."""
+def is_me():
+    """
+    predicate that makes sure only I can run the test commands.
+    """
 
-    def predicate(interaction: nextcord.Interaction) -> bool:
-        return interaction.user.id == ME
+    def predicate(interaction: nextcord.Interaction):
+        return interaction.user.id == 206602713511886849
 
     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: commands.Bot) -> None:
-        """Default constructor for HelpCog class. Does nothing."""
-        self.bot: commands.Bot = bot
+    def __init__(self, bot) -> None:
+        """
+        Default constructor for HelpCog class. Does nothing.
+        """
+        self.bot = bot
 
-    @nextcord.slash_command(guild_ids=GUILDS)
-    async def test(self, interaction: nextcord.Interaction) -> None:
-        """Parent slash command for help. Never called."""
+    @nextcord.slash_command(guild_ids=[1000247361639030804])
+    async def test(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for help. Never called.
+        """
 
     @test.subcommand()
     @is_me()
-    async def election_start(self, interaction: nextcord.Interaction) -> None:
+    async def election_start(self, interaction: nextcord.Interaction):
         """
-        Force starts election.
+        idc
 
         Args:
-            interaction (nextcord.Interaction): Interaction with the message.
+            interaction (nextcord.Interaction): _description_
         """
-        cycle = Election(
-            get_active_election_cycle(),
-            self.bot.get_guild(settings.params.guild_id),
+
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            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) -> None:
+    async def voting_start(self, interaction: nextcord.Interaction):
         """
-        Force starts voting.
+        tests the voting start action
 
         Args:
-            interaction (nextcord.Interaction): Interaction with the message.
+            interaction (nextcord.Interaction): _description_
         """
-        cycle = Election(
-            get_active_election_cycle(),
-            self.bot.get_guild(settings.params.guild_id),
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            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) -> None:
+    async def voting_end(self, interaction: nextcord.Interaction):
         """
-        Force ends voting.
+        tests the voting start action
 
         Args:
-            interaction (nextcord.Interaction): Interaction with the message.
+            interaction (nextcord.Interaction): _description_
         """
-        cycle = Election(
-            get_active_election_cycle(),
-            self.bot.get_guild(settings.params.guild_id),
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            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) -> None:
+    async def highcouncil_vote(self, interaction: nextcord.Interaction):
         """
-        Force starts highcouncil voting.
+        tests the voting start action
 
         Args:
-            interaction (nextcord.Interaction): Interaction with the message.
+            interaction (nextcord.Interaction): _description_
         """
-        cycle = Election(
-            get_active_election_cycle(),
-            self.bot.get_guild(settings.params.guild_id),
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            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) -> None:
-        """
-        Forces election reminder.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with the message.
-        """
-        cycle = Election(
-            get_active_election_cycle(),
-            self.bot.get_guild(settings.params.guild_id),
+    async def election_reminder(self, interaction: nextcord.Interaction):
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            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) -> None:
-        """
-        Forces daily function.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with the message.
-        """
-        cycle = Election(
-            get_active_election_cycle(),
-            self.bot.get_guild(settings.params.guild_id),
+    async def daily(self, interaction: nextcord.Interaction):
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            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) -> None:
-        """
-        Forces term start.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with the message.
-        """
-        cycle = Election(
-            get_active_election_cycle(),
-            self.bot.get_guild(settings.params.guild_id),
+    async def term_start(self, interaction: nextcord.Interaction):
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
         )
         await cycle.term_start_action()
-        await interaction.send("Test command sent.", ephemeral=True)
-
-    @test.subcommand()
-    @is_me()
-    async def get_quarter_name(self, interaction: nextcord.Interaction) -> None:
-        """
-        Tests getting the quarter name.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with the message.
-        """
-        name = get_quarter_name()
-        await interaction.send(name)

cogs/commands/time.py

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

cogs/commands/view.py

@@ -1,121 +1,35 @@
-"""Commands for viewing information in the database."""
+"""
+Commands for viewing information in the database.
+"""
 
 import nextcord
-import pandas as pd
 from nextcord.ext import commands
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from database_setup.sql_data_classes import (
-    Points,
+    ElectionInformation,
     Presences,
     Votes,
     engine,
 )
-from utils import GUILDS, MAX_DISCORD_MESSAGE_LENGTH, PointType, 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."""
-
-    @nextcord.slash_command(guild_ids=GUILDS)
-    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(
-        self,
-        interaction: nextcord.Interaction,
-        quarter_name: str = nextcord.SlashOption(
-            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.
+        Default constructor for ViewCog class. Does nothing.
         """
-        # just in case
-        await interaction.response.defer(ephemeral=True)
 
-        with Session(engine) as session:
-            if quarter_name:
-                ppdf = pd.read_sql_query(
-                    sql=session.query(Points).where(Points.QuarterName.startswith(quarter_name)).statement,
-                    con=engine,
-                )
-            else:
-                ppdf = pd.read_sql_query(
-                    sql=session.query(Points).statement,
-                    con=engine,
-                )
-
-            if ppdf.empty:
-                await interaction.followup.send(f'Quarter "{quarter_name}" is invalid.', ephemeral=True)
-                return
-
-            quarters = ppdf.groupby("QuarterName")
-            content = create_points_string(interaction, quarters, PointType.EVENT)
-
-            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)
-
-    @view.subcommand(description="Show event points.")
-    async def clan_points(
-        self,
-        interaction: nextcord.Interaction,
-        quarter_name: str = nextcord.SlashOption(
-            description="The quarter to view",
-            required=False,
-        ),
-    ) -> None:
+    @nextcord.slash_command()
+    async def view(self, interaction: nextcord.Interaction):
         """
-        View the clan points.
-
-        Builds a message with the clan 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.
+        Parent slash command for set. Never called.
         """
-        # just in case
-        await interaction.response.defer(ephemeral=True)
-
-        with Session(engine) as session:
-            if quarter_name:
-                ppdf = pd.read_sql_query(
-                    sql=session.query(Points).where(Points.QuarterName.startswith(quarter_name)).statement,
-                    con=engine,
-                )
-            else:
-                ppdf = pd.read_sql_query(
-                    sql=session.query(Points).statement,
-                    con=engine,
-                )
-
-            if ppdf.empty:
-                await interaction.followup.send(f'Quarter "{quarter_name}" is invalid.', ephemeral=True)
-                return
-
-            quarters = ppdf.groupby("QuarterName")
-            content = create_points_string(interaction, quarters, PointType.CLAN)
-
-            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)
 
     @view.subcommand(description="Show all possible presence choices.")
     async def presences(
@@ -125,14 +39,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)
 
@@ -141,28 +55,29 @@ 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.
@@ -170,14 +85,16 @@ 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.ElectionName == election_name).where(Votes.Type == election_type)
+
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name)
 
         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)
@@ -192,7 +109,9 @@ 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) -> None:
+    async def election_autocomplete(
+        self, interaction: nextcord.Interaction, election_name: str
+    ):
         """
         Collects all elections that start with the election string.
 
@@ -200,8 +119,9 @@ 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.ElectionName).distinct()
+            stmt = select(ElectionInformation.ElectionCycle)
             elections = session.scalars(stmt)
 
             # if empty compare string
@@ -209,89 +129,9 @@ 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")
-    @clan_points.on_autocomplete("quarter_name")
-    async def event_points_autocomplete(self, interaction: nextcord.Interaction, quarter_name: str) -> None:
-        """
-        Collects all elections that start with the election string.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with command.
-            quarter_name (str): String to run autocomplete on.
-        """
-        with Session(engine) as session:
-            stmt = select(Points.QuarterName).distinct()
-            quarters = session.scalars(stmt)
-
-            # if empty compare string
-            if not quarter_name:
-                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())
-            ]
-            await interaction.response.send_autocomplete(autofilled_quarters[:25])
-
-
-def create_points_string(interaction: nextcord.Interaction, quarters: any, point_type: PointType) -> str:
-    """
-    Creates the string to show how many clan/event points users have.
-
-    Args:
-        interaction (nextcord.Interaction): Discord interaction of the command.
-        quarters (any): Pandas objects grouped by quarters.
-        point_type (PointType): The type of points to create the message for.
-
-    Returns:
-        str: The string with the message content.
-    """
-    content: str = ""
-    for quarter in quarters.groups:
-        content += f"**{quarter}**\n"
-        unsorted_all = quarters.get_group(quarter).groupby("DiscordMember")
-        members = unsorted_all.get_group(name=True)
-
-        # there can be no non-discord members sometimes.
-        try:
-            sorted_non_members = unsorted_all.get_group(name=False).sort_values(by="UserId")
-        except KeyError:
-            sorted_non_members = None
-        sorted_members = members.sort_values(
-            by="UserId",
-            key=lambda user_ids: ([member_lambda_string(interaction.guild, user_id) for user_id in user_ids]),
-        )
-        sorted_all = pd.concat([sorted_members, sorted_non_members], ignore_index=True, sort=False)
-        for row in sorted_all.itertuples():
-            points = row.EventPoints if point_type == PointType.EVENT else row.ClanPoints
-            discord_member = row.DiscordMember
-            if points > 0:
-                content += f"<@{row.UserId}>: {points}\n" if discord_member else f"{row.UserId}: {points}\n"
-        content += "\n"
-    return content
-
-
-def member_lambda_string(guild: nextcord.Guild, user_id: int) -> str:
-    """
-    Finds a user in a guild and returns the display name.
-
-    Returns the user id in string form if user is no longer in guild.
-    I don't know if I like this name very much.
-
-    Args:
-        guild (nextcord.Guild): Guild object to find the user in.
-        user_id (int): User id to get display name of.
-
-    Returns:
-        str: String to use for sorting.
-    """
-    try:
-        return guild.get_member(int(user_id)).display_name.lower()
-    except AttributeError:
-        # The user is no longer a part of the guild
-        return str(user_id)

cogs/loops/__init__.py

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

cogs/loops/bot_presence.py

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

cogs/loops/daily_loop.py

@@ -1,28 +1,27 @@
-"""Defines the daily loop that runs the Dakiny bot functions."""
+"""
+Defines the daily loop that runs the Dakiny bot functions.
+"""
 
 import random
-from datetime import UTC, datetime, time
-from typing import TYPE_CHECKING
+from datetime import datetime, time
 
+import nextcord
 from nextcord.ext import commands, tasks
 from pytz import timezone
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
-from classes.election import Election
-from DakinySettings import settings
+from classes.election_cycle import ElectionCycle
+from config import DakinyConfig
+from dakiny_bot import birthday_list
 from database_setup.sql_data_classes import UserBirthday, engine
-from main import birthday_list
-from utils import get_active_election_cycle
-
-if TYPE_CHECKING:
-    import nextcord
-
-KANDY = 239547993106284544
+from utils import get_current_cycle
 
 
 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
@@ -32,17 +31,16 @@ 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("UTC")))
-    async def daily_loop(self) -> None:
+    @tasks.loop(time=time(hour=0, tzinfo=timezone("GMT")))
+    async def daily_loop(self):
         """
-        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()
+            self.current_election = self.get_election_cycle()
 
         if self.current_election is not None:
             await self.current_election.check_date()
@@ -51,49 +49,49 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
 
         self.update_birthdays()
 
-        if KANDY in birthday_list:
+        if 239547993106284544 in birthday_list:
             # inform kandy that it is her "birthday"
-            kandy: nextcord.User = await self.bot.fetch_user(KANDY)
+            kandy: nextcord.User = await self.bot.fetch_user(239547993106284544)
             await kandy.send('Happy "Birthday"!')
 
         await self.cakedays()
 
     @daily_loop.before_loop
-    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."""
+    async def before_loop(self):
+        """
+        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.
-        self.current_election = self.get_election()
+        self.current_election = self.get_election_cycle()
 
-    def get_election(self) -> Election:
+    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:
-            Election: Current election cycle, None if there is no election happening.
+            ElectionCycle: Current election cycle, None if there is no election happening.
         """
-        cycle = get_active_election_cycle()
 
-        # prevent exception from using cycle as an Int in an array
-        if cycle is None:
-            return None
+        config: DakinyConfig = self.bot.config
+        cycle = get_current_cycle(config)
 
-        election = Election(cycle, self.bot.get_guild(settings.params.guild_id))
-
-        return election if election.active else None
+        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:  # noqa: S311 isn't cryptography related.
-            birthday_list.append(KANDY)
+        if random.randint(0, 99) == 0:
+            birthday_list.append(239547993106284544)
 
-        today = datetime.now(tz=UTC).date()
+        today = datetime.today()
         birthday = f"{today.month}/{today.day}"
 
         stmt = select(UserBirthday.UserId).where(UserBirthday.Birthday == birthday)
@@ -103,13 +101,13 @@ 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. Sends a message
+        saying happy cakeday.
         """
-        today = datetime.now(tz=UTC).date()
-        guild: nextcord.Guild = self.bot.get_guild(settings.params.guild_id)
-        announce_channel: nextcord.TextChannel = guild.get_channel(settings.channel_ids.general)
+
+        today = datetime.today()
+        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)
 
         cakedays: list[nextcord.Member] = [
             human for human in guild.humans if human.joined_at.month == today.month and human.joined_at.day == today.day

cogs/message_listener/__init__.py

@@ -1,9 +1,11 @@
-"""Defines cog for on message listener."""
+"""
+Defines cog for on message listener.
+"""
 
 import nextcord
 from nextcord.ext import commands
 
-from main import birthday_list
+from dakiny_bot import birthday_list
 
 
 class SubmissionListener(commands.Cog, name="Message Listener"):
@@ -13,7 +15,7 @@ class SubmissionListener(commands.Cog, name="Message Listener"):
         self.bot = bot
 
     @commands.Cog.listener()
-    async def on_message(self, message: nextcord.Message) -> None:
+    async def on_message(self, message: nextcord.Message):
         """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:
@@ -24,8 +26,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) -> None:
-    """Adds function to bot."""
+def setup(bot: commands.Bot):
+    """Adds function to bot"""
     bot.add_cog(SubmissionListener(bot))
 
 
@@ -36,5 +38,6 @@ 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)):
         await message.add_reaction("🎂")

config.py

@@ -0,0 +1,50 @@
+"""
+File contains classes defining the Hydra configuraton structure.
+"""
+from dataclasses import dataclass
+
+
+@dataclass
+class Params:
+    """
+    Class defines the various configuration parameters.
+    """
+
+    admin_channel_id: int  # might want to rename this...
+    announcement_category_id: int
+    clan_council_elect_role_id: int
+    clan_council_role_id: int
+    clan_info_channel_id: int
+    clan_member_role_id: int
+    discord_token: str
+    general_channel_id: int
+    guild_id: int
+    high_council_role_id: int
+    voting_parent_id: int
+
+
+@dataclass
+class ElectionCycle:
+    """
+    Class defines relevant election dates.
+    """
+
+    election_start: str
+    highcouncil_election_announce: str
+    highcouncil_election_end: str
+    highcouncil_election_start: str
+    name: str
+    term_end: str
+    term_start: str
+    voting_end: str
+    voting_start: str
+
+
+@dataclass
+class DakinyConfig:
+    """
+    Class defines all configs required for Dakiny Bot.
+    """
+
+    election_cycles: list[ElectionCycle]
+    params: Params

dakiny_bot.py

@@ -0,0 +1,72 @@
+import logging
+import os
+import sys
+
+import hydra
+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
+
+cs = ConfigStore.instance()
+cs.store(name="dakiny_config", node=DakinyConfig)
+
+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")
+)
+logger.addHandler(handler)
+
+
+@hydra.main(config_path="conf", config_name="config")
+def main(cfg: DakinyConfig):
+    # 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()
+
+    # 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
+
+    bot = commands.Bot(intents=intents)
+    bot.config = cfg
+
+    # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
+    for folder in os.listdir("cogs"):
+        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
+        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!")
+
+    # Run Discord bot
+    bot.run(bot.config.params.discord_token)
+
+
+if __name__ == "__main__":
+    sys.argv.append("hydra.job.chdir=False")
+    sys.argv.append("hydra/job_logging=none")
+    sys.argv.append("hydra/hydra_logging=none")
+    main()  # pylint: disable=no-value-for-parameter

database_setup/create_database.py

@@ -1,13 +1,15 @@
-"""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 pathlib import Path
+from os.path import exists
 
-if not Path("database/dakiny.db").exists():
+if not exists("database/dakiny.db"):
     with sqlite3.connect("database/dakiny.db") as con:
         cur = con.cursor()
 
-        with Path("database_setup/database.sql", encoding="utf-8").open() as file:
+        with open("database_setup/database.sql", mode="r", encoding="utf-8") as file:
             database_script = file.read()
             cur.executescript(database_script)
             con.commit()

database_setup/database.sql

@@ -1,15 +1,15 @@
 CREATE TABLE ElectionInformation(
-    ElectionName varchar(30) not null unique,
+    ElectionCycle varchar(30) not null unique,
     ThreadId bigint unsigned not null,
     CouncilVoteMsgId bigint unsigned,
     HighCouncilVoteMsgId bigint unsigned,
     CouncilNominationMsgId bigint unsigned,
     HighCouncilNominationMsgId bigint unsigned,
-    PRIMARY KEY (ElectionName)
+    PRIMARY KEY (ElectionCycle)
 );
 
 CREATE TABLE CouncilMembers(
-    ElectionName varchar(30) not null,
+    ElectionCycle varchar(30) not null,
     MemberId bigint unsigned not null,
     SpeechMsgId bigint unsigned not null,
     Elected boolean DEFAULT false,
@@ -17,17 +17,16 @@ CREATE TABLE CouncilMembers(
     ClanLeader boolean DEFAULT false,
     DiscordManagerSpeechId bigint unsigned,
     ClanLeaderSpeechId bigint unsigned,
-    FOREIGN KEY (ElectionName) REFERENCES ElectionInformation(ElectionName),
-    PRIMARY KEY (ElectionName, MemberId)
+    FOREIGN KEY (ElectionCycle) REFERENCES ElectionInformation(ElectionCycle),
+    PRIMARY KEY (ElectionCycle, MemberId)
 );
 
 CREATE TABLE Votes(
-    ElectionName varchar(30) not null,
+    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 (ElectionName) REFERENCES ElectionInformation(ElectionName),
-    PRIMARY KEY (ElectionName, VoterId, Type)
+    FOREIGN KEY (ElectionCycle) REFERENCES ElectionInformation(ElectionCycle),
+    PRIMARY KEY (ElectionCycle, VoterId)
 );
 
 CREATE TABLE UserBirthday (
@@ -40,25 +39,3 @@ CREATE TABLE Presences (
     Id integer PRIMARY KEY,
     Presence varchar(100) not null
 );
-
-CREATE TABLE Points (
-    QuarterName varchar(30) not null,
-    UserId varchar(32) not null,
-    DiscordMember boolean not null,
-    EventPoints int unsigned DEFAULT 0,
-    ClanPoints int unsigned DEFAULT 0,
-    PRIMARY KEY (QuarterName, UserId)
-);
-
-CREATE TABLE Messages (
-    Path varchar(100) PRIMARY KEY,
-    Id bigint unsigned not null
-);
-
-CREATE TABLE PointsLimit (
-    UserId varchar(32) not null,
-    EventPoints int unsigned DEFAULT 0,
-    ClanPoints int unsigned DEFAULT 0,
-    Week varchar(7) not null,
-    PRIMARY KEY (UserId, Week)
-);

database_setup/pyproject.toml

@@ -1,7 +0,0 @@
-[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,5 +1,6 @@
-"""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
 
@@ -10,11 +11,8 @@ Base = automap_base()
 Base.prepare(autoload_with=engine)
 
 # define the classes
-Points = Base.classes.Points
-PointsLimit = Base.classes.PointsLimit
-CouncilMembers = Base.classes.CouncilMembers
 ElectionInformation = Base.classes.ElectionInformation
-Messages = Base.classes.Messages
-Presences = Base.classes.Presences
-UserBirthday = Base.classes.UserBirthday
+CouncilMembers = Base.classes.CouncilMembers
 Votes = Base.classes.Votes
+UserBirthday = Base.classes.UserBirthday
+Presences = Base.classes.Presences

main.py

@@ -1,59 +0,0 @@
-"""Main file for bot."""
-
-import logging
-import os
-
-import nextcord
-from nextcord.ext import commands
-
-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 DakinySettings import settings
-from database_setup import create_database
-
-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"))
-logger.addHandler(handler)
-
-
-def main() -> None:
-    """Builds and runs bot."""
-    # Allows privileged 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()
-
-    # Required in order to read messages (eg. prefix commands)
-    intents.message_content = True
-
-    # To enable the members privileged intent:
-    intents.members = True
-
-    bot = commands.Bot(intents=intents)
-
-    # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
-    for folder in os.listdir("cogs"):
-        bot.load_extension(f"cogs.{folder}")
-
-    @bot.listen()
-    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(bot.get_guild(settings.params.guild_id)))
-        bot.add_view(NominateHighCouncilView(bot.get_guild(settings.params.guild_id)))
-        bot.add_view(VoteView(bot.get_guild(settings.params.guild_id)))
-        bot.add_view(VoteHighcouncilView(bot.get_guild(settings.params.guild_id)))
-        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(settings.params.discord_token)
-
-
-if __name__ == "__main__":
-    main()

pyproject.toml

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

requirements.txt

@@ -0,0 +1,5 @@
+nextcord==2.4.2
+python-dotenv==1.0.0
+pytz==2022.7.1
+hydra-core==1.3.2
+sqlalchemy<2.0

runtime.txt

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

utils.py

@@ -1,36 +1,16 @@
-"""File contains util functions."""
+"""
+File contains util functions.
+"""
 
-import calendar
-import os
-from collections.abc import Sequence
-from datetime import UTC, datetime
-from enum import StrEnum
-from pathlib import Path
+from datetime import datetime
 
-import aiofiles
-import nextcord
-from sqlalchemy import select, true, update
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
-from DakinySettings import settings
-from database_setup.sql_data_classes import (
-    CouncilMembers,
-    Messages,
-    Points,
-    PointsLimit,
-    Votes,
-    engine,
-)
+from config import DakinyConfig
+from database_setup.sql_data_classes import CouncilMembers, Votes, engine
 
 NOMINEE_SPLITTER = "========================================\n\n"
-REPO_DIR = "./dakiny-messages"
-MESSAGES_DIR = f"{REPO_DIR}/messages"
-TEMPLATES_DIR = f"{REPO_DIR}/message_templates"
-MAX_DISCORD_MESSAGE_LENGTH = 2000
-GUILDS = [1000247361639030804, 239758371358638080]
-
-VoteType = StrEnum("VoteType", ["COUNCIL", "DISCORDMANAGER", "CLANLEADER"])
-PointType = StrEnum("PointType", ["CLAN", "EVENT"])
 
 
 def get_datetime(day: str) -> datetime:
@@ -43,110 +23,108 @@ def get_datetime(day: str) -> datetime:
     Returns:
         datetime: Datetime representation of Month/Day.
     """
-    today = datetime.now(tz=UTC).date()
-    year = today.year
+    year = datetime.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 today.month == calendar.DECEMBER and month < calendar.OCTOBER:
+    if datetime.today().month == 12 and month < 12:
         year += 1
 
-    if today.month == calendar.JANUARY and month > calendar.MARCH:
-        year -= 1
-
-    return datetime(year, month, day, tzinfo=UTC)
+    return datetime(year, month, day)
 
 
-def get_election_name() -> str:
+def get_election_cycle_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.
 
     Returns:
         str: the name of the election cycle
     """
-    cycle = get_active_election_cycle()
-    current_cycle = settings.election_cycles[cycle]
+    cycle = get_current_cycle(config)
+    current_cycle = config.election_cycles[cycle]
+
     return f"vote-{get_datetime(current_cycle.term_start).year}-{current_cycle.name}"
 
 
-def get_quarter_name() -> str:
+def get_dm_election_name(config: DakinyConfig) -> str:
     """
-    Builds the name of the current cycle/quarter.
+    creates the name of the discord manager election
+
+    Args:
+        config (DakinyConfig): Config sent to get_election_cycle_name
 
     Returns:
-        str: the name of the cycle.
+        str: the name of the election
     """
-    cycle = get_quarter_cycle()
-    current_cycle = settings.election_cycles[cycle]
 
-    return f"{get_datetime(current_cycle.term_start).year}-{current_cycle.name}"
+    return f"{get_election_cycle_name(config)}-dm"
 
 
-def get_active_election_cycle() -> int:
+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_cycle(config: DakinyConfig) -> int:
     """
     Returns index for active election. An election is considered active between the election start and the term start.
 
-    Returns:
-        int: cycle index for active election. None for no active cycle
-    """
-    today = datetime.now(tz=UTC)
+    Args:
+        config (DakinyConfig): Config object to use
 
-    for cycle, election in enumerate(settings.election_cycles):
+    Returns:
+        int: cycle index for active election. -1 for no active cycle
+    """
+
+    today = datetime.today()
+
+    for cycle, election in enumerate(config.election_cycles):
         if (
             today.date() >= get_datetime(election.election_start).date()
             and today.date() <= get_datetime(election.term_start).date()
         ):
             return cycle
 
-    # It isn't a current election, get the quarter
-    return get_quarter_cycle()
+    return -1
 
 
-def get_quarter_cycle() -> int:
-    """
-    Returns the index for the current cycle/quarter. Defined as between term start and end.
-
-    Can return None if entire year isn't covered by cycles.
-
-    Returns:
-        int: cycle index for current cycle.
-    """
-    today = datetime.now(tz=UTC)
-    for cycle, election in enumerate(settings.election_cycles):
-        if (
-            today.date() >= get_datetime(election.term_start).date()
-            and today.date() <= get_datetime(election.term_end).date()
-        ):
-            return cycle
-
-    return None
-
-
-def build_votes_str(guild: nextcord.Guild) -> str:
+def build_votes_str(config: DakinyConfig) -> str:
     """
     Creates a string that contains all nominees and their votes to be sent as a discord message.
 
     Args:
-        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
+        config (DakinyConfig): Daking config object
 
     Returns:
         str: String that contains all nominees and their votes.
     """
+
     votes: dict[int, int] = {}
 
-    election_name = get_election_name()
-
     with Session(engine) as session:
-        stmt = select(CouncilMembers).where(CouncilMembers.ElectionName == election_name)
+        stmt = select(CouncilMembers).where(
+            CouncilMembers.ElectionCycle == get_election_cycle_name(config)
+        )
 
-        for nominee in sorted(
-            session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
-        ):
+        for nominee in session.scalars(stmt):
             votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(Votes.ElectionName == election_name).where(Votes.Type == VoteType.COUNCIL)
+        stmt = select(Votes).where(
+            Votes.ElectionCycle == get_election_cycle_name(config)
+        )
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -158,35 +136,31 @@ def build_votes_str(guild: nextcord.Guild) -> str:
     return votes_str
 
 
-def build_highcouncil_votes_str(guild: nextcord.Guild) -> str:
+def build_highcouncil_votes_str(config: DakinyConfig) -> str:
     """
     Creates a string that contains all high council nominees and their votes to be sent as a discord message.
 
     Args:
-        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
+        config (DakinyConfig): Daking config object
 
     Returns:
         str: String that contains all nominees and their votes.
     """
+
     cl_votes: dict[int, int] = {}
     dm_votes: dict[int, int] = {}
 
-    election_name = get_election_name()
-
     with Session(engine) as session:
         stmt = (
             select(CouncilMembers)
-            .where(CouncilMembers.ElectionName == election_name)
+            .where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
             .filter(CouncilMembers.ClanLeaderSpeechId.is_not(None))
         )
 
-        for nominee in sorted(
-            session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
-        ):
+        for nominee in session.scalars(stmt):
             cl_votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(Votes.ElectionName == election_name).where(Votes.Type == VoteType.CLANLEADER)
+        stmt = select(Votes).where(Votes.ElectionCycle == get_cl_election_name(config))
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -194,17 +168,14 @@ def build_highcouncil_votes_str(guild: nextcord.Guild) -> str:
 
         stmt = (
             select(CouncilMembers)
-            .where(CouncilMembers.ElectionName == election_name)
+            .where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
             .filter(CouncilMembers.DiscordManagerSpeechId.is_not(None))
         )
 
-        for nominee in sorted(
-            session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
-        ):
+        for nominee in session.scalars(stmt):
             dm_votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(Votes.ElectionName == election_name).where(Votes.Type == VoteType.DISCORDMANAGER)
+        stmt = select(Votes).where(Votes.ElectionCycle == get_dm_election_name(config))
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
@@ -289,269 +260,3 @@ def decorate_dm_nomination(user_id: int, speech: str) -> str:
     msg += speech
 
     return msg
-
-
-def record_points(users: Sequence[str], add_points: int, point_type: PointType, *, is_member: bool) -> None:
-    """
-    Adds 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 in events or for the clan
-    points.
-
-    Args:
-        users (Sequence[int]): users that participated and need points.
-        add_points (int): number of points to add
-        point_type (PointType): which point type to add to
-        is_member (bool): whether the users are a discord member or not
-    """
-    quarter_name = get_quarter_name()
-    with Session(engine) as session:
-        for user in users:
-            stmt = select(Points).where(Points.UserId == user).where(Points.QuarterName == quarter_name)
-
-            points_obj = session.scalar(stmt)
-            add_points = get_allowed_points(session, point_type, user, add_points)
-            add_clan_points = add_points if point_type == PointType.CLAN else 0
-            add_event_points = add_points if point_type == PointType.EVENT else 0
-            if points_obj is None:
-                new_points = Points(
-                    QuarterName=quarter_name,
-                    UserId=user,
-                    DiscordMember=is_member,
-                    EventPoints=add_event_points,
-                    ClanPoints=add_clan_points,
-                )
-                session.add(new_points)
-            else:
-                points_obj.EventPoints += add_event_points
-                points_obj.ClanPoints += add_clan_points
-
-        session.commit()
-
-
-def get_allowed_points(session: Session, point_type: PointType, user: str, points: int) -> int:
-    """
-    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:
-        session (Session): Open connection to database.
-        point_type (PointType): Which type of points to check the limit for.
-        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.
-    """
-    # check for limit
-    today = datetime.now(tz=UTC).date()
-    this_week = f"{today.isocalendar().year}-{today.isocalendar().week}"
-    points_limit = (
-        settings.point_settings.events_weekly_limit
-        if point_type == PointType.EVENT
-        else settings.point_settings.clan_points_weekly_limit
-    )
-    stmt = select(PointsLimit).where(PointsLimit.UserId == user).where(PointsLimit.Week == this_week)
-
-    # if under limit, can add up to however many points would make the current limit equal to the
-    # allowed limit.
-    limit_obj = session.scalar(stmt)
-    if limit_obj is None:
-        clan_points = points if point_type == PointType.CLAN else 0
-        event_points = points if point_type == PointType.EVENT else 0
-        new_limit = PointsLimit(UserId=user, Week=this_week, EventPoints=event_points, ClanPoints=clan_points)
-        add_points = points
-        session.add(new_limit)
-    else:
-        curr_points = limit_obj.EventPoints if point_type == PointType.EVENT else limit_obj.ClanPoints
-        add_points = points if curr_points + points <= points_limit else (max(0, points_limit - curr_points))
-        if point_type == PointType.EVENT:
-            limit_obj.EventPoints += add_points
-        else:
-            limit_obj.ClanPoints += add_points
-
-    session.commit()
-
-    return add_points
-
-
-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 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 channel_updates if Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()]
-
-    with Session(engine) as session:
-        for dir_name in dirs:
-            dir_path = f"{MESSAGES_DIR}/{dir_name}"
-            channel = await get_clan_message_channel(session, dir_name, guild)
-            sorted_files = sorted(
-                os.listdir(dir_path),
-                key=lambda filename: int(filename.split(".")[0]),
-            )
-
-            for file_name in sorted_files:
-                message_name = f"{dir_name}/{file_name}"
-                file_path = f"{dir_path}/{file_name}"
-                async with aiofiles.open(file_path, encoding="utf8") as reader:
-                    await edit_clan_message(
-                        session, channel, message_name, await reader.read(MAX_DISCORD_MESSAGE_LENGTH)
-                    )
-
-
-async def get_clan_message_channel(session: Session, channel_name: str, guild: nextcord.Guild) -> nextcord.TextChannel:
-    """
-    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.
-
-    Args:
-        session (Session): Open connection to database.
-        channel_name (str): Name of channel to obtain.
-        guild (nextcord.Guild): Guild object to get channel from.
-
-    Returns:
-        nextcord.TextChannel: Channel object with name channel_name.
-    """
-    stmt = select(Messages.Id).where(Messages.Path == channel_name)
-    channel_id = session.scalar(stmt)
-    if channel_id is None:
-        ret_channel = None
-        # 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:
-                ret_channel = channel
-
-        if ret_channel is None:
-            # channel doesn't exist, we must create it
-            ret_channel = await guild.create_text_channel(
-                channel_name,
-                reason="Creating channel as required for by design of Dakiny-Messages repo.",
-            )
-
-        # record channel information
-        new_item = Messages(Path=channel_name, Id=ret_channel.id)
-        session.add(new_item)
-        session.commit()
-        return ret_channel
-
-    try:
-        return await guild.fetch_channel(channel_id)
-    except nextcord.NotFound:
-        # the channel was deleted for some reason
-        ret_channel = await guild.create_text_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)
-        session.execute(stmt)
-        session.commit()
-        return ret_channel
-
-
-async def edit_clan_message(
-    session: Session,
-    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.
-    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.
-
-    Args:
-        session (Session): Open connection to database.
-        channel (nextcord.TextChannel): Channel object that message belongs to.
-        message_name (str): Name of the message. Corresponds to the file that contains message content.
-        message_content (str): Content of the message to edit/send.
-    """
-    stmt = select(Messages.Id).where(Messages.Path == message_name)
-    msg_id = session.scalar(stmt)
-    if msg_id is None:
-        # don't have a message for this file
-        msg = await channel.send(message_content)
-        new_message = Messages(Path=message_name, Id=msg.id)
-        session.add(new_message)
-        session.commit()
-    else:
-        try:
-            msg: nextcord.Message = await channel.fetch_message(msg_id)
-            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)
-            session.execute(stmt)
-            session.commit()
-
-
-async def edit_clan_council_info(guild: nextcord.Guild) -> None:
-    """
-    Gets the winners of the elections and updates the permanent message that states the current council.
-
-    Args:
-        guild (nextcord.Guild): Guild object that to use to get channel.
-    """
-    clan_info_channel: nextcord.TextChannel = await guild.fetch_channel(settings.channel_ids.clan_info)
-
-    election_name = get_election_name()
-    with Session(engine) as session:
-        stmt = (
-            select(CouncilMembers.MemberId)
-            .where(CouncilMembers.ElectionName == election_name)
-            .where(CouncilMembers.DiscordManager == true())
-        )
-        discord_manager = session.scalar(stmt)
-        stmt = (
-            select(CouncilMembers.MemberId)
-            .where(CouncilMembers.ElectionName == election_name)
-            .where(CouncilMembers.ClanLeader == true())
-        )
-        clan_leader = session.scalar(stmt)
-        stmt = (
-            select(CouncilMembers.MemberId)
-            .where(CouncilMembers.ElectionName == election_name)
-            .where(CouncilMembers.Elected == true())
-        )
-
-        council_member_ids = sorted(
-            session.scalars(stmt), key=lambda user_id: guild.get_member(user_id).display_name.lower()
-        )
-
-        council_members_strs = [
-            f"<@{user_id}>" for user_id in council_member_ids if user_id not in (discord_manager, clan_leader)
-        ]
-
-        quarter = get_quarter_name()
-
-        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),
-                clan_leader=clan_leader,
-                discord_manager=discord_manager,
-            )
-
-        await edit_clan_message(session, clan_info_channel, "council_members.txt", message)