Rewrote Crabstero from Java to Python.

- Replaced Javacord with discord.py.
- Replaced Redis backend with SQLite via aiosqlite.
- Replaced Gradle build with pyproject.toml and uv.
- Added setuptools-scm for automatic versioning from git tags.
- Added argparse CLI with systemd credential support for the bot token.
- Replaced per-channel ingestion tasks with a bounded queue and worker pool.
- Removed Dockerfile and Gitea Actions workflow.

.gitea/workflows/build.yml

@@ -1,24 +0,0 @@
-name: Build Distribution
-on: [push]
-
-jobs:
-  Build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Java environment
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
-      - name: Build artifact
-        run: chmod +x ./gradlew && ./gradlew build --no-daemon
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: Distribution
-          path: build/distributions/Crabstero.zip

.gitignore

@@ -1,2 +1,10 @@
-.gradle/
-.idea/
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.env
+*.db
+.venv/
+crabstero/_version.py

.python-version

@@ -0,0 +1 @@
+3.14

Dockerfile

@@ -1,9 +0,0 @@
-FROM gradle:8.7.0-jdk17-alpine AS build
-COPY . /home/gradle/Crabstero
-WORKDIR /home/gradle/Crabstero
-RUN gradle build --no-daemon
-
-FROM eclipse-temurin:17.0.11_9-jre-alpine AS run
-COPY --from=build /home/gradle/Crabstero/build/distributions/Crabstero.tar /
-RUN tar -xvf Crabstero.tar && rm /Crabstero.tar /Crabstero/bin/Crabstero.bat
-ENTRYPOINT ["/Crabstero/bin/Crabstero"]

LICENSE.txt

@@ -1,6 +1,7 @@
+
                                  Apache License
                            Version 2.0, January 2004
-                        https://www.apache.org/licenses/
+                        http://www.apache.org/licenses/
 
    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
@@ -173,4 +174,29 @@
       incurred by, or claims asserted against, such Contributor by reason
       of your accepting any such warranty or additional liability.
 
-   END OF TERMS AND CONDITIONS
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

build.gradle

@@ -1,18 +0,0 @@
-plugins {
-    id 'java'
-    id 'application'
-}
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    implementation 'org.javacord:javacord:3.8.0'
-    implementation 'redis.clients:jedis:5.1.0'
-
-    implementation 'org.slf4j:slf4j-simple:2.0.12'
-}
-
-compileJava.options.encoding = 'UTF-8'
-mainClassName = 'dev.logal.crabstero.Crabstero'

crabstero/__main__.py

@@ -0,0 +1,130 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Entry point for the Crabstero Discord bot.
+
+Provides an argparse CLI with environment variable and systemd credential fallbacks for --token and --database-path.
+"""
+
+import argparse
+import asyncio
+import logging
+import os
+import signal
+import sys
+
+from crabstero._version import version as crabstero_version
+from crabstero.bot import Crabstero
+
+logger = logging.getLogger("crabstero")
+
+
+def _read_credential(name: str) -> str | None:
+    """
+    Read a value from a systemd credential file.
+
+    Looks for a file named *name* inside the directory pointed to by the
+    ``CREDENTIALS_DIRECTORY`` environment variable (set automatically by
+    systemd when ``LoadCredential=`` or ``SetCredential=`` is used).
+
+    :param name: Credential name to look up.
+    :return: The credential value, or ``None`` if unavailable.
+    """
+    credentials_dir = os.environ.get("CREDENTIALS_DIRECTORY")
+    if credentials_dir is None:
+        return None
+
+    try:
+        return (
+            open(os.path.join(credentials_dir, name)).read().strip()  # noqa: SIM115
+        )
+    except OSError:
+        return None
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    """
+    Parses command-line arguments with environment variable fallbacks.
+
+    :param argv: Optional argument list (defaults to sys.argv[1:]).
+    :return: Parsed arguments namespace.
+    """
+    parser = argparse.ArgumentParser(
+        prog="crabstero",
+        description="Crabstero - the simple nonversation Discord bot.",
+    )
+    parser.add_argument(
+        "--token",
+        default=os.environ.get("TOKEN") or _read_credential("token"),
+        help="Discord bot token (default: TOKEN environment variable or systemd credential 'token').",
+    )
+    parser.add_argument(
+        "--database-path",
+        "--database",
+        default=os.environ.get("DATABASE_PATH", "crabstero.db"),
+        help='Path to the SQLite database file (default: DATABASE_PATH environment variable or "crabstero.db").',
+    )
+    parser.add_argument(
+        "--ingestion-workers",
+        type=int,
+        default=int(os.environ.get("INGESTION_WORKERS", "4")),
+        help="Number of concurrent ingestion workers (default: INGESTION_WORKERS environment variable or 4).",
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.token is None:
+        parser.error(
+            "a Discord bot token is required via --token, the TOKEN environment variable, or a systemd credential named 'token'"
+        )
+
+    return args
+
+
+def main() -> None:
+    """
+    Main entry point. Parses arguments, configures logging, and starts the bot.
+    """
+    args = _parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s",
+    )
+
+    logger.info("Starting Crabstero %s...", crabstero_version)
+
+    bot = Crabstero(
+        token=args.token,
+        database_path=args.database_path,
+        ingestion_workers=args.ingestion_workers,
+    )
+
+    async def _run() -> None:
+        async with bot:
+            await bot.start()
+
+    # Make SIGTERM behave like SIGINT so systemd stop triggers the same
+    # clean shutdown path (context manager __aexit__ -> bot.close()).
+    signal.signal(signal.SIGTERM, signal.default_int_handler)
+
+    try:
+        asyncio.run(_run())
+    except KeyboardInterrupt:
+        logger.info("Interrupted.")
+
+
+if __name__ == "__main__":
+    main()

crabstero/bot.py

@@ -0,0 +1,153 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The simple nonversation Discord bot.
+
+Provides the Crabstero subclass that owns the full bot lifecycle: database connection,
+cog loading, ingestion worker pool, and graceful shutdown.
+"""
+
+import asyncio
+import logging
+
+import discord
+from discord import app_commands
+from discord.ext import commands
+
+from crabstero._version import version as crabstero_version
+from crabstero.database import Database
+from crabstero.tasks.ingestion import ingest_channel
+
+logger = logging.getLogger(__name__)
+
+
+class Crabstero(commands.Bot):
+    """
+    Central bot subclass that owns all lifecycle state.
+
+    The database is opened in setup_hook and closed in close(). Background
+    ingestion is handled by a bounded queue and a fixed worker pool.
+    """
+
+    def __init__(
+        self, token: str, database_path: str, ingestion_workers: int = 4
+    ) -> None:
+        """
+        Configures intents, stores configuration, and prepares ingestion queue state.
+
+        :param token: The Discord bot token.
+        :param database_path: The file path to the SQLite database.
+        :param ingestion_workers: The number of concurrent ingestion workers.
+        """
+        intents = discord.Intents.default()
+        intents.guilds = True
+        intents.guild_messages = True
+        intents.message_content = True
+
+        super().__init__(
+            command_prefix=[],
+            intents=intents,
+            max_messages=None,  # Disables the message cache.
+        )
+
+        self._token = token
+        self._database_path = database_path
+        self._ingestion_worker_count = ingestion_workers
+        self._ingestion_queue: asyncio.Queue[
+            discord.TextChannel | discord.VoiceChannel
+        ] = asyncio.Queue()
+        self._ingestion_workers: list[asyncio.Task[None]] = []
+        self.db: Database
+
+        self.http.user_agent = f"DiscordBot (https://git.logal.dev/LogalDeveloper/Crabstero, {crabstero_version})"
+
+    async def setup_hook(self) -> None:
+        """Opens the database, starts ingestion workers, loads all cogs, and syncs slash commands if changed."""
+        self.db = await Database.connect(self._database_path)
+        self._start_ingestion_workers()
+
+        from crabstero.listeners import interaction, message, server_events
+
+        await interaction.setup(self)
+        await message.setup(self)
+        await server_events.setup(self)
+
+        # Only sync slash commands if the registered commands differ from local definitions.
+        local_commands = {
+            cmd.name: cmd.description
+            for cmd in self.tree.get_commands()
+            if isinstance(cmd, (app_commands.Command, app_commands.Group))
+        }
+        try:
+            remote_commands = {
+                cmd.name: cmd.description for cmd in await self.tree.fetch_commands()
+            }
+        except discord.HTTPException:
+            remote_commands = {}
+
+        if local_commands != remote_commands:
+            logger.info("Slash command tree has changed, syncing with Discord.")
+            await self.tree.sync()
+
+    async def on_ready(self) -> None:
+        """Logs that the bot has started successfully."""
+        logger.info("Crabstero started!")
+
+    async def start(self, token: str = "", *, reconnect: bool = True) -> None:
+        """
+        Starts the bot using the stored token by default.
+
+        :param token: Optional token override. Falls back to the stored token if empty.
+        :param reconnect: Whether to automatically reconnect on disconnect.
+        """
+        await super().start(token or self._token, reconnect=reconnect)
+
+    async def close(self) -> None:
+        """Cancels ingestion workers, closes the database, and then the bot connection."""
+        if self.is_closed():
+            return
+        logger.info("Shutting down Crabstero...")
+        for worker in self._ingestion_workers:
+            worker.cancel()
+        await asyncio.gather(*self._ingestion_workers, return_exceptions=True)
+        self._ingestion_workers.clear()
+        if hasattr(self, "db"):
+            await self.db.close()
+        await super().close()
+
+    def queue_channel_for_ingestion(
+        self, channel: discord.TextChannel | discord.VoiceChannel
+    ) -> None:
+        """
+        Enqueues a single channel for background message history ingestion.
+
+        :param channel: The channel to enqueue.
+        """
+        self._ingestion_queue.put_nowait(channel)
+
+    def _start_ingestion_workers(self) -> None:
+        """Spawns the fixed pool of ingestion worker tasks."""
+        for _ in range(self._ingestion_worker_count):
+            task = asyncio.create_task(self._ingestion_worker())
+            self._ingestion_workers.append(task)
+
+    async def _ingestion_worker(self) -> None:
+        """Loops forever pulling channels from the ingestion queue and ingesting them."""
+        while True:
+            channel = await self._ingestion_queue.get()
+            try:
+                await ingest_channel(channel, self.db)
+            finally:
+                self._ingestion_queue.task_done()

crabstero/database.py

@@ -0,0 +1,327 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Provides async SQLite database access for all of Crabstero's persistent storage needs.
+
+Uses aiosqlite for native async access. All methods are async def.
+"""
+
+import asyncio
+import logging
+from typing import Self
+
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+AUTO_COMMIT_WRITE_THRESHOLD = 100  # Commit after this many DB write operations.
+AUTO_COMMIT_TIMEOUT_SECONDS = (
+    60.0  # Commit after this many seconds since first uncommitted write.
+)
+
+# SQL statements for creating the database schema.
+_SCHEMA = """
+-- Markov chain starting words.
+-- Each row represents one occurrence. Duplicates represent frequency weight.
+CREATE TABLE IF NOT EXISTS markov_start_words (
+    channel_id INTEGER NOT NULL,
+    word TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_start_channel ON markov_start_words(channel_id, word);
+
+-- Markov chain word transitions.
+-- Each row represents one occurrence. Duplicates represent frequency weight.
+CREATE TABLE IF NOT EXISTS markov_transitions (
+    channel_id INTEGER NOT NULL,
+    word TEXT NOT NULL,
+    next_word TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_transitions_channel_word ON markov_transitions(channel_id, word);
+
+-- Image URLs per channel.
+CREATE TABLE IF NOT EXISTS channel_images (
+    channel_id INTEGER NOT NULL,
+    url TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_images_channel ON channel_images(channel_id);
+
+-- Flags for channels, servers, and users.
+CREATE TABLE IF NOT EXISTS flags (
+    entity_type TEXT NOT NULL,
+    entity_id TEXT NOT NULL,
+    flag_name TEXT NOT NULL,
+    PRIMARY KEY (entity_type, entity_id, flag_name)
+);
+
+-- Tracks which channels have been bulk-ingested.
+CREATE TABLE IF NOT EXISTS ingested_channels (
+    channel_id INTEGER NOT NULL PRIMARY KEY
+);
+"""
+
+
+class Database:
+    """
+    Manages all SQLite database operations for Crabstero.
+
+    Uses aiosqlite for native async access. A single connection is held open for the lifetime of
+    the bot process with WAL mode enabled for concurrent read performance.
+    """
+
+    def __init__(self, connection: aiosqlite.Connection) -> None:
+        """
+        Initializes the Database wrapper with an already-opened aiosqlite connection.
+
+        :param connection: An open aiosqlite connection.
+        """
+        self._connection = connection
+        self._pending_writes = 0
+        self._flush_task: asyncio.Task[None] | None = None
+
+    @classmethod
+    async def connect(cls, path: str) -> Self:
+        """
+        Opens a new SQLite database at the given path, configures it for performance, and creates
+        the schema if it does not already exist.
+
+        :param path: The file path to the SQLite database.
+        :return: A new Database instance ready for use.
+        """
+        connection = await aiosqlite.connect(path)
+
+        # Enable WAL mode for better concurrent read performance.
+        await connection.execute("PRAGMA journal_mode=WAL")
+
+        # Set synchronous to NORMAL for a balance between safety and speed.
+        await connection.execute("PRAGMA synchronous=NORMAL")
+
+        # Create the schema tables and indexes if they do not already exist.
+        # executescript auto-commits, so no explicit commit is needed.
+        await connection.executescript(_SCHEMA)
+
+        return cls(connection)
+
+    async def commit(self) -> None:
+        """Commits pending writes and resets the flush timer."""
+        await self._connection.commit()
+        self._pending_writes = 0
+        if self._flush_task is not None:
+            self._flush_task.cancel()
+            self._flush_task = None
+
+    async def close(self) -> None:
+        """Cancels the flush timer, commits any pending writes, then closes the database connection."""
+        if self._flush_task is not None:
+            self._flush_task.cancel()
+            try:
+                await self._flush_task
+            except asyncio.CancelledError:
+                pass
+            self._flush_task = None
+        if self._pending_writes > 0:
+            await self._connection.commit()
+            self._pending_writes = 0
+        await self._connection.close()
+
+    async def add_start_words_batch(self, rows: list[tuple[int, str]]) -> None:
+        """
+        Inserts a batch of starting words into the markov_start_words table.
+
+        :param rows: A list of (channel_id, word) tuples to insert.
+        """
+        await self._connection.executemany(
+            "INSERT INTO markov_start_words (channel_id, word) VALUES (?, ?)", rows
+        )
+        await self._maybe_commit()
+
+    async def get_random_start_word(self, channel_id: int) -> str | None:
+        """
+        Returns a random starting word for a given channel, weighted by occurrence frequency.
+
+        :param channel_id: The Discord channel ID.
+        :return: A random starting word, or None if no starting words exist for this channel.
+        """
+        async with self._connection.execute(
+            "SELECT word FROM markov_start_words WHERE channel_id = ? ORDER BY RANDOM() LIMIT 1",
+            (channel_id,),
+        ) as cursor:
+            row = await cursor.fetchone()
+            return row[0] if row else None
+
+    async def add_transitions_batch(self, rows: list[tuple[int, str, str]]) -> None:
+        """
+        Inserts a batch of word transitions into the markov_transitions table.
+
+        :param rows: A list of (channel_id, word, next_word) tuples to insert.
+        """
+        await self._connection.executemany(
+            "INSERT INTO markov_transitions (channel_id, word, next_word) VALUES (?, ?, ?)",
+            rows,
+        )
+        await self._maybe_commit()
+
+    async def get_random_next_word(self, channel_id: int, word: str) -> str | None:
+        """
+        Returns a random next word for a given word in a given channel, weighted by occurrence
+        frequency.
+
+        :param channel_id: The Discord channel ID.
+        :param word: The current word to find a transition for.
+        :return: A random next word, or None if no transitions exist.
+        """
+        async with self._connection.execute(
+            "SELECT next_word FROM markov_transitions WHERE channel_id = ? AND word = ? ORDER BY RANDOM() LIMIT 1",
+            (channel_id, word),
+        ) as cursor:
+            row = await cursor.fetchone()
+            return row[0] if row else None
+
+    async def get_random_completing_next_word(
+        self, channel_id: int, word: str
+    ) -> str | None:
+        """
+        Returns a random next word that ends a sentence for a given word in a given channel,
+        weighted by occurrence frequency.
+
+        A completing word is one whose last character is '.', '!', '?', or '§'.
+
+        :param channel_id: The Discord channel ID.
+        :param word: The current word to find a completing transition for.
+        :return: A random completing next word, or None if no completing transitions exist.
+        """
+        async with self._connection.execute(
+            "SELECT next_word FROM markov_transitions WHERE channel_id = ? AND word = ? AND SUBSTR(next_word, -1, 1) IN ('.', '!', '?', '§') ORDER BY RANDOM() LIMIT 1",
+            (channel_id, word),
+        ) as cursor:
+            row = await cursor.fetchone()
+            return row[0] if row else None
+
+    async def add_image(self, channel_id: int, url: str) -> None:
+        """
+        Stores an image URL for a given channel.
+
+        :param channel_id: The Discord channel ID.
+        :param url: The image URL to store.
+        """
+        await self._connection.execute(
+            "INSERT INTO channel_images (channel_id, url) VALUES (?, ?)",
+            (channel_id, url),
+        )
+        await self._maybe_commit()
+
+    async def get_random_image(self, channel_id: int) -> str | None:
+        """
+        Returns a random image URL for a given channel.
+
+        :param channel_id: The Discord channel ID.
+        :return: A random image URL, or None if no images exist for this channel.
+        """
+        async with self._connection.execute(
+            "SELECT url FROM channel_images WHERE channel_id = ? ORDER BY RANDOM() LIMIT 1",
+            (channel_id,),
+        ) as cursor:
+            row = await cursor.fetchone()
+            return row[0] if row else None
+
+    async def set_flag(self, entity_type: str, entity_id: str, flag_name: str) -> None:
+        """
+        Sets a flag on a given entity. If the flag is already set, this is a no-op.
+
+        :param entity_type: The type of entity ("channel", "server", or "user").
+        :param entity_id: The Discord ID of the entity.
+        :param flag_name: The name of the flag to set.
+        """
+        await self._connection.execute(
+            "INSERT OR IGNORE INTO flags (entity_type, entity_id, flag_name) VALUES (?, ?, ?)",
+            (entity_type, entity_id, flag_name),
+        )
+        await self._maybe_commit()
+
+    async def clear_flag(
+        self, entity_type: str, entity_id: str, flag_name: str
+    ) -> None:
+        """
+        Clears a flag on a given entity. If the flag is not set, this is a no-op.
+
+        :param entity_type: The type of entity ("channel", "server", or "user").
+        :param entity_id: The Discord ID of the entity.
+        :param flag_name: The name of the flag to clear.
+        """
+        await self._connection.execute(
+            "DELETE FROM flags WHERE entity_type = ? AND entity_id = ? AND flag_name = ?",
+            (entity_type, entity_id, flag_name),
+        )
+        await self._maybe_commit()
+
+    async def is_flag_set(
+        self, entity_type: str, entity_id: str, flag_name: str
+    ) -> bool:
+        """
+        Checks whether a flag is set on a given entity.
+
+        :param entity_type: The type of entity ("channel", "server", or "user").
+        :param entity_id: The Discord ID of the entity.
+        :param flag_name: The name of the flag to check.
+        :return: True if the flag is set, False otherwise.
+        """
+        async with self._connection.execute(
+            "SELECT 1 FROM flags WHERE entity_type = ? AND entity_id = ? AND flag_name = ?",
+            (entity_type, entity_id, flag_name),
+        ) as cursor:
+            return await cursor.fetchone() is not None
+
+    async def is_channel_ingested(self, channel_id: int) -> bool:
+        """
+        Checks whether a channel has already been bulk-ingested.
+
+        :param channel_id: The Discord channel ID.
+        :return: True if the channel has been ingested, False otherwise.
+        """
+        async with self._connection.execute(
+            "SELECT 1 FROM ingested_channels WHERE channel_id = ?",
+            (channel_id,),
+        ) as cursor:
+            return await cursor.fetchone() is not None
+
+    async def mark_channel_ingested(self, channel_id: int) -> None:
+        """
+        Marks a channel as having been bulk-ingested.
+
+        :param channel_id: The Discord channel ID.
+        """
+        await self._connection.execute(
+            "INSERT OR IGNORE INTO ingested_channels (channel_id) VALUES (?)",
+            (channel_id,),
+        )
+        await self._maybe_commit()
+
+    async def _maybe_commit(self) -> None:
+        """Tracks a pending write. Commits if the threshold is reached, otherwise starts a flush timer."""
+        self._pending_writes += 1
+        if self._pending_writes >= AUTO_COMMIT_WRITE_THRESHOLD:
+            await self.commit()
+        elif self._flush_task is None:
+            self._flush_task = asyncio.create_task(self._flush_after_timeout())
+
+    async def _flush_after_timeout(self) -> None:
+        """Background task that commits after the timeout elapses."""
+        try:
+            await asyncio.sleep(AUTO_COMMIT_TIMEOUT_SECONDS)
+            if self._pending_writes > 0:
+                await self.commit()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("Error in database flush timer.")

crabstero/flags.py

@@ -0,0 +1,106 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Provides async convenience wrappers around the database flag methods.
+
+Accepts discord.py objects or raw integer IDs and translates them into the
+entity_type/entity_id pairs used by the database layer.
+"""
+
+import enum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import discord
+
+    from crabstero.database import Database
+
+
+class Flag(enum.Enum):
+    """Enum of all supported flag names."""
+
+    NO_REPLY = "noReply"
+    NO_INGEST = "noIngest"
+    ALLOW_PINGS = "allowPings"
+
+
+class EntityType(enum.Enum):
+    """Enum of entity types that can have flags."""
+
+    CHANNEL = "channel"
+    SERVER = "server"
+    USER = "user"
+
+
+def _entity_id(entity: discord.abc.Snowflake | int) -> str:
+    """
+    Extracts a string entity ID from a Discord object or raw integer ID.
+
+    :param entity: A Discord entity or raw integer ID.
+    :return: The entity ID as a string.
+    """
+    return str(entity) if isinstance(entity, int) else str(entity.id)
+
+
+async def set_flag(
+    db: Database,
+    entity: discord.abc.Snowflake | int,
+    entity_type: EntityType,
+    flag: Flag,
+) -> None:
+    """
+    Sets a flag on a given entity.
+
+    :param db: The database instance.
+    :param entity: The Discord entity or raw integer ID to set the flag on.
+    :param entity_type: The type of the entity.
+    :param flag: The flag to set.
+    """
+    await db.set_flag(entity_type.value, _entity_id(entity), flag.value)
+
+
+async def clear_flag(
+    db: Database,
+    entity: discord.abc.Snowflake | int,
+    entity_type: EntityType,
+    flag: Flag,
+) -> None:
+    """
+    Clears a flag on a given entity.
+
+    :param db: The database instance.
+    :param entity: The Discord entity or raw integer ID to clear the flag on.
+    :param entity_type: The type of the entity.
+    :param flag: The flag to clear.
+    """
+    await db.clear_flag(entity_type.value, _entity_id(entity), flag.value)
+
+
+async def is_flag_set(
+    db: Database,
+    entity: discord.abc.Snowflake | int,
+    entity_type: EntityType,
+    flag: Flag,
+) -> bool:
+    """
+    Checks whether a flag is set on a given entity.
+
+    :param db: The database instance.
+    :param entity: The Discord entity or raw integer ID to check.
+    :param entity_type: The type of the entity.
+    :param flag: The flag to check for.
+    :return: True if the flag is set, False otherwise.
+    """
+    return await db.is_flag_set(entity_type.value, _entity_id(entity), flag.value)

crabstero/listeners/interaction.py

@@ -0,0 +1,97 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Handles responding to interactions.
+
+Provides the /pingme slash command as a Cog with an app command.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+import discord
+from discord import app_commands
+from discord.ext import commands
+
+from crabstero import flags
+from crabstero.flags import EntityType, Flag
+
+if TYPE_CHECKING:
+    from crabstero.bot import Crabstero
+
+logger = logging.getLogger(__name__)
+
+
+class InteractionCog(commands.Cog):
+    """
+    Cog for handling slash command interactions.
+    """
+
+    def __init__(self, bot: Crabstero) -> None:
+        """
+        Creates a new interaction handler cog.
+
+        :param bot: The bot instance.
+        """
+        self.bot = bot
+
+    @app_commands.command(
+        name="pingme",
+        description="Opts into (or back out of) receiving pings for generated message which mention you.",
+    )
+    async def pingme(self, interaction: discord.Interaction) -> None:
+        """
+        Toggles the allowPings flag for the user who ran the command.
+
+        :param interaction: The interaction event.
+        """
+        # Wrap in try/except to always send a response even if the database fails.
+        try:
+            if await flags.is_flag_set(
+                self.bot.db, interaction.user, EntityType.USER, Flag.ALLOW_PINGS
+            ):
+                await flags.clear_flag(
+                    self.bot.db, interaction.user, EntityType.USER, Flag.ALLOW_PINGS
+                )
+                await interaction.response.send_message(
+                    "I will no longer ping you for messages which mention you. If you decide to opt back in, run `/pingme` any time.",
+                    ephemeral=True,
+                )
+            else:
+                await flags.set_flag(
+                    self.bot.db, interaction.user, EntityType.USER, Flag.ALLOW_PINGS
+                )
+                await interaction.response.send_message(
+                    "I will now ping you for messages which mention you. If you change your mind, run `/pingme` any time.",
+                    ephemeral=True,
+                )
+
+        except Exception:
+            logger.exception(
+                "An exception occurred while attempting to execute slash command responder for command 'pingme'."
+            )
+            await interaction.response.send_message(
+                "An error occurred while executing your command. Please try again later.",
+                ephemeral=True,
+            )
+
+
+async def setup(bot: Crabstero) -> None:
+    """
+    Adds the InteractionCog to the bot.
+
+    :param bot: The bot instance.
+    """
+    await bot.add_cog(InteractionCog(bot))

crabstero/listeners/message.py

@@ -0,0 +1,79 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Handles created messages.
+
+Responds to mentions and ingests normal text messages as a Cog with an on_message listener.
+"""
+
+from typing import TYPE_CHECKING
+
+import discord
+from discord.ext import commands
+
+from crabstero.messages import ingest_message, reply_to_message
+
+if TYPE_CHECKING:
+    from crabstero.bot import Crabstero
+
+
+class MessageCog(commands.Cog):
+    """
+    Cog for handling message creation events.
+    """
+
+    def __init__(self, bot: Crabstero) -> None:
+        """
+        Creates a new message creation handler cog.
+
+        :param bot: The bot instance.
+        """
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_message(self, message: discord.Message) -> None:
+        """
+        Responds to mentions and ingests normal text messages.
+
+        :param message: The message event.
+        """
+        channel = message.channel
+
+        if not isinstance(
+            channel, (discord.TextChannel, discord.Thread, discord.VoiceChannel)
+        ):
+            return
+
+        if message.author.bot or message.author == self.bot.user:
+            return
+
+        if self.bot.user in message.mentions:
+            await reply_to_message(self.bot.db, message)
+            return
+
+        # Only ingest non-thread messages; threads share their parent channel's chain.
+        if message.type == discord.MessageType.default and not isinstance(
+            channel, discord.Thread
+        ):
+            await ingest_message(self.bot.db, message)
+
+
+async def setup(bot: Crabstero) -> None:
+    """
+    Adds the MessageCog to the bot.
+
+    :param bot: The bot instance.
+    """
+    await bot.add_cog(MessageCog(bot))

crabstero/listeners/server_events.py

@@ -0,0 +1,130 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Handles server-level events which trigger channel history ingestion.
+
+All of these events share the same outcome: queuing all textable channels for message history
+ingestion when something changes that may grant new read permissions.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+import discord
+from discord.ext import commands
+
+from crabstero.tasks.ingestion import queue_channels_for_ingestion
+
+if TYPE_CHECKING:
+    from crabstero.bot import Crabstero
+
+logger = logging.getLogger(__name__)
+
+
+class ServerEventsCog(commands.Cog):
+    """
+    Cog for handling server-level events that trigger channel history ingestion.
+    """
+
+    def __init__(self, bot: Crabstero) -> None:
+        """
+        Creates a new server events handler cog.
+
+        :param bot: The bot instance.
+        """
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_guild_join(self, guild: discord.Guild) -> None:
+        """
+        Queues all text channels for message history ingestion when joining a new server.
+        Also logs the join and sends an embed to the bot owner.
+
+        :param guild: The guild that was joined.
+        """
+        logger.info('Joined new server! (Name: "%s" | ID: %s)', guild.name, guild.id)
+
+        embed = discord.Embed(
+            title="Joined New Server", color=discord.Color.from_rgb(255, 165, 0)
+        )
+        embed.add_field(
+            name=f"{guild.name} ({guild.id})",
+            value=f"{guild.member_count} members",
+        )
+
+        if guild.icon:
+            embed.set_image(url=guild.icon.url)
+
+        embed.set_footer(text=f"{len(self.bot.guilds)} total servers")
+
+        app_info = await self.bot.application_info()
+        if app_info.owner:
+            try:
+                await app_info.owner.send(embed=embed)
+            except discord.HTTPException:
+                pass
+
+        queue_channels_for_ingestion(guild, self.bot)
+
+    @commands.Cog.listener()
+    async def on_guild_available(self, guild: discord.Guild) -> None:
+        """
+        Queues all textable channels for message history ingestion when a server becomes available.
+
+        :param guild: The guild that became available.
+        """
+        queue_channels_for_ingestion(guild, self.bot)
+
+    @commands.Cog.listener()
+    async def on_guild_role_update(
+        self, before: discord.Role, after: discord.Role
+    ) -> None:
+        """
+        Queues all text channels for message history ingestion when role permissions change,
+        but only if the bot is a member of the updated role.
+
+        :param before: The role before the update.
+        :param after: The role after the update.
+        """
+        if before.permissions == after.permissions:
+            return
+
+        if after.guild.me in after.members:
+            queue_channels_for_ingestion(after.guild, self.bot)
+
+    @commands.Cog.listener()
+    async def on_guild_channel_update(
+        self, before: discord.abc.GuildChannel, after: discord.abc.GuildChannel
+    ) -> None:
+        """
+        Queues all text channels for message history ingestion when channel override permissions
+        change.
+
+        :param before: The channel before the update.
+        :param after: The channel after the update.
+        """
+        if before.overwrites == after.overwrites:
+            return
+
+        queue_channels_for_ingestion(after.guild, self.bot)
+
+
+async def setup(bot: Crabstero) -> None:
+    """
+    Adds the ServerEventsCog to the bot.
+
+    :param bot: The bot instance.
+    """
+    await bot.add_cog(ServerEventsCog(bot))

crabstero/markov.py

@@ -0,0 +1,152 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Ingests sentences and generates new ones using a Markov chain backed by SQLite storage.
+
+The Markov chain stores word transitions per channel, using duplicate rows to represent frequency
+weight. Random selection via ORDER BY RANDOM() LIMIT 1 naturally preserves this weighting.
+"""
+
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from crabstero.database import Database
+
+# Section sign (§), used internally to mark the end of sentences that lack punctuation,
+# as is common on Discord.
+DEFAULT_SENTENCE_END = "\u00a7"
+
+
+def is_complete_sentence(sentence: str) -> bool:
+    """
+    Checks whether a given sentence ends with a default sentence end character, a period, an
+    exclamation mark, or a question mark.
+
+    :param sentence: The sentence to test.
+    :return: True if the sentence ends with a valid terminator, False otherwise.
+    """
+    if not sentence:
+        return False
+
+    return sentence[-1] in (DEFAULT_SENTENCE_END, ".", "!", "?")
+
+
+async def ingest(db: Database, channel_id: int, paragraph: str) -> None:
+    """
+    Ingests a string potentially containing multiple smaller sentences into the Markov chain
+    for a given channel.
+
+    :param db: The database instance.
+    :param channel_id: The Discord channel ID to associate with this data.
+    :param paragraph: The paragraph of sentences to ingest.
+    """
+    if not is_complete_sentence(paragraph):
+        paragraph += DEFAULT_SENTENCE_END
+
+    # Normalize whitespace, then split on sentence-ending punctuation followed by a space.
+    normalized = re.sub(r" +", " ", paragraph.strip().replace("\n", " "))
+    sentences = re.split(r"(?<=[.!?]) ", normalized)
+
+    for sentence in sentences:
+        await _ingest_sentence(db, channel_id, sentence)
+
+
+async def _ingest_sentence(db: Database, channel_id: int, sentence: str) -> None:
+    """
+    Ingests a string containing a single sentence into the Markov chain for a given channel.
+
+    :param db: The database instance.
+    :param channel_id: The Discord channel ID to associate with this data.
+    :param sentence: The sentence to ingest.
+    """
+    if not is_complete_sentence(sentence):
+        sentence += DEFAULT_SENTENCE_END
+
+    # Normalize whitespace and split into individual words.
+    words = re.sub(r" +", " ", sentence.strip()).split(" ")
+
+    start_words: list[tuple[int, str]] = []
+    transitions: list[tuple[int, str, str]] = []
+
+    for i in range(len(words) - 1):
+        if i == 0:
+            start_words.append((channel_id, words[i]))
+        transitions.append((channel_id, words[i], words[i + 1]))
+
+    if start_words:
+        await db.add_start_words_batch(start_words)
+    if transitions:
+        await db.add_transitions_batch(transitions)
+
+
+async def generate(
+    db: Database, channel_id: int, soft_limit: int = 750, hard_limit: int = 1000
+) -> str:
+    """
+    Generates a new sentence using words learned from previously ingested sentences for a given
+    channel.
+
+    :param db: The database instance.
+    :param channel_id: The Discord channel ID to generate from.
+    :param soft_limit: The amount of characters to try and limit sentence length around.
+    :param hard_limit: The amount of characters to cut off the sentence at if it gets too long.
+    :return: A new generated sentence.
+    """
+    word = await db.get_random_start_word(channel_id)
+
+    # Seed the chain with a fallback sentence if the channel has no data yet.
+    if word is None:
+        await _ingest_sentence(db, channel_id, "Hello world!")
+        word = await db.get_random_start_word(channel_id)
+        if word is None:
+            return ""
+
+    parts: list[str] = []
+    parts.append(word)
+    current_length = len(word)
+
+    # The loop is skipped if the starting word already ends a sentence (e.g. "Yes.").
+    while not is_complete_sentence(word):
+        # Past the soft limit, prefer a sentence-ending word to wrap up.
+        if current_length >= soft_limit:
+            next_word = await db.get_random_completing_next_word(channel_id, word)
+            if next_word is None:
+                next_word = await db.get_random_next_word(channel_id, word)
+        else:
+            next_word = await db.get_random_next_word(channel_id, word)
+
+        if next_word is None:
+            break
+
+        word = next_word
+
+        parts.append(word)
+        current_length += 1 + len(word)  # +1 for the joining space.
+
+        if current_length >= hard_limit:
+            result = " ".join(parts)[:hard_limit]
+            # Strip the internal sentence-end marker if it ended up at the boundary.
+            if result and result[-1] == DEFAULT_SENTENCE_END:
+                return result[:-1]
+            return result
+
+    result = " ".join(parts)
+
+    # Strip the internal sentence-end marker so it never appears in output.
+    if result and result[-1] == DEFAULT_SENTENCE_END:
+        return result[:-1]
+
+    return result

crabstero/messages.py

@@ -0,0 +1,157 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Assists with generating Discord messages in response to other users and ingesting raw messages.
+
+Orchestrates Markov chain generation and ingestion in the context of Discord messages, handling
+reply logic, embed generation, mention filtering, and message ingestion with flag checks.
+"""
+
+import re
+import secrets
+from typing import TYPE_CHECKING
+
+import discord
+
+from crabstero import flags, markov
+from crabstero.flags import EntityType, Flag
+
+if TYPE_CHECKING:
+    from crabstero.database import Database
+
+# Copied from discordjs/discord-api-types:
+# https://github.com/discordjs/discord-api-types/blob/7fe434114e91c80ed79f0204ae6c73047672d55d/globals.ts#L30
+MENTION_PATTERN = re.compile(r"<@!?(?P<id>\d{17,20})>")
+
+
+async def reply_to_message(db: Database, message: discord.Message) -> None:
+    """
+    Sends a new message in Discord in response to a given message.
+
+    :param db: The database instance.
+    :param message: The message prompting the response.
+    """
+    channel = message.channel
+    guild = message.guild
+    if guild is None:
+        return
+
+    if not channel.permissions_for(guild.me).send_messages:
+        return
+
+    if (
+        await flags.is_flag_set(db, channel, EntityType.CHANNEL, Flag.NO_REPLY)
+        or await flags.is_flag_set(db, guild, EntityType.SERVER, Flag.NO_REPLY)
+        or await flags.is_flag_set(db, message.author, EntityType.USER, Flag.NO_REPLY)
+    ):
+        return
+
+    # Threads share their parent channel's Markov chain.
+    if isinstance(channel, discord.Thread):
+        channel_id = channel.parent_id
+    else:
+        channel_id = channel.id
+
+    body = await markov.generate(db, channel_id, 750, 1000)
+
+    embed = None
+
+    # 5% chance to include an embed, if the bot has permission.
+    if secrets.randbelow(100) >= 95 and channel.permissions_for(guild.me).embed_links:
+        embed = discord.Embed(
+            title=await markov.generate(db, channel_id, 200, 300),
+            description=await markov.generate(db, channel_id, 300, 500),
+        )
+
+        random_image = await db.get_random_image(channel_id)
+        if random_image is not None:
+            embed.set_image(url=random_image)
+
+    # Suppress all mentions by default; only ping users who opted in.
+    allowed_user_ids: list[int] = []
+
+    for match in MENTION_PATTERN.finditer(body):
+        user_id = int(match.group("id"))
+
+        if await flags.is_flag_set(db, user_id, EntityType.USER, Flag.ALLOW_PINGS):
+            allowed_user_ids.append(user_id)
+
+    allowed_mentions = discord.AllowedMentions(
+        everyone=False,
+        roles=False,
+        users=[discord.Object(id=uid) for uid in allowed_user_ids],
+    )
+
+    if embed is not None:
+        await message.reply(
+            content=body,
+            embed=embed,
+            allowed_mentions=allowed_mentions,
+            mention_author=False,
+        )
+    else:
+        await message.reply(
+            content=body,
+            allowed_mentions=allowed_mentions,
+            mention_author=False,
+        )
+
+
+async def ingest_message(db: Database, message: discord.Message) -> None:
+    """
+    Ingests a given message into its channel's Markov chain.
+
+    :param db: The database instance.
+    :param message: The message to ingest.
+    """
+    guild = message.guild
+    if guild is None:
+        return
+
+    if message.author.bot or guild.me in message.mentions:
+        return
+
+    if (
+        await flags.is_flag_set(db, message.channel, EntityType.CHANNEL, Flag.NO_INGEST)
+        or await flags.is_flag_set(db, guild, EntityType.SERVER, Flag.NO_INGEST)
+        or await flags.is_flag_set(db, message.author, EntityType.USER, Flag.NO_INGEST)
+    ):
+        return
+
+    channel_id = message.channel.id
+
+    if message.content:
+        await markov.ingest(db, channel_id, message.content)
+
+    for embed in message.embeds:
+        await _ingest_embed(db, channel_id, embed)
+
+
+async def _ingest_embed(db: Database, channel_id: int, embed: discord.Embed) -> None:
+    """
+    Ingests a given embed into a given channel's Markov chain.
+
+    :param db: The database instance.
+    :param channel_id: The ID of the channel to use for the Markov chain.
+    :param embed: The embed to ingest.
+    """
+    if embed.title:
+        await markov.ingest(db, channel_id, embed.title)
+
+    if embed.description:
+        await markov.ingest(db, channel_id, embed.description)
+
+    if embed.image and embed.image.url:
+        await db.add_image(channel_id, embed.image.url)

crabstero/tasks/ingestion.py

@@ -0,0 +1,92 @@
+# Copyright 2026 Logan Fick
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Bulk-ingests the message history of channels.
+
+Channels are enqueued for processing by the bot's fixed ingestion worker pool.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+import discord
+
+from crabstero.messages import ingest_message
+
+if TYPE_CHECKING:
+    from crabstero.bot import Crabstero
+    from crabstero.database import Database
+
+MAXIMUM_MESSAGES_PER_CHANNEL = (
+    50000  # The maximum amount of historical messages to ingest per channel.
+)
+
+logger = logging.getLogger(__name__)
+
+
+def queue_channels_for_ingestion(guild: discord.Guild, bot: Crabstero) -> None:
+    """
+    Enqueues every textable channel in a guild for message history ingestion.
+
+    :param guild: The Discord guild whose channels should be ingested.
+    :param bot: The bot instance.
+    """
+    for channel in guild.channels:
+        if isinstance(channel, (discord.TextChannel, discord.VoiceChannel)):
+            bot.queue_channel_for_ingestion(channel)
+
+
+async def ingest_channel(
+    channel: discord.TextChannel | discord.VoiceChannel,
+    db: Database,
+) -> None:
+    """
+    Bulk-ingests the message history of a given channel. The task will be ended early if
+    permissions do not allow ingesting this channel or if it has already been ingested in the past.
+
+    :param channel: The channel to ingest.
+    :param db: The database instance.
+    """
+    try:
+        if not channel.permissions_for(channel.guild.me).read_message_history:
+            logger.warning(
+                "[%s] Unable to ingest textable channel history due to lacking permissions. Ignoring.",
+                channel.id,
+            )
+            return
+
+        if await db.is_channel_ingested(channel.id):
+            return
+
+        await db.mark_channel_ingested(channel.id)
+
+        logger.info("[%s] Starting ingestion of textable channel history.", channel.id)
+
+        count = 0
+        async for message in channel.history(limit=MAXIMUM_MESSAGES_PER_CHANNEL):
+            count += 1
+            await ingest_message(db, message)
+
+        logger.info(
+            "[%s] Ingestion of textable channel history complete. %d messages ingested.",
+            channel.id,
+            count,
+        )
+
+    except Exception:
+        logger.exception(
+            "[%s] An error occurred while ingesting textable channel history!",
+            channel.id,
+        )

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

gradlew

@@ -1,249 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,92 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "crabstero"
+dynamic = ["version"]
+description = "The simple nonversation Discord bot."
+license = "Apache-2.0"
+requires-python = ">=3.14"
+authors = [
+    { name = "Logan Fick" },
+]
+dependencies = [
+    "discord.py>=2.6.4",
+    "aiosqlite>=0.22.1",
+]
+
+[project.scripts]
+crabstero = "crabstero.__main__:main"
+
+[project.urls]
+Repository = "https://git.logal.dev/LogalDeveloper/Crabstero"
+
+[dependency-groups]
+dev = ["mypy>=1.18.1", "black>=26.1.0"]
+
+[build-system]
+requires = ["setuptools>=61.0", "setuptools-scm>=8.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["crabstero*"]
+
+[tool.setuptools_scm]
+version_file = "crabstero/_version.py"
+
+[tool.mypy]
+strict = true
+exclude = ["crabstero/_version\\.py"]

src/main/java/dev/logal/crabstero/Crabstero.java

@@ -1,115 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero;
-
-import dev.logal.crabstero.listeners.*;
-import org.javacord.api.DiscordApi;
-import org.javacord.api.DiscordApiBuilder;
-import org.javacord.api.entity.intent.Intent;
-import org.javacord.api.interaction.SlashCommand;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import redis.clients.jedis.JedisPool;
-import redis.clients.jedis.JedisPoolConfig;
-
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-
-/**
- * The simple nonversation Discord bot.
- */
-public final class Crabstero {
-    private static final Logger logger = LoggerFactory.getLogger(Crabstero.class);
-
-    private final DiscordApi discordApi;
-    private final JedisPool jedisPool;
-    private final ScheduledExecutorService workerPool;
-
-    /**
-     * Creates a new instance of Crabstero using a given Discord bot token to connect to Discord and a given Redis host and port to connect to a Redis database.
-     *
-     * @param token     The Discord bot token.
-     * @param redisHost The host of the Redis server.
-     * @param redisPort The port of the Redis server.
-     */
-    public Crabstero(final String token, final String redisHost, final int redisPort) {
-        this.jedisPool = new JedisPool(new JedisPoolConfig(), redisHost, redisPort);
-        this.workerPool = Executors.newScheduledThreadPool(4, new CrabsteroThreadFactory());
-
-        final DiscordApiBuilder builder = new DiscordApiBuilder();
-
-        builder.setToken(token);
-        builder.setTrustAllCertificates(false);
-
-        builder.setWaitForServersOnStartup(false);
-        builder.setWaitForUsersOnStartup(false);
-
-        builder.setIntents(Intent.GUILDS, Intent.GUILD_MESSAGES, Intent.MESSAGE_CONTENT);
-
-        builder.addListener(new InteractionCreate(this));
-        builder.addListener(new MessageCreate(this));
-        builder.addListener(new RoleChangePermissions(this));
-        builder.addListener(new ServerBecomesAvailable(this));
-        builder.addListener(new ServerChannelChangeOverwrittenPermissions(this));
-        builder.addListener(new ServerJoin(this));
-        builder.addListener(new UserRoleAdd(this));
-
-        builder.setRecommendedTotalShards();
-
-        this.discordApi = builder.login().join();
-        this.discordApi.setMessageCacheSize(0, 1);
-
-        SlashCommand.with("pingme", "Opts into (or back out of) receiving pings for generated message which mention you.")
-                .setDefaultEnabledForEveryone()
-                .createGlobal(this.discordApi)
-                .join();
-    }
-
-    /**
-     * Entrypoint to the standalone executable build of Crabstero. This simply starts an instance of Crabstero
-     *
-     * @param arguments Command line arguments. Not used.
-     */
-    public static void main(final String[] arguments) {
-        final String token = System.getenv("TOKEN");
-        final String redisHost = System.getenv("REDIS_HOST");
-        final int redisPort = Integer.parseInt(System.getenv("REDIS_PORT"));
-
-        logger.info("Starting Crabstero...");
-        new Crabstero(token, redisHost, redisPort);
-        logger.info("Crabstero started!");
-    }
-
-    /**
-     * Gets the Discord API used by this instance of Crabstero.
-     *
-     * @return The Discord API.
-     */
-    public DiscordApi getDiscordApi() {
-        return this.discordApi;
-    }
-
-    /**
-     * Gets the Jedis pool used by this instance of Crabstero.
-     *
-     * @return The Jedis pool.
-     */
-    public JedisPool getJedisPool() {
-        return this.jedisPool;
-    }
-
-    /**
-     * Gets the worker pool used by this instance of Crabstero.
-     *
-     * @return The scheduled executor service.
-     */
-    public ScheduledExecutorService getWorkerPool() {
-        return this.workerPool;
-    }
-}

src/main/java/dev/logal/crabstero/CrabsteroThreadFactory.java

@@ -1,33 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero;
-
-import java.util.concurrent.ThreadFactory;
-
-/**
- * Creates threads with custom branded names for visibility in tools such as htop.
- */
-public final class CrabsteroThreadFactory implements ThreadFactory {
-    private int threadNumber = 1;
-
-    /**
-     * Creates a new thread with an automatically set name.
-     *
-     * @param runnable The runnable to create the thread with.
-     * @return A new thread with the name automatically set.
-     */
-    @Override
-    public Thread newThread(final Runnable runnable) {
-        final Thread thread = new Thread(runnable);
-
-        thread.setName("Crabstero Worker Thread - " + threadNumber++);
-
-        return thread;
-    }
-}

src/main/java/dev/logal/crabstero/listeners/InteractionCreate.java

@@ -1,96 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.listeners;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.utils.FlagManager;
-import org.javacord.api.entity.message.MessageFlag;
-import org.javacord.api.event.interaction.InteractionCreateEvent;
-import org.javacord.api.interaction.SlashCommandInteraction;
-import org.javacord.api.interaction.callback.InteractionImmediateResponseBuilder;
-import org.javacord.api.listener.interaction.InteractionCreateListener;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Optional;
-
-/**
- * Handles responding to interactions.
- */
-public class InteractionCreate implements InteractionCreateListener {
-    private static final String ALLOW_PINGS_FLAG = "allowPings";
-
-    private static final Logger logger = LoggerFactory.getLogger(InteractionCreate.class);
-
-    private final FlagManager flagManager;
-
-    /**
-     * Creates a new interaction create handler owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public InteractionCreate(final Crabstero crabstero) {
-        this.flagManager = new FlagManager(crabstero);
-    }
-
-
-    /**
-     * Executes slash commands and responds to the users who run them.
-     * <p>
-     * All non-slash command interactions are ignored.
-     *
-     * @param event The event.
-     */
-    @Override
-    public void onInteractionCreate(final InteractionCreateEvent event) {
-        final Optional<SlashCommandInteraction> potentialCommandInteraction = event.getSlashCommandInteraction();
-
-        // Is this interaction not a slash command?
-        if (potentialCommandInteraction.isEmpty()) {
-            return; // Only slash commands are used, so ignore this interaction.
-        }
-
-        final SlashCommandInteraction interaction = potentialCommandInteraction.get();
-        final InteractionImmediateResponseBuilder response = interaction.createImmediateResponder();
-
-        final String commandName = interaction.getFullCommandName();
-
-        // Since access activity is involved, put all command execution in a try/catch so we always respond to the user if something bad happens.
-        try {
-            // `/pingme` command.
-            if (commandName.equalsIgnoreCase("pingme")) {
-                // Is this user opted in to receiving pings for mentions?
-                if (flagManager.isFlagSet(interaction.getUser(), ALLOW_PINGS_FLAG)) {
-                    // Yes. Revert their opt-in.
-                    flagManager.clearFlag(interaction.getUser(), ALLOW_PINGS_FLAG);
-                    response.setContent("I will no longer ping you for messages which mention you. If you decide to opt back in, run `/pingme` any time.");
-                } else {
-                    // No. Opt them in.
-                    flagManager.setFlag(interaction.getUser(), ALLOW_PINGS_FLAG);
-                    response.setContent("I will now ping you for messages which mention you. If you change your mind, run `/pingme` any time.");
-                }
-
-            } else {
-                // The only way I think this could be executed is if a new command is registered with the API in the Crabstero class, but this class isn't reflected to know it exists.
-                // As long as the Crabstero class and this class are in sync, I don't think this should ever happen.
-                logger.warn("Received slash command interaction for command '{}' which is not implemented!", commandName);
-                response.setContent("I don't know how to execute that command. Please contact the bot administrator as this shouldn't happen.");
-            }
-        } catch (Exception exception) {
-            logger.error("An exception occurred while attempting to execute slash command responder for command '{}'.", commandName, exception);
-            response.setContent("An error occurred while executing your command. Please try again later.");
-        }
-
-        // Make the slash command response only visible to the executor.
-        response.setFlags(MessageFlag.EPHEMERAL);
-
-        // Finally, fire off the response to the user!
-        response.respond();
-    }
-}

src/main/java/dev/logal/crabstero/listeners/MessageCreate.java

@@ -1,72 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.listeners;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.utils.MarkovChainMessages;
-import org.javacord.api.entity.channel.TextChannel;
-import org.javacord.api.entity.message.Message;
-import org.javacord.api.entity.message.MessageAuthor;
-import org.javacord.api.entity.message.MessageType;
-import org.javacord.api.event.message.MessageCreateEvent;
-import org.javacord.api.listener.message.MessageCreateListener;
-
-/**
- * Handles created messages.
- */
-public final class MessageCreate implements MessageCreateListener {
-    private final MarkovChainMessages markovChainMessages;
-
-    /**
-     * Creates a new message creation handler owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public MessageCreate(final Crabstero crabstero) {
-        this.markovChainMessages = new MarkovChainMessages(crabstero);
-    }
-
-    /**
-     * Responds to mentions and ingests normal text messages.
-     *
-     * @param event The event.
-     */
-    @Override
-    public void onMessageCreate(final MessageCreateEvent event) {
-        // Is this message being created outside a server text channel, a server thread channel, or a server voice channel?
-        final TextChannel channel = event.getChannel();
-        if (channel.asServerTextChannel().isEmpty() && channel.asServerThreadChannel().isEmpty() && channel.asServerVoiceChannel().isEmpty()) {
-            // Yes. Ignore it.
-            return;
-        }
-
-        // Is the user creating this message not a regular user or Crabstero itself?
-        final MessageAuthor author = event.getMessageAuthor();
-        if (!author.isRegularUser() || author.isYourself()) {
-            // Yes. Ignore it.
-            return;
-        }
-
-        // Is this message mentioning Crabstero?
-        final Message message = event.getMessage();
-        if (message.getMentionedUsers().contains(event.getApi().getYourself())) {
-            // Yes. Respond to it.
-            this.markovChainMessages.replyToMessage(message);
-
-            // Prevent further processing of the message.
-            return;
-        }
-
-        // Is this message a normal message outside of a server thread channel?
-        if (message.getType() == MessageType.NORMAL && channel.asServerThreadChannel().isEmpty()) {
-            // Yes. Ingest the message.
-            this.markovChainMessages.ingestMessage(message);
-        }
-    }
-}

src/main/java/dev/logal/crabstero/listeners/RoleChangePermissions.java

@@ -1,49 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.listeners;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.tasks.ChannelHistoryIngestionTask;
-import org.javacord.api.entity.channel.TextableRegularServerChannel;
-import org.javacord.api.event.server.role.RoleChangePermissionsEvent;
-import org.javacord.api.listener.server.role.RoleChangePermissionsListener;
-
-/**
- * Handles roles with changing permissions.
- */
-public final class RoleChangePermissions implements RoleChangePermissionsListener {
-    private final Crabstero crabstero;
-
-    /**
-     * Creates a new role change permission handler owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public RoleChangePermissions(final Crabstero crabstero) {
-        this.crabstero = crabstero;
-    }
-
-    /**
-     * Queues all text channels for message history ingestion when role permissions change.
-     *
-     * @param event The event.
-     */
-    @Override
-    public void onRoleChangePermissions(final RoleChangePermissionsEvent event) {
-        // Does the updated role include Crabstero as a member?
-        if (event.getRole().hasUser(event.getApi().getYourself())) {
-            // Queue every textable channel for message history ingestion.
-            event.getServer().getRegularChannels().forEach((channel) -> {
-                if (channel instanceof final TextableRegularServerChannel textableChannel) {
-                    this.crabstero.getWorkerPool().submit(new ChannelHistoryIngestionTask(textableChannel, crabstero));
-                }
-            });
-        }
-    }
-}

src/main/java/dev/logal/crabstero/listeners/ServerBecomesAvailable.java

@@ -1,46 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.listeners;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.tasks.ChannelHistoryIngestionTask;
-import org.javacord.api.entity.channel.TextableRegularServerChannel;
-import org.javacord.api.event.server.ServerBecomesAvailableEvent;
-import org.javacord.api.listener.server.ServerBecomesAvailableListener;
-
-/**
- * Handles when servers become available.
- */
-public final class ServerBecomesAvailable implements ServerBecomesAvailableListener {
-    private final Crabstero crabstero;
-
-    /**
-     * Creates a new server becoming available handler owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public ServerBecomesAvailable(final Crabstero crabstero) {
-        this.crabstero = crabstero;
-    }
-
-    /**
-     * Queues all textable channels for message history ingestion when a server becomes available.
-     *
-     * @param event The event.
-     */
-    @Override
-    public void onServerBecomesAvailable(final ServerBecomesAvailableEvent event) {
-        // Queue every textable channel for message history ingestion.
-        event.getServer().getRegularChannels().forEach((channel) -> {
-            if (channel instanceof final TextableRegularServerChannel textableChannel) {
-                this.crabstero.getWorkerPool().submit(new ChannelHistoryIngestionTask(textableChannel, crabstero));
-            }
-        });
-    }
-}

src/main/java/dev/logal/crabstero/listeners/ServerChannelChangeOverwrittenPermissions.java

@@ -1,46 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.listeners;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.tasks.ChannelHistoryIngestionTask;
-import org.javacord.api.entity.channel.TextableRegularServerChannel;
-import org.javacord.api.event.channel.server.ServerChannelChangeOverwrittenPermissionsEvent;
-import org.javacord.api.listener.channel.server.ServerChannelChangeOverwrittenPermissionsListener;
-
-/**
- * Handles channels with changing overwritten permissions.
- */
-public final class ServerChannelChangeOverwrittenPermissions implements ServerChannelChangeOverwrittenPermissionsListener {
-    private final Crabstero crabstero;
-
-    /**
-     * Creates a new server channel changing overwritten permissions handler owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public ServerChannelChangeOverwrittenPermissions(final Crabstero crabstero) {
-        this.crabstero = crabstero;
-    }
-
-    /**
-     * Queues all text channels for message history ingestion when channel override permissions change.
-     *
-     * @param event The event.
-     */
-    @Override
-    public void onServerChannelChangeOverwrittenPermissions(final ServerChannelChangeOverwrittenPermissionsEvent event) {
-        // Queue every textable channel for message history ingestion.
-        event.getServer().getRegularChannels().forEach((channel) -> {
-            if (channel instanceof final TextableRegularServerChannel textableChannel) {
-                this.crabstero.getWorkerPool().submit(new ChannelHistoryIngestionTask(textableChannel, crabstero));
-            }
-        });
-    }
-}

src/main/java/dev/logal/crabstero/listeners/ServerJoin.java

@@ -1,72 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.listeners;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.tasks.ChannelHistoryIngestionTask;
-import org.javacord.api.entity.channel.TextableRegularServerChannel;
-import org.javacord.api.entity.message.embed.EmbedBuilder;
-import org.javacord.api.entity.server.Server;
-import org.javacord.api.event.server.ServerJoinEvent;
-import org.javacord.api.listener.server.ServerJoinListener;
-import org.javacord.api.util.logging.ExceptionLogger;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.awt.Color;
-
-/**
- * Handles joining new servers.
- */
-public final class ServerJoin implements ServerJoinListener {
-    private static final Logger logger = LoggerFactory.getLogger(ServerJoin.class);
-
-    private final Crabstero crabstero;
-
-    /**
-     * Creates a new server join handler owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public ServerJoin(final Crabstero crabstero) {
-        this.crabstero = crabstero;
-    }
-
-    /**
-     * Queues all text channels for message history ingestion when joining a new server.
-     *
-     * @param event The event.
-     */
-    @Override
-    public void onServerJoin(final ServerJoinEvent event) {
-        // Log the server join.
-        final Server server = event.getServer();
-        logger.info("Joined new server! (Name: \"" + server.getName() + "\" | ID: " + server.getIdAsString() + ")");
-
-        // Start building an embed with basic server information.
-        final EmbedBuilder embed = new EmbedBuilder();
-        embed.setTitle("Joined New Server");
-        embed.setColor(new Color(255, 165, 0));
-        embed.addField(server.getName() + " (" + server.getIdAsString() + ")", server.getMemberCount() + " members");
-        server.getIcon().ifPresent((icon) -> embed.setImage(icon.getUrl().toString()));
-
-        // Add the current total server count.
-        embed.setFooter(event.getApi().getServers().size() + " total servers");
-
-        // Send this embed to the bot owner.
-        event.getApi().getOwner().ifPresent((owner) -> owner.thenAcceptAsync((user) -> user.sendMessage(embed).exceptionally(ExceptionLogger.get())));
-
-        // Queue every textable channel for message history ingestion.
-        event.getServer().getRegularChannels().forEach((channel) -> {
-            if (channel instanceof final TextableRegularServerChannel textableChannel) {
-                this.crabstero.getWorkerPool().submit(new ChannelHistoryIngestionTask(textableChannel, crabstero));
-            }
-        });
-    }
-}

src/main/java/dev/logal/crabstero/listeners/UserRoleAdd.java

@@ -1,49 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.listeners;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.tasks.ChannelHistoryIngestionTask;
-import org.javacord.api.entity.channel.TextableRegularServerChannel;
-import org.javacord.api.event.server.role.UserRoleAddEvent;
-import org.javacord.api.listener.server.role.UserRoleAddListener;
-
-/**
- * Handles when roles are added to users.
- */
-public final class UserRoleAdd implements UserRoleAddListener {
-    private final Crabstero crabstero;
-
-    /**
-     * Creates a new user role add handler owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public UserRoleAdd(final Crabstero crabstero) {
-        this.crabstero = crabstero;
-    }
-
-    /**
-     * Queues all text channels for message history ingestion when added to a new role.
-     *
-     * @param event The event.
-     */
-    @Override
-    public void onUserRoleAdd(final UserRoleAddEvent event) {
-        // Is the user who was assigned the role Crabstero?
-        if (event.getUser().isYourself()) {
-            // Queue every textable channel for message history ingestion.
-            event.getServer().getRegularChannels().forEach((channel) -> {
-                if (channel instanceof final TextableRegularServerChannel textableChannel) {
-                    this.crabstero.getWorkerPool().submit(new ChannelHistoryIngestionTask(textableChannel, crabstero));
-                }
-            });
-        }
-    }
-}

src/main/java/dev/logal/crabstero/tasks/ChannelHistoryIngestionTask.java

@@ -1,99 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.tasks;
-
-import dev.logal.crabstero.Crabstero;
-import dev.logal.crabstero.utils.MarkovChainMessages;
-import org.javacord.api.entity.channel.TextableRegularServerChannel;
-import org.javacord.api.entity.message.Message;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import redis.clients.jedis.Jedis;
-
-import java.util.Iterator;
-import java.util.stream.Stream;
-
-/**
- * Bulk-ingests the message history of a channel.
- */
-public final class ChannelHistoryIngestionTask implements Runnable {
-    private static final String INGESTED_CHANNELS_KEY = "ingestedChannels"; // Key in redis for storing the IDs of channels which have been ingested.
-    private static final int MAXIMUM_MESSAGES_PER_CHANNEL = 50000; // The maximum amount of historical messages to ingest per channel.
-
-    private static final Logger logger = LoggerFactory.getLogger(ChannelHistoryIngestionTask.class);
-
-    private final Crabstero crabstero;
-    private final TextableRegularServerChannel channel;
-
-    /**
-     * Creates a new task for ingesting the message history of a textable channel.
-     *
-     * @param channel   The channel to ingest.
-     * @param crabstero The Crabstero instance running this task.
-     */
-    public ChannelHistoryIngestionTask(final TextableRegularServerChannel channel, final Crabstero crabstero) {
-        this.channel = channel;
-        this.crabstero = crabstero;
-    }
-
-    /**
-     * Runs the task. The task will be ended early if permissions do not allow ingesting this channel or if it has already been ingested in the past.
-     */
-    @Override
-    public void run() {
-        try {
-            // Do permissions allow Crabstero to read message history in this channel?
-            if (!this.channel.canYouReadMessageHistory()) {
-                // No. Log the problem and stop further processing this channel.
-                logger.warn("[" + this.channel.getIdAsString() + "] Unable to ingest textable channel history due to lacking permissions. Ignoring.");
-                return;
-            }
-
-            try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-                // Have we already ingested this channel before?
-                if (jedis.lrange(INGESTED_CHANNELS_KEY, 0, -1).contains(this.channel.getIdAsString())) {
-                    // Yes. Stop further processing of this channel.
-                    return;
-                } else {
-                    // No. Add this channel's ID to the list of ingested channels.
-                    jedis.lpush(INGESTED_CHANNELS_KEY, this.channel.getIdAsString());
-
-                    // Log the start of the ingestion of this channel.
-                    logger.info("[" + this.channel.getIdAsString() + "] Starting ingestion of textable channel history.");
-                }
-            }
-
-            final MarkovChainMessages markovChainMessages = new MarkovChainMessages(this.crabstero);
-            // Start streaming messages in this channel from newest to oldest.
-            try (final Stream<Message> history = this.channel.getMessagesAsStream()) {
-                final Iterator<Message> iterator = history.iterator();
-                int i = 0;
-                // While the stream still has messages...
-                while (iterator.hasNext()) {
-                    i++;
-
-                    //Ingest the message.
-                    markovChainMessages.ingestMessage(iterator.next());
-
-                    // Have we reached the maximum amount of messages to ingest per channel?
-                    if (i >= MAXIMUM_MESSAGES_PER_CHANNEL) {
-                        // Yes. Stop ingesting.
-                        break;
-                    }
-                }
-
-                // Log the results of the ingestion.
-                logger.info("[" + this.channel.getIdAsString() + "] Ingestion of textable channel history complete. " + i + " messages ingested.");
-            }
-        } catch (final Throwable exception) {
-            // A problem occurred somewhere in this task. Log the problem.
-            logger.error("[" + this.channel.getIdAsString() + "] An error occurred while ingesting textable channel history!", exception);
-        }
-    }
-}

src/main/java/dev/logal/crabstero/utils/FlagManager.java

@@ -1,171 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.utils;
-
-import dev.logal.crabstero.Crabstero;
-import org.javacord.api.entity.channel.TextChannel;
-import org.javacord.api.entity.server.Server;
-import org.javacord.api.entity.user.User;
-import redis.clients.jedis.Jedis;
-
-/**
- * Provides ability to set and check for flags on text channels, servers, and users.
- */
-public class FlagManager {
-    public static final String CHANNEL_DB_PREFIX = "";
-    public static final String SERVER_DB_PREFIX = "s";
-    public static final String USER_DB_PREFIX = "u";
-
-    private final Crabstero crabstero; // The Crabstero instance using this configuration manager.
-
-    /**
-     * Creates a new configuration manager owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public FlagManager(final Crabstero crabstero) {
-        this.crabstero = crabstero;
-    }
-
-    /**
-     * Sets a flag of a given name on a given ID in the namespace of a prefix.
-     * This should only be used if only an ID is known instead of a reference to a more abstract object.
-     *
-     * @param prefix The prefix.
-     * @param ID     The ID of the entity within that prefix namespace to set the flag on.
-     * @param flag   The flag to set.
-     */
-    public void setFlag(final String prefix, final String ID, final String flag) {
-        try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-            jedis.set(prefix + ID + ":flags:" + flag, "");
-        }
-    }
-
-    /**
-     * Sets a flag of a given name on the given text channel.
-     *
-     * @param channel The text channel to set the flag on.
-     * @param flag    The name of the flag to set.
-     */
-    public void setFlag(final TextChannel channel, String flag) {
-        this.setFlag(CHANNEL_DB_PREFIX, channel.getIdAsString(), flag);
-    }
-
-    /**
-     * Sets a flag of a given name on the given server.
-     *
-     * @param server The server to set the flag on.
-     * @param flag   The name of the flag to set.
-     */
-    public void setFlag(final Server server, String flag) {
-        this.setFlag(SERVER_DB_PREFIX, server.getIdAsString(), flag);
-    }
-
-    /**
-     * Sets a flag of a given name on the given user.
-     *
-     * @param user The user to set the flag on.
-     * @param flag The name of the flag to set.
-     */
-    public void setFlag(final User user, String flag) {
-        this.setFlag(USER_DB_PREFIX, user.getIdAsString(), flag);
-    }
-
-    /**
-     * Clears the flag of a given name on a given ID in the namespace of a prefix.
-     * This should only be used if only an ID is known instead of a reference to a more abstract object.
-     *
-     * @param prefix The prefix.
-     * @param ID     The ID of the entity within that prefix namespace to clear the flag on.
-     * @param flag   The name of the flag to clear.
-     */
-    public void clearFlag(final String prefix, final String ID, final String flag) {
-        try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-            jedis.del(prefix + ID + ":flags:" + flag);
-        }
-    }
-
-    /**
-     * Clears the flag of a given name on the given text channel.
-     *
-     * @param channel The text channel to clear the flag on.
-     * @param flag    The name of the flag to clear.
-     */
-    public void clearFlag(final TextChannel channel, String flag) {
-        this.clearFlag(CHANNEL_DB_PREFIX, channel.getIdAsString(), flag);
-    }
-
-    /**
-     * Clears the flag of a given name on the given server.
-     *
-     * @param server The server to clear the flag on.
-     * @param flag   The name of the flag to clear.
-     */
-    public void clearFlag(final Server server, String flag) {
-        this.clearFlag(SERVER_DB_PREFIX, server.getIdAsString(), flag);
-    }
-
-    /**
-     * Clears the flag of a given name on the given user.
-     *
-     * @param user The user to clear the flag on.
-     * @param flag The name of the flag to clear.
-     */
-    public void clearFlag(final User user, String flag) {
-        this.clearFlag(USER_DB_PREFIX, user.getIdAsString(), flag);
-    }
-
-    /**
-     * Checks whether a flag of a given name is set on a given ID in the namespace of a prefix.
-     * This should only be used if only an ID is known instead of a reference to a more abstract object.
-     *
-     * @param prefix The prefix.
-     * @param ID     The ID of the entity within that prefix namespace to check on.
-     * @param flag   The name of the flag to check for.
-     * @return A boolean indicating whether the flag is set.
-     */
-    public boolean isFlagSet(final String prefix, final String ID, final String flag) {
-        try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-            return jedis.exists(prefix + ID + ":flags:" + flag);
-        }
-    }
-
-    /**
-     * Checks whether a flag of a given name is set on a given text channel.
-     *
-     * @param channel The text channel to check on.
-     * @param flag    The name of the flag to check for.
-     * @return A boolean indicating whether the flag is set.
-     */
-    public boolean isFlagSet(final TextChannel channel, String flag) {
-        return this.isFlagSet(CHANNEL_DB_PREFIX, channel.getIdAsString(), flag);
-    }
-
-    /**
-     * Checks whether a flag of a given name is set on a given server.
-     *
-     * @param server The server to check on.
-     * @param flag   The name of the flag to check for.
-     * @return A boolean indicating whether the flag is set.
-     */
-    public boolean isFlagSet(final Server server, String flag) {
-        return this.isFlagSet(SERVER_DB_PREFIX, server.getIdAsString(), flag);
-    }
-
-    /**
-     * Checks whether a flag of a given name is set on a given user.
-     *
-     * @param user The user to check on.
-     * @param flag The name of the flag to check for.
-     * @return A boolean indicating whether the flag is set.
-     */
-    public boolean isFlagSet(final User user, String flag) {
-        return this.isFlagSet(USER_DB_PREFIX, user.getIdAsString(), flag);
-    }
-}

src/main/java/dev/logal/crabstero/utils/MarkovChain.java

@@ -1,231 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.utils;
-
-import dev.logal.crabstero.Crabstero;
-import redis.clients.jedis.Jedis;
-import redis.clients.jedis.Pipeline;
-
-import java.security.SecureRandom;
-import java.util.List;
-import java.util.Random;
-
-/**
- * Ingests sentences and generates new ones using a Markov chain with a Redis storage.
- */
-public final class MarkovChain {
-    private static final char DEFAULT_SENTENCE_END = '§'; // Default character to end sentences with if it does not include a period, exclamation mark, or question mark.
-
-    private final long id; // A unique number for this Markov chain to segment it away from other Markov chains. This is usually the channel ID given by Discord.
-    private final Crabstero crabstero; // The Crabstero instance using this Markov chain.
-    private final Random rng; // A source of randomness.
-
-    /**
-     * Creates a new Markov chain identified by a given number and owned by a given instance of Crabstero.
-     *
-     * @param id        The unique number.
-     * @param crabstero The instance of Crabstero.
-     */
-    public MarkovChain(final long id, final Crabstero crabstero) {
-        this.id = id;
-        this.crabstero = crabstero;
-        this.rng = new SecureRandom(); // Probably placebo effect, but SecureRandom seems to produce better results.
-    }
-
-    /**
-     * Creates a new Markov chain identified by a given number, owned by a given instance of Crabstero, and using a custom source of randomness.
-     *
-     * @param id        The unique number.
-     * @param crabstero The instance of Crabstero.
-     * @param random    The custom randomness source.
-     */
-    public MarkovChain(final long id, final Crabstero crabstero, final Random random) {
-        this.id = id;
-        this.crabstero = crabstero;
-        this.rng = random;
-    }
-
-    /**
-     * Checks whether a given sentence ends with a default sentence end character, a period, an exclamation mark, or a question mark.
-     *
-     * @param sentence The sentence to test.
-     * @return True if the sentence ends with a default sentence end character, a period, an exclamation mark, or a question mark, false otherwise.
-     */
-    private static boolean isCompleteSentence(final String sentence) {
-        // Is the given sentence an empty string?
-        if (sentence.isEmpty()) {
-            // Yes. Therefor, it is not a complete sentence.
-            return false;
-        }
-
-        // Get the last character of the given sentence.
-        final char lastChar = sentence.charAt(sentence.length() - 1);
-
-        // Return true if th character is a default sentence end character, a period, an exclamation mark, or a question mark.
-        return (lastChar == DEFAULT_SENTENCE_END || lastChar == '.' || lastChar == '!' || lastChar == '?');
-    }
-
-    /**
-     * Ingests a string potentially containing multiple smaller sentences.
-     *
-     * @param paragraph The paragraph of sentences to ingest.
-     */
-    public void ingest(String paragraph) {
-        // Is the given paragraph as a whole complete?
-        if (!isCompleteSentence(paragraph)) {
-            // No. Add DEFAULT_SENTENCE_END to the end.
-            paragraph += DEFAULT_SENTENCE_END;
-        }
-
-        // First, trim all leading and trailing spaces.
-        // Next, replace repeated spaces with a single space.
-        // Then, replace new lines with spaces.
-        // Finally, split the paragraph into a string array with each element being a single sentence.
-        final String[] sentences = paragraph.trim().replaceAll(" +", " ").replaceAll("\n", " ").split("(?<=[.!?]) ");
-
-        // Ingest each sentence individually.
-        for (String sentence : sentences) {
-            this.ingestSentence(sentence);
-        }
-    }
-
-    /**
-     * Ingests a string containing a single sentence.
-     *
-     * @param sentence The sentence to ingest.
-     */
-    private void ingestSentence(String sentence) {
-        // Is the given sentence complete?
-        if (!isCompleteSentence(sentence)) {
-            // No. Add DEFAULT_SENTENCE_END to the end.
-            sentence += DEFAULT_SENTENCE_END;
-        }
-
-        // First, trim all leading and trailing spaces.
-        // Next, replace repeated spaces with a single space.
-        // Finally, split the sentence into a string array with each element being a word.
-        String[] words = sentence.trim().replaceAll(" +", " ").split(" ");
-
-        // Get a reference to Jedis from the pool.
-        try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-            // Use a pipeline to avoid blocking caused by waiting for responses from the Redis server.
-            final Pipeline pipeline = jedis.pipelined();
-
-            // Iterate over the array of words, starting from the first element until the second to last element.
-            for (int i = 0; i < words.length - 1; i++) {
-                // Is this the first word?
-                if (i == 0) {
-                    // Yes. Push the word into a special list containing starting words.
-                    pipeline.lpush(this.id + ":start", words[i]);
-                }
-
-                // Push the word after this one into a list identified by this word.
-                pipeline.lpush(this.id + "::" + words[i], words[i + 1]);
-            }
-        }
-    }
-
-    /**
-     * Generates a new sentence using word learned from previously ingested sentences.
-     *
-     * @param softCharacterLimit The amount of characters to try and limit sentence length around.
-     * @param hardCharacterLimit The amount of characters to cut off the sentence at if it gets too long.
-     * @return A new sentence.
-     */
-    public String generate(final int softCharacterLimit, final int hardCharacterLimit) {
-        // Declare a new builder for building the new sentence.
-        final StringBuilder newSentence = new StringBuilder();
-
-        // Get a reference to Jedis from the pool.
-        try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-            // Does this Markov chain have any starting words?
-            if (!jedis.exists(this.id + ":start")) {
-                // No. Quickly ingest something to avoid throwing an error.
-                // TODO: Could this soft lock since a reference to the jedis pool is already held?
-                this.ingestSentence("Hello world!");
-            }
-
-            // Declare a variable for holding the word about to be added to the new sentence.
-            String word;
-
-            // Get a list of all starting words.
-            final List<String> startingWords = jedis.lrange(this.id + ":start", 0, -1);
-
-            // Pick a random index for a starting word.
-            int index = rng.nextInt(startingWords.size());
-
-            // Get the word.
-            word = startingWords.get(index);
-
-            // Add it to the output sentence.
-            newSentence.append(word);
-
-            // While the selected word is in complete...
-            // Although quite rare, this loop will skip if the starting word is already complete on its own (e.g. "Yes.")
-            while (!isCompleteSentence(word)) {
-                // Get the list of words which can be added after the previous word.
-                final List<String> wordChoices = jedis.lrange(this.id + "::" + word, 0, -1);
-
-                // Reset the index.
-                index = -1;
-
-                // Is the new sentence length above the soft character limit?
-                if (newSentence.length() >= softCharacterLimit) {
-                    // Yes. Time to aggressively search for words which can complete this sentence.
-
-                    // Iterate over the word choices.
-                    for (int i = 0; i < wordChoices.size(); i++) {
-                        // Get current candidate word.
-                        final String candidate = wordChoices.get(i);
-
-                        // Does this word conclude the sentence?
-                        if (isCompleteSentence(candidate)) {
-                            // Select the index for this word and stop evaluating choices.
-                            index = i;
-                            break;
-                        }
-                    }
-
-                    // Was no word to conclude the new sentence found?
-                    if (index == -1) {
-                        // Yes. Pick a random word and hope the next word can conclude it.
-                        index = rng.nextInt(wordChoices.size());
-                    }
-                } else {
-                    // No, there is still room. Pick a random index.
-                    index = rng.nextInt(wordChoices.size());
-                }
-
-                // Get the selected word.
-                word = wordChoices.get(index);
-
-                // Append a space and this word to the new sentence.
-                newSentence.append(" ").append(word);
-
-                // Is the new sentence now longer than the hard character limit?
-                final int sentenceLength = newSentence.length();
-                if (sentenceLength >= hardCharacterLimit) {
-                    // Yes. Chop off the characters beyond the hard limit.
-                    newSentence.delete(hardCharacterLimit, sentenceLength);
-                    // Break out of the loop to forcefully declare the new sentence complete.
-                    break;
-                }
-            }
-        }
-
-        // Is the last character of the new sentence the default sentence end character?
-        if (newSentence.charAt(newSentence.length() - 1) == DEFAULT_SENTENCE_END) {
-            // Yes. Get a rid of it. The default sentence end character is meant to internally mark the end of sentences which did not include a punctuation mark, as is common on Discord.
-            return newSentence.deleteCharAt(newSentence.length() - 1).toString();
-        } else {
-            // No. Return the new sentence as is.
-            return newSentence.toString();
-        }
-    }
-}

src/main/java/dev/logal/crabstero/utils/MarkovChainMessages.java

@@ -1,200 +0,0 @@
-/*
- * Copyright 2024 Logan Fick
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-
-package dev.logal.crabstero.utils;
-
-import dev.logal.crabstero.Crabstero;
-import org.javacord.api.entity.channel.TextChannel;
-import org.javacord.api.entity.message.Message;
-import org.javacord.api.entity.message.MessageAuthor;
-import org.javacord.api.entity.message.MessageBuilder;
-import org.javacord.api.entity.message.embed.Embed;
-import org.javacord.api.entity.message.embed.EmbedBuilder;
-import org.javacord.api.entity.message.mention.AllowedMentionsBuilder;
-import org.javacord.api.util.logging.ExceptionLogger;
-import redis.clients.jedis.Jedis;
-
-import java.security.SecureRandom;
-import java.util.List;
-import java.util.Random;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Assists with generating Discord messages in response to other users and ingesting raw messages.
- */
-public class MarkovChainMessages {
-    private static final String NO_REPLY_FLAG = "noReply";
-    private static final String NO_INGEST_FLAG = "noIngest";
-    private static final String ALLOW_PINGS_FLAG = "allowPings";
-    private static final String USER_WITH_OPTIONAL_NICKNAME_REGEX = "<@!?(?<id>\\d{17,20})>"; // Copied from discordjs/discord-api-types: https://github.com/discordjs/discord-api-types/blob/7fe434114e91c80ed79f0204ae6c73047672d55d/globals.ts#L30
-
-    private final Crabstero crabstero;
-    private final FlagManager flagManager;
-    private final Pattern mentionPattern;
-    private final Random rng = new SecureRandom();
-
-    /**
-     * Creates a new Markov Chain message assistant owned by a given instance of Crabstero.
-     *
-     * @param crabstero The instance of Crabstero.
-     */
-    public MarkovChainMessages(final Crabstero crabstero) {
-        this.crabstero = crabstero;
-        this.flagManager = new FlagManager(crabstero);
-
-        this.mentionPattern = Pattern.compile(USER_WITH_OPTIONAL_NICKNAME_REGEX);
-    }
-
-    /**
-     * Sends a new message in Discord in response to a given message.
-     *
-     * @param message The message prompting the response.
-     */
-    public void replyToMessage(final Message message) {
-        final TextChannel channel = message.getChannel();
-
-        // Does Crabstero have permissions to write to the channel the message was sent in?
-        if (!channel.canYouWrite()) {
-            // No. Give up.
-            return;
-        }
-
-        // Is a flag set on the text channel or server this message was sent in or the user who sent the message to prevent replying?
-        // TODO: The blind get()s are safe for now as MessageCreate does the necessary checks, but this could be done better.
-        if (flagManager.isFlagSet(channel, NO_REPLY_FLAG) ||
-                flagManager.isFlagSet(message.getServer().get(), NO_REPLY_FLAG) ||
-                flagManager.isFlagSet(message.getAuthor().asUser().get(), NO_REPLY_FLAG)) {
-            // Yes, don't reply.
-            return;
-        }
-
-        final long channelID;
-        // Is this channel a thread?
-        if (channel.asServerThreadChannel().isPresent()) {
-            // Yes. Store the ID of the parent channel for this thread.
-            channelID = channel.asServerThreadChannel().get().getParent().getId();
-        } else {
-            // No. Store the ID of the channel the message was sent in.
-            channelID = channel.getId();
-        }
-
-        final MessageBuilder response = new MessageBuilder();
-        final MarkovChain markovChain = new MarkovChain(channelID, this.crabstero);
-
-        // Tell Discord which message Crabstero is replying to
-        response.replyTo(message);
-
-        // Generate a new body.
-        final String body = markovChain.generate(750, 1000);
-        response.setContent(body);
-
-        // Was a random number greater than 0.95 (5% of the time) and does Crabstero have permission to use embeds in this channel?
-        if (this.rng.nextDouble() >= 0.95 && channel.canYouEmbedLinks()) {
-            // Yes. Generate an embed with a random title and description.
-            final EmbedBuilder embed = new EmbedBuilder();
-            embed.setTitle(markovChain.generate(200, 300));
-            embed.setDescription(markovChain.generate(300, 500));
-
-            // If image URLs are known for this channel, chose a random one and attach to the embed.
-            try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-                final List<String> embedImageURLs = jedis.lrange(channelID + ":images", 0, -1);
-
-                if (!embedImageURLs.isEmpty()) {
-                    embed.setImage(embedImageURLs.get(this.rng.nextInt(embedImageURLs.size())));
-                }
-            }
-
-            // Attach the embed to the response.
-            response.setEmbed(embed);
-        }
-
-        // Build an allowed mentions filter which, by default, does not allow mentions in the response to generate pings.
-        final AllowedMentionsBuilder builder = new AllowedMentionsBuilder();
-        builder.setMentionEveryoneAndHere(false);
-        builder.setMentionRoles(false);
-        builder.setMentionUsers(false);
-
-        // Search for mentions in the generated body sentence.
-        Matcher mentionMatcher = mentionPattern.matcher(body);
-
-        // For each detected mention in the body sentence...
-        while (mentionMatcher.find()) {
-            // Get the user ID from the mention
-            String id = mentionMatcher.group("id");
-
-            // Did this mentioned user opt into receiving pings for mentions?
-            if (this.flagManager.isFlagSet(FlagManager.USER_DB_PREFIX, id, ALLOW_PINGS_FLAG)) {
-                builder.addUser(id); // Add the user to the filter to allow a ping to generate.
-            }
-        }
-
-        // Attach the final allowed mentions filter to the response.
-        response.setAllowedMentions(builder.build());
-
-        // Send the response.
-        response.send(channel).exceptionally(ExceptionLogger.get());
-    }
-
-    /**
-     * Ingests a given message into its channel's Markov chain.
-     *
-     * @param message The message to ingest.
-     */
-    public void ingestMessage(final Message message) {
-        final MessageAuthor author = message.getAuthor();
-        // Is the author of the message not a regular user or mentioning Crabstero?
-        if (!author.isRegularUser() || message.getMentionedUsers().contains(message.getApi().getYourself())) {
-            // Yes. Ignore it.
-            return;
-        }
-
-        // Is a flag set on the text channel or server this message was sent in or the user who sent the message to prevent ingestion?
-        // TODO: The blind get()s are safe for now as MessageCreate does the necessary checks, but this could be done better.
-        if (flagManager.isFlagSet(message.getChannel(), NO_INGEST_FLAG) ||
-                flagManager.isFlagSet(message.getServer().get(), NO_INGEST_FLAG) ||
-                flagManager.isFlagSet(message.getAuthor().asUser().get(), NO_INGEST_FLAG)) {
-            // Yes, don't reply.
-            return;
-        }
-
-        // Get the Markov chain for the message's text channel.
-        final long channelID = message.getChannel().getId();
-        final MarkovChain markovChain = new MarkovChain(channelID, this.crabstero);
-
-        // Ingest the message content into the Markov chain.
-        markovChain.ingest(message.getContent());
-
-        // If the message has embeds, ingest each one individually.
-        for (final Embed embed : message.getEmbeds()) {
-            ingestEmbed(channelID, embed);
-        }
-    }
-
-    /**
-     * Ingests a given embed into a given channel's Markov chain.
-     *
-     * @param channelID The ID of the channel to use for the Markov Chain.
-     * @param embed     The embed to ingest.
-     */
-    private void ingestEmbed(final long channelID, final Embed embed) {
-        // Get the Markov chain for the given channel ID.
-        final MarkovChain markovChain = new MarkovChain(channelID, this.crabstero);
-
-        // If the embed has a title or description, ingest each one separately.
-        embed.getTitle().ifPresent(markovChain::ingest);
-        embed.getDescription().ifPresent(markovChain::ingest);
-
-        // If the embed has an image, store the URL to the image.
-        embed.getImage().ifPresent((image) -> {
-            try (final Jedis jedis = this.crabstero.getJedisPool().getResource()) {
-                jedis.lpush(channelID + ":images", image.getUrl().toString());
-            }
-        });
-    }
-}

uv.lock

@@ -0,0 +1,510 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" },
+    { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" },
+    { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" },
+    { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" },
+    { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" },
+    { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" },
+    { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" },
+    { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" },
+    { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" },
+    { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" },
+    { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" },
+    { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" },
+    { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "aiosqlite"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/8a/64761f4005f17809769d23e518d915db74e6310474e733e3593cfc854ef1/aiosqlite-0.22.1.tar.gz", hash = "sha256:043e0bd78d32888c0a9ca90fc788b38796843360c855a7262a532813133a0650", size = 14821, upload-time = "2025-12-23T19:25:43.997Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/b7/e3bf5133d697a08128598c8d0abc5e16377b51465a33756de24fa7dee953/aiosqlite-0.22.1-py3-none-any.whl", hash = "sha256:21c002eb13823fad740196c5a2e9d8e62f6243bd9e7e4a1f87fb5e44ecb4fceb", size = 17405, upload-time = "2025-12-23T19:25:42.139Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "audioop-lts"
+version = "0.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/53/946db57842a50b2da2e0c1e34bd37f36f5aadba1a929a3971c5d7841dbca/audioop_lts-0.2.2.tar.gz", hash = "sha256:64d0c62d88e67b98a1a5e71987b7aa7b5bcffc7dcee65b635823dbdd0a8dbbd0", size = 30686, upload-time = "2025-08-05T16:43:17.409Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/d4/94d277ca941de5a507b07f0b592f199c22454eeaec8f008a286b3fbbacd6/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd3d4602dc64914d462924a08c1a9816435a2155d74f325853c1f1ac3b2d9800", size = 46523, upload-time = "2025-08-05T16:42:20.836Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/5a/656d1c2da4b555920ce4177167bfeb8623d98765594af59702c8873f60ec/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:550c114a8df0aafe9a05442a1162dfc8fec37e9af1d625ae6060fed6e756f303", size = 27455, upload-time = "2025-08-05T16:42:22.283Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/83/ea581e364ce7b0d41456fb79d6ee0ad482beda61faf0cab20cbd4c63a541/audioop_lts-0.2.2-cp313-abi3-macosx_11_0_arm64.whl", hash = "sha256:9a13dc409f2564de15dd68be65b462ba0dde01b19663720c68c1140c782d1d75", size = 26997, upload-time = "2025-08-05T16:42:23.849Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/3b/e8964210b5e216e5041593b7d33e97ee65967f17c282e8510d19c666dab4/audioop_lts-0.2.2-cp313-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51c916108c56aa6e426ce611946f901badac950ee2ddaf302b7ed35d9958970d", size = 85844, upload-time = "2025-08-05T16:42:25.208Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2e/0a1c52faf10d51def20531a59ce4c706cb7952323b11709e10de324d6493/audioop_lts-0.2.2-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47eba38322370347b1c47024defbd36374a211e8dd5b0dcbce7b34fdb6f8847b", size = 85056, upload-time = "2025-08-05T16:42:26.559Z" },
+    { url = "https://files.pythonhosted.org/packages/75/e8/cd95eef479656cb75ab05dfece8c1f8c395d17a7c651d88f8e6e291a63ab/audioop_lts-0.2.2-cp313-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba7c3a7e5f23e215cb271516197030c32aef2e754252c4c70a50aaff7031a2c8", size = 93892, upload-time = "2025-08-05T16:42:27.902Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/1e/a0c42570b74f83efa5cca34905b3eef03f7ab09fe5637015df538a7f3345/audioop_lts-0.2.2-cp313-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def246fe9e180626731b26e89816e79aae2276f825420a07b4a647abaa84becc", size = 96660, upload-time = "2025-08-05T16:42:28.9Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d5/8a0ae607ca07dbb34027bac8db805498ee7bfecc05fd2c148cc1ed7646e7/audioop_lts-0.2.2-cp313-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e160bf9df356d841bb6c180eeeea1834085464626dc1b68fa4e1d59070affdc3", size = 79143, upload-time = "2025-08-05T16:42:29.929Z" },
+    { url = "https://files.pythonhosted.org/packages/12/17/0d28c46179e7910bfb0bb62760ccb33edb5de973052cb2230b662c14ca2e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4b4cd51a57b698b2d06cb9993b7ac8dfe89a3b2878e96bc7948e9f19ff51dba6", size = 84313, upload-time = "2025-08-05T16:42:30.949Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ba/bd5d3806641564f2024e97ca98ea8f8811d4e01d9b9f9831474bc9e14f9e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4a53aa7c16a60a6857e6b0b165261436396ef7293f8b5c9c828a3a203147ed4a", size = 93044, upload-time = "2025-08-05T16:42:31.959Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/5e/435ce8d5642f1f7679540d1e73c1c42d933331c0976eb397d1717d7f01a3/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:3fc38008969796f0f689f1453722a0f463da1b8a6fbee11987830bfbb664f623", size = 78766, upload-time = "2025-08-05T16:42:33.302Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3b/b909e76b606cbfd53875693ec8c156e93e15a1366a012f0b7e4fb52d3c34/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_s390x.whl", hash = "sha256:15ab25dd3e620790f40e9ead897f91e79c0d3ce65fe193c8ed6c26cffdd24be7", size = 87640, upload-time = "2025-08-05T16:42:34.854Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e7/8f1603b4572d79b775f2140d7952f200f5e6c62904585d08a01f0a70393a/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:03f061a1915538fd96272bac9551841859dbb2e3bf73ebe4a23ef043766f5449", size = 86052, upload-time = "2025-08-05T16:42:35.839Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/96/c37846df657ccdda62ba1ae2b6534fa90e2e1b1742ca8dcf8ebd38c53801/audioop_lts-0.2.2-cp313-abi3-win32.whl", hash = "sha256:3bcddaaf6cc5935a300a8387c99f7a7fbbe212a11568ec6cf6e4bc458c048636", size = 26185, upload-time = "2025-08-05T16:42:37.04Z" },
+    { url = "https://files.pythonhosted.org/packages/34/a5/9d78fdb5b844a83da8a71226c7bdae7cc638861085fff7a1d707cb4823fa/audioop_lts-0.2.2-cp313-abi3-win_amd64.whl", hash = "sha256:a2c2a947fae7d1062ef08c4e369e0ba2086049a5e598fda41122535557012e9e", size = 30503, upload-time = "2025-08-05T16:42:38.427Z" },
+    { url = "https://files.pythonhosted.org/packages/34/25/20d8fde083123e90c61b51afb547bb0ea7e77bab50d98c0ab243d02a0e43/audioop_lts-0.2.2-cp313-abi3-win_arm64.whl", hash = "sha256:5f93a5db13927a37d2d09637ccca4b2b6b48c19cd9eda7b17a2e9f77edee6a6f", size = 24173, upload-time = "2025-08-05T16:42:39.704Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/73/413b5a2804091e2c7d5def1d618e4837f1cb82464e230f827226278556b7/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f9ee9b52f5f857fbaf9d605a360884f034c92c1c23021fb90b2e39b8e64bede6", size = 47104, upload-time = "2025-08-05T16:42:58.518Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8c/daa3308dc6593944410c2c68306a5e217f5c05b70a12e70228e7dd42dc5c/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:49ee1a41738a23e98d98b937a0638357a2477bc99e61b0f768a8f654f45d9b7a", size = 27754, upload-time = "2025-08-05T16:43:00.132Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/86/c2e0f627168fcf61781a8f72cab06b228fe1da4b9fa4ab39cfb791b5836b/audioop_lts-0.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b00be98ccd0fc123dcfad31d50030d25fcf31488cde9e61692029cd7394733b", size = 27332, upload-time = "2025-08-05T16:43:01.666Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/bd/35dce665255434f54e5307de39e31912a6f902d4572da7c37582809de14f/audioop_lts-0.2.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6d2e0f9f7a69403e388894d4ca5ada5c47230716a03f2847cfc7bd1ecb589d6", size = 92396, upload-time = "2025-08-05T16:43:02.991Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/d2/deeb9f51def1437b3afa35aeb729d577c04bcd89394cb56f9239a9f50b6f/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9b0b8a03ef474f56d1a842af1a2e01398b8f7654009823c6d9e0ecff4d5cfbf", size = 91811, upload-time = "2025-08-05T16:43:04.096Z" },
+    { url = "https://files.pythonhosted.org/packages/76/3b/09f8b35b227cee28cc8231e296a82759ed80c1a08e349811d69773c48426/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2b267b70747d82125f1a021506565bdc5609a2b24bcb4773c16d79d2bb260bbd", size = 100483, upload-time = "2025-08-05T16:43:05.085Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/15/05b48a935cf3b130c248bfdbdea71ce6437f5394ee8533e0edd7cfd93d5e/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0337d658f9b81f4cd0fdb1f47635070cc084871a3d4646d9de74fdf4e7c3d24a", size = 103885, upload-time = "2025-08-05T16:43:06.197Z" },
+    { url = "https://files.pythonhosted.org/packages/83/80/186b7fce6d35b68d3d739f228dc31d60b3412105854edb975aa155a58339/audioop_lts-0.2.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:167d3b62586faef8b6b2275c3218796b12621a60e43f7e9d5845d627b9c9b80e", size = 84899, upload-time = "2025-08-05T16:43:07.291Z" },
+    { url = "https://files.pythonhosted.org/packages/49/89/c78cc5ac6cb5828f17514fb12966e299c850bc885e80f8ad94e38d450886/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0d9385e96f9f6da847f4d571ce3cb15b5091140edf3db97276872647ce37efd7", size = 89998, upload-time = "2025-08-05T16:43:08.335Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/4b/6401888d0c010e586c2ca50fce4c903d70a6bb55928b16cfbdfd957a13da/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:48159d96962674eccdca9a3df280e864e8ac75e40a577cc97c5c42667ffabfc5", size = 99046, upload-time = "2025-08-05T16:43:09.367Z" },
+    { url = "https://files.pythonhosted.org/packages/de/f8/c874ca9bb447dae0e2ef2e231f6c4c2b0c39e31ae684d2420b0f9e97ee68/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fefe5868cd082db1186f2837d64cfbfa78b548ea0d0543e9b28935ccce81ce9", size = 84843, upload-time = "2025-08-05T16:43:10.749Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/c0/0323e66f3daebc13fd46b36b30c3be47e3fc4257eae44f1e77eb828c703f/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:58cf54380c3884fb49fdd37dfb7a772632b6701d28edd3e2904743c5e1773602", size = 94490, upload-time = "2025-08-05T16:43:12.131Z" },
+    { url = "https://files.pythonhosted.org/packages/98/6b/acc7734ac02d95ab791c10c3f17ffa3584ccb9ac5c18fd771c638ed6d1f5/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:088327f00488cdeed296edd9215ca159f3a5a5034741465789cad403fcf4bec0", size = 92297, upload-time = "2025-08-05T16:43:13.139Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c3/c3dc3f564ce6877ecd2a05f8d751b9b27a8c320c2533a98b0c86349778d0/audioop_lts-0.2.2-cp314-cp314t-win32.whl", hash = "sha256:068aa17a38b4e0e7de771c62c60bbca2455924b67a8814f3b0dee92b5820c0b3", size = 27331, upload-time = "2025-08-05T16:43:14.19Z" },
+    { url = "https://files.pythonhosted.org/packages/72/bb/b4608537e9ffcb86449091939d52d24a055216a36a8bf66b936af8c3e7ac/audioop_lts-0.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a5bf613e96f49712073de86f20dbdd4014ca18efd4d34ed18c75bd808337851b", size = 31697, upload-time = "2025-08-05T16:43:15.193Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" },
+]
+
+[[package]]
+name = "black"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "mypy-extensions" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "platformdirs" },
+    { name = "pytokens" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/88/560b11e521c522440af991d46848a2bde64b5f7202ec14e1f46f9509d328/black-26.1.0.tar.gz", hash = "sha256:d294ac3340eef9c9eb5d29288e96dc719ff269a88e27b396340459dd85da4c58", size = 658785, upload-time = "2026-01-18T04:50:11.993Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/83/be35a175aacfce4b05584ac415fd317dd6c24e93a0af2dcedce0f686f5d8/black-26.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9dc8c71656a79ca49b8d3e2ce8103210c9481c57798b48deeb3a8bb02db5f115", size = 1871864, upload-time = "2026-01-18T04:59:47.586Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/f5/d33696c099450b1274d925a42b7a030cd3ea1f56d72e5ca8bbed5f52759c/black-26.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b22b3810451abe359a964cc88121d57f7bce482b53a066de0f1584988ca36e79", size = 1701009, upload-time = "2026-01-18T04:59:49.443Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/87/670dd888c537acb53a863bc15abbd85b22b429237d9de1b77c0ed6b79c42/black-26.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53c62883b3f999f14e5d30b5a79bd437236658ad45b2f853906c7cbe79de00af", size = 1767806, upload-time = "2026-01-18T04:59:50.769Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/9c/cd3deb79bfec5bcf30f9d2100ffeec63eecce826eb63e3961708b9431ff1/black-26.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:f016baaadc423dc960cdddf9acae679e71ee02c4c341f78f3179d7e4819c095f", size = 1433217, upload-time = "2026-01-18T04:59:52.218Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/29/f3be41a1cf502a283506f40f5d27203249d181f7a1a2abce1c6ce188035a/black-26.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:66912475200b67ef5a0ab665011964bf924745103f51977a78b4fb92a9fc1bf0", size = 1245773, upload-time = "2026-01-18T04:59:54.457Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/3d/51bdb3ecbfadfaf825ec0c75e1de6077422b4afa2091c6c9ba34fbfc0c2d/black-26.1.0-py3-none-any.whl", hash = "sha256:1054e8e47ebd686e078c0bb0eaf31e6ce69c966058d122f2c0c950311f9f3ede", size = 204010, upload-time = "2026-01-18T04:50:09.978Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "crabstero"
+source = { editable = "." }
+dependencies = [
+    { name = "aiosqlite" },
+    { name = "discord-py" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "black" },
+    { name = "mypy" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "aiosqlite", specifier = ">=0.22.1" },
+    { name = "discord-py", specifier = ">=2.6.4" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "black", specifier = ">=26.1.0" },
+    { name = "mypy", specifier = ">=1.18.1" },
+]
+
+[[package]]
+name = "discord-py"
+version = "2.6.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "audioop-lts" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/e7/9b1dbb9b2fc07616132a526c05af23cfd420381793968a189ee08e12e35f/discord_py-2.6.4.tar.gz", hash = "sha256:44384920bae9b7a073df64ae9b14c8cf85f9274b5ad5d1d07bd5a67539de2da9", size = 1092623, upload-time = "2025-10-08T21:45:43.593Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/ae/3d3a89b06f005dc5fa8618528dde519b3ba7775c365750f7932b9831ef05/discord_py-2.6.4-py3-none-any.whl", hash = "sha256:2783b7fb7f8affa26847bfc025144652c294e8fe6e0f8877c67ed895749eb227", size = 1209284, upload-time = "2025-10-08T21:45:41.679Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "librt"
+version = "0.7.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/24/5f3646ff414285e0f7708fa4e946b9bf538345a41d1c375c439467721a5e/librt-0.7.8.tar.gz", hash = "sha256:1a4ede613941d9c3470b0368be851df6bb78ab218635512d0370b27a277a0862", size = 148323, upload-time = "2026-01-14T12:56:16.876Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/73/fa8814c6ce2d49c3827829cadaa1589b0bf4391660bd4510899393a23ebc/librt-0.7.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:be927c3c94c74b05128089a955fba86501c3b544d1d300282cc1b4bd370cb418", size = 57049, upload-time = "2026-01-14T12:55:35.056Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fe/f6c70956da23ea235fd2e3cc16f4f0b4ebdfd72252b02d1164dd58b4e6c3/librt-0.7.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7b0803e9008c62a7ef79058233db7ff6f37a9933b8f2573c05b07ddafa226611", size = 58689, upload-time = "2026-01-14T12:55:36.078Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/4d/7a2481444ac5fba63050d9abe823e6bc16896f575bfc9c1e5068d516cdce/librt-0.7.8-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:79feb4d00b2a4e0e05c9c56df707934f41fcb5fe53fd9efb7549068d0495b758", size = 166808, upload-time = "2026-01-14T12:55:37.595Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/3c/10901d9e18639f8953f57c8986796cfbf4c1c514844a41c9197cf87cb707/librt-0.7.8-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9122094e3f24aa759c38f46bd8863433820654927370250f460ae75488b66ea", size = 175614, upload-time = "2026-01-14T12:55:38.756Z" },
+    { url = "https://files.pythonhosted.org/packages/db/01/5cbdde0951a5090a80e5ba44e6357d375048123c572a23eecfb9326993a7/librt-0.7.8-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e03bea66af33c95ce3addf87a9bf1fcad8d33e757bc479957ddbc0e4f7207ac", size = 189955, upload-time = "2026-01-14T12:55:39.939Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/b4/e80528d2f4b7eaf1d437fcbd6fc6ba4cbeb3e2a0cb9ed5a79f47c7318706/librt-0.7.8-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1ade7f31675db00b514b98f9ab9a7698c7282dad4be7492589109471852d398", size = 189370, upload-time = "2026-01-14T12:55:41.057Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ab/938368f8ce31a9787ecd4becb1e795954782e4312095daf8fd22420227c8/librt-0.7.8-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a14229ac62adcf1b90a15992f1ab9c69ae8b99ffb23cb64a90878a6e8a2f5b81", size = 183224, upload-time = "2026-01-14T12:55:42.328Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/10/559c310e7a6e4014ac44867d359ef8238465fb499e7eb31b6bfe3e3f86f5/librt-0.7.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5bcaaf624fd24e6a0cb14beac37677f90793a96864c67c064a91458611446e83", size = 203541, upload-time = "2026-01-14T12:55:43.501Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/db/a0db7acdb6290c215f343835c6efda5b491bb05c3ddc675af558f50fdba3/librt-0.7.8-cp314-cp314-win32.whl", hash = "sha256:7aa7d5457b6c542ecaed79cec4ad98534373c9757383973e638ccced0f11f46d", size = 40657, upload-time = "2026-01-14T12:55:44.668Z" },
+    { url = "https://files.pythonhosted.org/packages/72/e0/4f9bdc2a98a798511e81edcd6b54fe82767a715e05d1921115ac70717f6f/librt-0.7.8-cp314-cp314-win_amd64.whl", hash = "sha256:3d1322800771bee4a91f3b4bd4e49abc7d35e65166821086e5afd1e6c0d9be44", size = 46835, upload-time = "2026-01-14T12:55:45.655Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/3d/59c6402e3dec2719655a41ad027a7371f8e2334aa794ed11533ad5f34969/librt-0.7.8-cp314-cp314-win_arm64.whl", hash = "sha256:5363427bc6a8c3b1719f8f3845ea53553d301382928a86e8fab7984426949bce", size = 39885, upload-time = "2026-01-14T12:55:47.138Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/9c/2481d80950b83085fb14ba3c595db56330d21bbc7d88a19f20165f3538db/librt-0.7.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ca916919793a77e4a98d4a1701e345d337ce53be4a16620f063191f7322ac80f", size = 59161, upload-time = "2026-01-14T12:55:48.45Z" },
+    { url = "https://files.pythonhosted.org/packages/96/79/108df2cfc4e672336765d54e3ff887294c1cc36ea4335c73588875775527/librt-0.7.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:54feb7b4f2f6706bb82325e836a01be805770443e2400f706e824e91f6441dde", size = 61008, upload-time = "2026-01-14T12:55:49.527Z" },
+    { url = "https://files.pythonhosted.org/packages/46/f2/30179898f9994a5637459d6e169b6abdc982012c0a4b2d4c26f50c06f911/librt-0.7.8-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:39a4c76fee41007070f872b648cc2f711f9abf9a13d0c7162478043377b52c8e", size = 187199, upload-time = "2026-01-14T12:55:50.587Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/da/f7563db55cebdc884f518ba3791ad033becc25ff68eb70902b1747dc0d70/librt-0.7.8-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac9c8a458245c7de80bc1b9765b177055efff5803f08e548dd4bb9ab9a8d789b", size = 198317, upload-time = "2026-01-14T12:55:51.991Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/6c/4289acf076ad371471fa86718c30ae353e690d3de6167f7db36f429272f1/librt-0.7.8-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95b67aa7eff150f075fda09d11f6bfb26edffd300f6ab1666759547581e8f666", size = 210334, upload-time = "2026-01-14T12:55:53.682Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/7f/377521ac25b78ac0a5ff44127a0360ee6d5ddd3ce7327949876a30533daa/librt-0.7.8-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:535929b6eff670c593c34ff435d5440c3096f20fa72d63444608a5aef64dd581", size = 211031, upload-time = "2026-01-14T12:55:54.827Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/b1/e1e96c3e20b23d00cf90f4aad48f0deb4cdfec2f0ed8380d0d85acf98bbf/librt-0.7.8-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:63937bd0f4d1cb56653dc7ae900d6c52c41f0015e25aaf9902481ee79943b33a", size = 204581, upload-time = "2026-01-14T12:55:56.811Z" },
+    { url = "https://files.pythonhosted.org/packages/43/71/0f5d010e92ed9747e14bef35e91b6580533510f1e36a8a09eb79ee70b2f0/librt-0.7.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf243da9e42d914036fd362ac3fa77d80a41cadcd11ad789b1b5eec4daaf67ca", size = 224731, upload-time = "2026-01-14T12:55:58.175Z" },
+    { url = "https://files.pythonhosted.org/packages/22/f0/07fb6ab5c39a4ca9af3e37554f9d42f25c464829254d72e4ebbd81da351c/librt-0.7.8-cp314-cp314t-win32.whl", hash = "sha256:171ca3a0a06c643bd0a2f62a8944e1902c94aa8e5da4db1ea9a8daf872685365", size = 41173, upload-time = "2026-01-14T12:55:59.315Z" },
+    { url = "https://files.pythonhosted.org/packages/24/d4/7e4be20993dc6a782639625bd2f97f3c66125c7aa80c82426956811cfccf/librt-0.7.8-cp314-cp314t-win_amd64.whl", hash = "sha256:445b7304145e24c60288a2f172b5ce2ca35c0f81605f5299f3fa567e189d2e32", size = 47668, upload-time = "2026-01-14T12:56:00.261Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/85/69f92b2a7b3c0f88ffe107c86b952b397004b5b8ea5a81da3d9c04c04422/librt-0.7.8-cp314-cp314t-win_arm64.whl", hash = "sha256:8766ece9de08527deabcd7cb1b4f1a967a385d26e33e536d6d8913db6ef74f06", size = 40550, upload-time = "2026-01-14T12:56:01.542Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+    { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+    { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+    { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+    { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+    { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "1.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/db/4efed9504bc01309ab9c2da7e352cc223569f05478012b5d9ece38fd44d2/mypy-1.19.1.tar.gz", hash = "sha256:19d88bb05303fe63f71dd2c6270daca27cb9401c4ca8255fe50d1d920e0eb9ba", size = 3582404, upload-time = "2025-12-15T05:03:48.42Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/eb/b83e75f4c820c4247a58580ef86fcd35165028f191e7e1ba57128c52782d/mypy-1.19.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06e6170bd5836770e8104c8fdd58e5e725cfeb309f0a6c681a811f557e97eac1", size = 13199744, upload-time = "2025-12-15T05:03:30.823Z" },
+    { url = "https://files.pythonhosted.org/packages/94/28/52785ab7bfa165f87fcbb61547a93f98bb20e7f82f90f165a1f69bce7b3d/mypy-1.19.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:804bd67b8054a85447c8954215a906d6eff9cabeabe493fb6334b24f4bfff718", size = 12215815, upload-time = "2025-12-15T05:02:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/c6/bdd60774a0dbfb05122e3e925f2e9e846c009e479dcec4821dad881f5b52/mypy-1.19.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21761006a7f497cb0d4de3d8ef4ca70532256688b0523eee02baf9eec895e27b", size = 12740047, upload-time = "2025-12-15T05:03:33.168Z" },
+    { url = "https://files.pythonhosted.org/packages/32/2a/66ba933fe6c76bd40d1fe916a83f04fed253152f451a877520b3c4a5e41e/mypy-1.19.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28902ee51f12e0f19e1e16fbe2f8f06b6637f482c459dd393efddd0ec7f82045", size = 13601998, upload-time = "2025-12-15T05:03:13.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/da/5055c63e377c5c2418760411fd6a63ee2b96cf95397259038756c042574f/mypy-1.19.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:481daf36a4c443332e2ae9c137dfee878fcea781a2e3f895d54bd3002a900957", size = 13807476, upload-time = "2025-12-15T05:03:17.977Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/09/4ebd873390a063176f06b0dbf1f7783dd87bd120eae7727fa4ae4179b685/mypy-1.19.1-cp314-cp314-win_amd64.whl", hash = "sha256:8bb5c6f6d043655e055be9b542aa5f3bdd30e4f3589163e85f93f3640060509f", size = 10281872, upload-time = "2025-12-15T05:03:05.549Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f4/4ce9a05ce5ded1de3ec1c1d96cf9f9504a04e54ce0ed55cfa38619a32b8d/mypy-1.19.1-py3-none-any.whl", hash = "sha256:f1235f5ea01b7db5468d53ece6aaddf1ad0b88d9e7462b86ef96fe04995d7247", size = 2471239, upload-time = "2025-12-15T05:03:07.248Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "1.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "pytokens"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b6/34/b4e015b99031667a7b960f888889c5bd34ef585c85e1cb56a594b92836ac/pytokens-0.4.1.tar.gz", hash = "sha256:292052fe80923aae2260c073f822ceba21f3872ced9a68bb7953b348e561179a", size = 23015, upload-time = "2026-01-30T01:03:45.924Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/a7/b470f672e6fc5fee0a01d9e75005a0e617e162381974213a945fcd274843/pytokens-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4a14d5f5fc78ce85e426aa159489e2d5961acf0e47575e08f35584009178e321", size = 160821, upload-time = "2026-01-30T01:03:19.684Z" },
+    { url = "https://files.pythonhosted.org/packages/80/98/e83a36fe8d170c911f864bfded690d2542bfcfacb9c649d11a9e6eb9dc41/pytokens-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f50fd18543be72da51dd505e2ed20d2228c74e0464e4262e4899797803d7fa", size = 254263, upload-time = "2026-01-30T01:03:20.834Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/95/70d7041273890f9f97a24234c00b746e8da86df462620194cef1d411ddeb/pytokens-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc74c035f9bfca0255c1af77ddd2d6ae8419012805453e4b0e7513e17904545d", size = 268071, upload-time = "2026-01-30T01:03:21.888Z" },
+    { url = "https://files.pythonhosted.org/packages/da/79/76e6d09ae19c99404656d7db9c35dfd20f2086f3eb6ecb496b5b31163bad/pytokens-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f66a6bbe741bd431f6d741e617e0f39ec7257ca1f89089593479347cc4d13324", size = 271716, upload-time = "2026-01-30T01:03:23.633Z" },
+    { url = "https://files.pythonhosted.org/packages/79/37/482e55fa1602e0a7ff012661d8c946bafdc05e480ea5a32f4f7e336d4aa9/pytokens-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:b35d7e5ad269804f6697727702da3c517bb8a5228afa450ab0fa787732055fc9", size = 104539, upload-time = "2026-01-30T01:03:24.788Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e8/20e7db907c23f3d63b0be3b8a4fd1927f6da2395f5bcc7f72242bb963dfe/pytokens-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8fcb9ba3709ff77e77f1c7022ff11d13553f3c30299a9fe246a166903e9091eb", size = 168474, upload-time = "2026-01-30T01:03:26.428Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/81/88a95ee9fafdd8f5f3452107748fd04c24930d500b9aba9738f3ade642cc/pytokens-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79fc6b8699564e1f9b521582c35435f1bd32dd06822322ec44afdeba666d8cb3", size = 290473, upload-time = "2026-01-30T01:03:27.415Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/35/3aa899645e29b6375b4aed9f8d21df219e7c958c4c186b465e42ee0a06bf/pytokens-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d31b97b3de0f61571a124a00ffe9a81fb9939146c122c11060725bd5aea79975", size = 303485, upload-time = "2026-01-30T01:03:28.558Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a0/07907b6ff512674d9b201859f7d212298c44933633c946703a20c25e9d81/pytokens-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:967cf6e3fd4adf7de8fc73cd3043754ae79c36475c1c11d514fc72cf5490094a", size = 306698, upload-time = "2026-01-30T01:03:29.653Z" },
+    { url = "https://files.pythonhosted.org/packages/39/2a/cbbf9250020a4a8dd53ba83a46c097b69e5eb49dd14e708f496f548c6612/pytokens-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:584c80c24b078eec1e227079d56dc22ff755e0ba8654d8383b2c549107528918", size = 116287, upload-time = "2026-01-30T01:03:30.912Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.22.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/b3/e20ef504049f1a1c54a814b4b9bed96d1ac0e0610c3b4da178f87209db05/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4", size = 140520, upload-time = "2025-10-06T14:11:15.465Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/04/3532d990fdbab02e5ede063676b5c4260e7f3abea2151099c2aa745acc4c/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683", size = 93504, upload-time = "2025-10-06T14:11:17.106Z" },
+    { url = "https://files.pythonhosted.org/packages/11/63/ff458113c5c2dac9a9719ac68ee7c947cb621432bcf28c9972b1c0e83938/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b", size = 94282, upload-time = "2025-10-06T14:11:19.064Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/315a56aca762d44a6aaaf7ad253f04d996cb6b27bad34410f82d76ea8038/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e", size = 372080, upload-time = "2025-10-06T14:11:20.996Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/3f/08e9b826ec2e099ea6e7c69a61272f4f6da62cb5b1b63590bb80ca2e4a40/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590", size = 338696, upload-time = "2025-10-06T14:11:22.847Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/9f/90360108e3b32bd76789088e99538febfea24a102380ae73827f62073543/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2", size = 387121, upload-time = "2025-10-06T14:11:24.889Z" },
+    { url = "https://files.pythonhosted.org/packages/98/92/ab8d4657bd5b46a38094cfaea498f18bb70ce6b63508fd7e909bd1f93066/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da", size = 394080, upload-time = "2025-10-06T14:11:27.307Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e7/d8c5a7752fef68205296201f8ec2bf718f5c805a7a7e9880576c67600658/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784", size = 372661, upload-time = "2025-10-06T14:11:29.387Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2e/f4d26183c8db0bb82d491b072f3127fb8c381a6206a3a56332714b79b751/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b", size = 364645, upload-time = "2025-10-06T14:11:31.423Z" },
+    { url = "https://files.pythonhosted.org/packages/80/7c/428e5812e6b87cd00ee8e898328a62c95825bf37c7fa87f0b6bb2ad31304/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694", size = 355361, upload-time = "2025-10-06T14:11:33.055Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/2a/249405fd26776f8b13c067378ef4d7dd49c9098d1b6457cdd152a99e96a9/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d", size = 381451, upload-time = "2025-10-06T14:11:35.136Z" },
+    { url = "https://files.pythonhosted.org/packages/67/a8/fb6b1adbe98cf1e2dd9fad71003d3a63a1bc22459c6e15f5714eb9323b93/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd", size = 383814, upload-time = "2025-10-06T14:11:37.094Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/f9/3aa2c0e480fb73e872ae2814c43bc1e734740bb0d54e8cb2a95925f98131/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da", size = 370799, upload-time = "2025-10-06T14:11:38.83Z" },
+    { url = "https://files.pythonhosted.org/packages/50/3c/af9dba3b8b5eeb302f36f16f92791f3ea62e3f47763406abf6d5a4a3333b/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2", size = 82990, upload-time = "2025-10-06T14:11:40.624Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/30/ac3a0c5bdc1d6efd1b41fa24d4897a4329b3b1e98de9449679dd327af4f0/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79", size = 88292, upload-time = "2025-10-06T14:11:42.578Z" },
+    { url = "https://files.pythonhosted.org/packages/df/0a/227ab4ff5b998a1b7410abc7b46c9b7a26b0ca9e86c34ba4b8d8bc7c63d5/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33", size = 82888, upload-time = "2025-10-06T14:11:44.863Z" },
+    { url = "https://files.pythonhosted.org/packages/06/5e/a15eb13db90abd87dfbefb9760c0f3f257ac42a5cac7e75dbc23bed97a9f/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1", size = 146223, upload-time = "2025-10-06T14:11:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/18/82/9665c61910d4d84f41a5bf6837597c89e665fa88aa4941080704645932a9/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca", size = 95981, upload-time = "2025-10-06T14:11:48.845Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/9a/2f65743589809af4d0a6d3aa749343c4b5f4c380cc24a8e94a3c6625a808/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53", size = 97303, upload-time = "2025-10-06T14:11:50.897Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/ab/5b13d3e157505c43c3b43b5a776cbf7b24a02bc4cccc40314771197e3508/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c", size = 361820, upload-time = "2025-10-06T14:11:52.549Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/242a5ef4677615cf95330cfc1b4610e78184400699bdda0acb897ef5e49a/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf", size = 323203, upload-time = "2025-10-06T14:11:54.225Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/96/475509110d3f0153b43d06164cf4195c64d16999e0c7e2d8a099adcd6907/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face", size = 363173, upload-time = "2025-10-06T14:11:56.069Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/66/59db471aecfbd559a1fd48aedd954435558cd98c7d0da8b03cc6c140a32c/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b", size = 373562, upload-time = "2025-10-06T14:11:58.783Z" },
+    { url = "https://files.pythonhosted.org/packages/03/1f/c5d94abc91557384719da10ff166b916107c1b45e4d0423a88457071dd88/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486", size = 339828, upload-time = "2025-10-06T14:12:00.686Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/aa6a143d3afba17b6465733681c70cf175af89f76ec8d9286e08437a7454/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138", size = 347551, upload-time = "2025-10-06T14:12:02.628Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3c/45a2b6d80195959239a7b2a8810506d4eea5487dce61c2a3393e7fc3c52e/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a", size = 334512, upload-time = "2025-10-06T14:12:04.871Z" },
+    { url = "https://files.pythonhosted.org/packages/86/a0/c2ab48d74599c7c84cb104ebd799c5813de252bea0f360ffc29d270c2caa/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529", size = 352400, upload-time = "2025-10-06T14:12:06.624Z" },
+    { url = "https://files.pythonhosted.org/packages/32/75/f8919b2eafc929567d3d8411f72bdb1a2109c01caaab4ebfa5f8ffadc15b/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093", size = 357140, upload-time = "2025-10-06T14:12:08.362Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/72/6a85bba382f22cf78add705d8c3731748397d986e197e53ecc7835e76de7/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c", size = 341473, upload-time = "2025-10-06T14:12:10.994Z" },
+    { url = "https://files.pythonhosted.org/packages/35/18/55e6011f7c044dc80b98893060773cefcfdbf60dfefb8cb2f58b9bacbd83/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e", size = 89056, upload-time = "2025-10-06T14:12:13.317Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/86/0f0dccb6e59a9e7f122c5afd43568b1d31b8ab7dda5f1b01fb5c7025c9a9/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27", size = 96292, upload-time = "2025-10-06T14:12:15.398Z" },
+    { url = "https://files.pythonhosted.org/packages/48/b7/503c98092fb3b344a179579f55814b613c1fbb1c23b3ec14a7b008a66a6e/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1", size = 85171, upload-time = "2025-10-06T14:12:16.935Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" },
+]