Streamline configuration

Model all configuration as cog-specific pydantic.BaseModels.

Author: NMertsch

prod-config.toml

@@ -1,4 +1,16 @@
-[item_to_role]
+log_level = "INFO"
+
+[registration]
+registration_form_channel_name = "registration-form"
+registration_help_channel_name = "registration-help"
+registration_log_channel_name = "registration-log"
+
+pretix_base_url = "https://pretix.eu/api/v1/organizers/europython/events/ep2025"
+
+registered_cache_file = "registered_log.txt"
+pretix_cache_file = "pretix_cache.json"
+
+[registration.item_to_roles]
 # onsite participants
 "Business" = ["Participants", "Onsite Participants"]
 "Personal" = ["Participants", "Onsite Participants"]
@@ -14,22 +26,9 @@
 # speakers
 "Presenter" = ["Participants", "Onsite Participants", "Speakers"]
 
-[variation_to_role]
+[registration.variation_to_roles]
 "Volunteer" = ["Volunteers"]
 
-[registration]
-REG_CHANNEL_NAME = "registration-form"
-REG_HELP_CHANNEL_NAME = "registration-help"
-REG_LOG_CHANNEL_NAME = "registration-log"
-REGISTERED_LOG_FILE = "registered_log.txt"
-
-[pretix]
-PRETIX_BASE_URL = "https://pretix.eu/api/v1/organizers/europython/events/ep2025"
-PRETIX_CACHE_FILE = "pretix_cache.json"
-
-[logging]
-LOG_LEVEL = "INFO"
-
 [program_notifications]
 # UTC offset in hours (e.g. 2 for CEST)
 timezone_offset = 2
@@ -39,7 +38,7 @@ livestream_url_file = "livestreams.toml"
 main_notification_channel_name = "programme-notifications"
 
 # optional simulated start time for testing program notifications
-# simulated_start_time = "2024-07-10T07:30:00"
+# simulated_start_time = "2024-07-10T07:30:00+02:00"
 
 # optional fast mode for faster testing of program notifications
 # will only take effect if simulated_start_time is set
@@ -54,5 +53,5 @@ main_notification_channel_name = "programme-notifications"
 "Terrace 2B" = "terrace-2b"
 "Exhibit Hall" = "exhibit-hall"
 
-[server_statistics]
+[guild_statistics]
 required_role = "Organizers"

src/europython_discord/bot.py

@@ -1,22 +1,35 @@
+from __future__ import annotations
+
 import argparse
 import asyncio
 import logging
 import os
 import sys
+import tomllib
 from pathlib import Path
+from typing import Literal
 
 import discord
 from discord.ext import commands
+from pydantic import BaseModel
 
-from europython_discord.cogs.guild_statistics import GuildStatisticsCog
+from europython_discord.cogs.guild_statistics import GuildStatisticsCog, GuildStatisticsConfig
 from europython_discord.cogs.ping import PingCog
-from europython_discord.configuration import Config
 from europython_discord.program_notifications.cog import ProgramNotificationsCog
+from europython_discord.program_notifications.config import ProgramNotificationsConfig
 from europython_discord.registration.cog import RegistrationCog
+from europython_discord.registration.config import RegistrationConfig
 
 _logger = logging.getLogger(__name__)
 
 
+class Config(BaseModel):
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+    registration: RegistrationConfig
+    program_notifications: ProgramNotificationsConfig
+    guild_statistics: GuildStatisticsConfig
+
+
 async def run_bot(config: Config, auth_token: str) -> None:
     intents = discord.Intents.all()
     intents.presences = False
@@ -27,9 +40,9 @@ async def run_bot(config: Config, auth_token: str) -> None:
 
     async with commands.Bot(intents=intents, command_prefix="$") as bot:
         await bot.add_cog(PingCog(bot))
-        await bot.add_cog(RegistrationCog(bot, config))
-        await bot.add_cog(ProgramNotificationsCog(bot, config))
-        await bot.add_cog(GuildStatisticsCog(bot, config.ROLE_REQUIRED_FOR_STATISTICS))
+        await bot.add_cog(RegistrationCog(bot, config.registration))
+        await bot.add_cog(ProgramNotificationsCog(bot, config.program_notifications))
+        await bot.add_cog(GuildStatisticsCog(bot, config.guild_statistics))
 
         await bot.start(auth_token)
 
@@ -47,10 +60,11 @@ def main() -> None:
         raise RuntimeError("Missing environment variable 'DISCORD_BOT_TOKEN'")
     bot_auth_token = os.environ["DISCORD_BOT_TOKEN"]
 
-    config = Config(Path(config_file))
+    config_file_content = Path(config_file).read_text()
+    config = Config(**tomllib.loads(config_file_content))
 
     logging.basicConfig(
-        level=config.LOG_LEVEL,
+        level=config.log_level,
         stream=sys.stdout,
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
     )

src/europython_discord/cogs/guild_statistics.py

@@ -1,20 +1,27 @@
 """Commands for organisers."""
 
+from __future__ import annotations
+
 import logging
 
 from discord import Role
 from discord.ext import commands
 from discord.utils import get as discord_get
+from pydantic import BaseModel
 
 _logger = logging.getLogger(__name__)
 
 
+class GuildStatisticsConfig(BaseModel):
+    required_role: str
+
+
 class GuildStatisticsCog(commands.Cog):
     """A cog with commands for organisers."""
 
-    def __init__(self, bot: commands.Bot, required_role_name: str) -> None:
+    def __init__(self, bot: commands.Bot, config: GuildStatisticsConfig) -> None:
         self._bot = bot
-        self._required_role_name = required_role_name
+        self._required_role_name = config.required_role
 
     @commands.command(name="participants")
     async def list_participants(self, ctx: commands.Context) -> None:

src/europython_discord/configuration.py

@@ -4,39 +4,39 @@
 from discord.ext import commands, tasks
 from discord.utils import get as discord_get
 
-from europython_discord.configuration import Config
 from europython_discord.program_notifications import session_to_embed
+from europython_discord.program_notifications.config import ProgramNotificationsConfig
 from europython_discord.program_notifications.livestream_connector import LivestreamConnector
 from europython_discord.program_notifications.program_connector import ProgramConnector
 
 _logger = logging.getLogger(__name__)
 
 
 class ProgramNotificationsCog(commands.Cog):
-    def __init__(self, bot: Client, config: Config) -> None:
+    def __init__(self, bot: Client, config: ProgramNotificationsConfig) -> None:
         self.bot = bot
         self.config = config
         self.program_connector = ProgramConnector(
-            api_url=self.config.PROGRAM_API_URL,
-            timezone_offset=self.config.TIMEZONE_OFFSET,
-            cache_file=self.config.SCHEDULE_CACHE_FILE,
-            simulated_start_time=self.config.SIMULATED_START_TIME,
-            fast_mode=self.config.FAST_MODE,
+            api_url=self.config.api_url,
+            timezone_offset=self.config.timezone_offset,
+            cache_file=self.config.schedule_cache_file,
+            simulated_start_time=self.config.simulated_start_time,
+            fast_mode=self.config.fast_mode,
         )
 
-        self.livestream_connector = LivestreamConnector(self.config.LIVESTREAM_URL_FILE)
+        self.livestream_connector = LivestreamConnector(self.config.livestream_url_file)
 
         self.notified_sessions = set()
         _logger.info("Cog 'Program Notifications' has been initialized")
 
     @commands.Cog.listener()
     async def on_ready(self) -> None:
-        if self.config.SIMULATED_START_TIME:
+        if self.config.simulated_start_time:
             _logger.info("Running in simulated time mode.")
             _logger.info("Will purge all room channels to avoid pile-up of test notifications.")
             await self.purge_all_room_channels()
-            _logger.debug(f"Simulated start time: {self.config.SIMULATED_START_TIME}")
-            _logger.debug(f"Fast mode: {self.config.FAST_MODE}")
+            _logger.debug(f"Simulated start time: {self.config.simulated_start_time}")
+            _logger.debug(f"Fast mode: {self.config.fast_mode}")
         _logger.info("Starting the session notifier...")
         self.notify_sessions.start()
         _logger.info("Cog 'Program Notifications' is ready")
@@ -49,7 +49,7 @@ async def cog_load(self) -> None:
         self.fetch_schedule.start()
         self.fetch_livestreams.start()
         self.notify_sessions.change_interval(
-            seconds=2 if self.config.FAST_MODE and self.config.SIMULATED_START_TIME else 60
+            seconds=2 if self.config.fast_mode and self.config.simulated_start_time else 60
         )
         _logger.info("Schedule updater started and interval set for the session notifier")
 
@@ -86,7 +86,7 @@ async def notify_sessions(self) -> None:
             return
 
         main_notification_channel = discord_get(
-            self.bot.get_all_channels(), name=self.config.MAIN_NOTIFICATION_CANNEL_NAME
+            self.bot.get_all_channels(), name=self.config.main_notification_channel_name
         )
         await main_notification_channel.send(content="# Sessions starting in 5 minutes:")
 
@@ -116,13 +116,13 @@ async def notify_sessions(self) -> None:
 
     async def purge_all_room_channels(self) -> None:
         _logger.info("Purging all room channels...")
-        for channel_name in self.config.ROOMS_TO_CHANNEL_NAMES.values():
+        for channel_name in self.config.rooms_to_channel_names.values():
             channel = discord_get(self.bot.get_all_channels(), name=channel_name)
             await channel.purge()
         _logger.info("Purged all room channels.")
 
     def _get_room_channel(self, room_name: str) -> TextChannel | None:
-        channel_name = self.config.ROOMS_TO_CHANNEL_NAMES.get(room_name)
+        channel_name = self.config.rooms_to_channel_names.get(room_name)
         if channel_name is None:
             _logger.warning(f"No notification channel configured for room {room_name!r}")
             return None

src/europython_discord/program_notifications/cog.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import datetime
+from pathlib import Path
+
+from pydantic import BaseModel
+
+
+class ProgramNotificationsConfig(BaseModel):
+    timezone_offset: int
+    api_url: str
+    schedule_cache_file: Path
+    livestream_url_file: Path
+    main_notification_channel_name: str
+    rooms_to_channel_names: Mapping[str, str]
+
+    simulated_start_time: datetime | None = None
+    fast_mode: bool = False