diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..2ab2ab1 --- /dev/null +++ b/.env.example @@ -0,0 +1,12 @@ +DISCORD_BOT_TOKEN=your-discord-bot-token +FORUM_CHANNEL_ID=your-forum-channel-id +GITHUB_TOKEN=your-github-token +GITHUB_PROJECT_NODE_ID=your-github-project-node-id +GITHUB_PROJECT_NUMBER=your-github-project-number +GITHUB_ORGANIZATION_NAME=your-github-organization-name +GITHUB_ID_TO_DISCORD_ID_MAPPING_PATH=path-to-github-username-to-discord-id-mapping.json +IP_ADDRESS=0.0.0.0 +PORT=8000 +GITHUB_WEBHOOK_SECRET=your-github-webhook-secret +# Shelve database +POST_ID_DB_PATH=path-to-post-id.db \ No newline at end of file diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml new file mode 100644 index 0000000..8a122e7 --- /dev/null +++ b/.github/workflows/ci.yaml @@ -0,0 +1,31 @@ +name: CI +on: + push: + branches: [master] + pull_request: + branches: [master] + workflow_dispatch: + +jobs: + tests: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v5 + + - name: Install uv + uses: astral-sh/setup-uv@v7 + + - name: Set up Python + run: uv python install + + - name: Install all dependencies + run: uv sync --all-groups --locked + + - name: Run Tests + run: uv run pytest + + - name: Run Lint + run: uv run ruff check + + - name: Run Formatter + run: uv run ruff format --check diff --git a/.gitignore b/.gitignore index b7faf40..1b9fe59 100644 --- a/.gitignore +++ b/.gitignore @@ -205,3 +205,8 @@ cython_debug/ marimo/_static/ marimo/_lsp/ __marimo__/ + +.idea/ + +# Shelves database +post_id.db \ No newline at end of file diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..cf19c00 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,21 @@ +repos: + # Run lint + - repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.14.5 + hooks: + # Run the linter. + - id: ruff + # Run the formatter. + - id: ruff-format + args: ["--check"] + # Run the tests. + - repo: local + hooks: + - id: pytest + name: pytest + entry: ./.venv/bin/pytest + language: system + types: [python] + pass_filenames: false + always_run: true diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..b014cd9 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,14 @@ +FROM python:3.14-slim-trixie +COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/ + +ADD . /app + +WORKDIR /app +RUN uv sync --locked --no-default-groups --group prod --compile-bytecode + +EXPOSE $PORT +CMD exec .venv/bin/gunicorn src.server:app \ + --workers 1 \ + --worker-class uvicorn.workers.UvicornWorker \ + --bind "${IP_ADDRESS:-0.0.0.0}:${PORT:-8000}" \ + --log-level info diff --git a/README.md b/README.md new file mode 100644 index 0000000..487c715 --- /dev/null +++ b/README.md @@ -0,0 +1,49 @@ +## GitHub Projects Discord Bot + +This repository provides an integration between [Discord](https://discord.com/) and [GitHub Projects](https://docs.github.com/en/issues/planning-and-tracking-with-projects/learning-about-projects/about-projects), +allowing users to discuss GitHub Projects directly from Discord. Whenever a new issue, pull request or draft issue is added +to the project, bot creates a new thread in the specified Discord channel. Every update to the project item is then communicated +in the thread, allowing users to stay up-to-date with the latest changes. + +## 🚜 Development + +This repository contains two main components: +- [`server.py`](/src/server.py): listens for GitHub webhook events and processes them +- [`bot.py`](/src/bot.py): a Discord bot that creates threads and posts updates + +For local development, you can copy the `.env.example` file to `.env` and fill in the first three environment variables. +Then run the following command to install dependencies: + +```bash +uv sync +``` + +To run the server and bot locally, you can use the following command: + +```bash +uv run start-app +``` + +To run all tests, including unit tests, integration tests and e2e tests, use the following command: + +```bash +uv run pytest +``` + +## 🚀 Deployment + +For deployment follow these steps: +- set all environment variables accordingly, +- setup file_mount for volumes specified in `docker-compose.yaml` on /app/path_set_in_env, +- set up a webhook in your GitHub repository to point to your server's `/webhook_endpoint` endpoint, +- use Dockerfile to build the image. + +## ⚒️ How it works + +1. GitHub sends a webhook event to the server when an issue, pull request or draft issue is added or updated in the project. +2. The server processes the event and extracts relevant information, such as the issue title, description +3. The server updates shared state with the new information which is then used by the bot to post updates. +4. The bot creates a new thread in the specified Discord channel for new issues, pull requests or draft issues. +5. The bot posts updates in the thread whenever the issue, pull request or draft issue is updated. +6. The bot uses the `github_usernames_to_discord_id_mapping.json` file to map GitHub usernames to Discord user IDs, + allowing it to mention users in the thread. diff --git a/docker-compose.yaml b/docker-compose.yaml new file mode 100644 index 0000000..953723f --- /dev/null +++ b/docker-compose.yaml @@ -0,0 +1,16 @@ +services: + app: + container_name: app + build: + context: . + dockerfile: Dockerfile + restart: on-failure + ports: + - "${PORT:-8000}:${PORT:-8000}" + env_file: + - .env + volumes: + - github_id_to_discord_id_mapping:/app/${GITHUB_ID_TO_DISCORD_ID_MAPPING_PATH} + +volumes: + github_id_to_discord_id_mapping: diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..e36e7f9 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,60 @@ +[project] +name = "github-project-discord-bot" +version = "1.0.0" +description = "Create post on forum channel for github project cards" +requires-python = ">=3.14" +dependencies = [ + "aiohttp>=3.13.2", + "aiorwlock>=1.5.0", + "dotenv>=0.9.9", + "fastapi>=0.121.2", + "hikari>=2.5.0", + "setuptools>=80.9.0", + "uvicorn>=0.38.0", +] + +[build-system] +requires = ["setuptools"] +build-backend = "setuptools.build_meta" + +[tool.setuptools] +packages = ["src"] + +[dependency-groups] +prod = [ + "gunicorn>=23.0.0", + "uvicorn[standard]>=0.38.0" +] +dev = [ + "pytest>=9.0.1", + "pytest-asyncio>=1.3.0", + "ruff>=0.14.5", + "pre-commit>=4.4.0", + "httpx>=0.28.1" # required for testing FastAPI endpoints +] + +[tool.uv] +default-groups = ["dev"] + +[tool.pytest.ini_options] +testpaths = ["src/tests"] +asyncio_mode = "auto" + +[project.scripts] +start-app = "src.main:main" + +[tool.ruff] +line-length = 120 +preview = true + +[tool.ruff.lint] +select = [ + "E", # pycodestyle errors + "W", # pycodestyle warnings + "F", # pyflakes + "I", # isort + "B", # flake8-bugbear + "C4", # flake8-comprehensions + "UP", # pyupgrade (modern Python syntax) + "N", # PEP8 Naming +] diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/bot.py b/src/bot.py new file mode 100644 index 0000000..126a184 --- /dev/null +++ b/src/bot.py @@ -0,0 +1,90 @@ +import asyncio +import os + +from hikari import GuildPublicThread, RESTApp, TokenType +from hikari.impl import RESTClientImpl + +from src.utils.data_types import ProjectItemEvent +from src.utils.discord_rest_client import fetch_forum_channel, get_post_id_or_post +from src.utils.error import ForumChannelNotFound +from src.utils.github_api import fetch_item_name +from src.utils.misc import SharedForumChannel, bot_logger, create_item_link, handle_task_exception, retrieve_discord_id + + +async def run(state: asyncio.Queue[ProjectItemEvent], stop_after_one_event: bool = False): + discord_rest = RESTApp() + await discord_rest.start() + + async with discord_rest.acquire(os.getenv("DISCORD_BOT_TOKEN"), token_type=TokenType.BOT) as client: + bot_logger.info("Discord client acquired.") + forum_channel_id = int(os.getenv("FORUM_CHANNEL_ID")) + discord_guild_id = int(os.getenv("DISCORD_GUILD_ID")) + forum_channel = await fetch_forum_channel(client, forum_channel_id) + if forum_channel is None: + raise ForumChannelNotFound(f"Forum channel with ID {forum_channel_id} not found.") + shared_forum_channel = SharedForumChannel(forum_channel) + + while True: + event = await state.get() + update_task = asyncio.create_task( + process_update(client, forum_channel_id, discord_guild_id, shared_forum_channel, event) + ) + update_task.add_done_callback(lambda task: handle_task_exception(task, "Error processing update:")) + if stop_after_one_event: + break + + +async def process_update( + client: RESTClientImpl, + forum_channel_id: int, + discord_guild_id: int, + shared_forum_channel: SharedForumChannel, + event: ProjectItemEvent, +): + bot_logger.info(f"Processing event for item: {event.node_id}") + + post_id_or_post = await get_post_id_or_post(event.node_id, discord_guild_id, forum_channel_id, client) + author_discord_id = retrieve_discord_id(event.sender) + user_mentions = [author_discord_id] if author_discord_id else [] + user_text_mention = f"<@{author_discord_id}>" if author_discord_id else "nieznany użytkownik" + + if post_id_or_post is None: + post = await create_post(event, user_text_mention, shared_forum_channel, client, user_mentions) + elif isinstance(post_id_or_post, int): + post = await client.fetch_channel(post_id_or_post) + else: + post = post_id_or_post + + if not isinstance(post, GuildPublicThread): + try: + bot_logger.error(f"Post with ID {post.id} is not a GuildPublicThread.") + except AttributeError: + bot_logger.error(f"Post with node_id {event.node_id} is not a GuildPublicThread.") + return + + message = await event.process(user_text_mention, post, client, shared_forum_channel, forum_channel_id) + if message: + await client.create_message(post.id, message, user_mentions=user_mentions) + + +async def create_post( + event: ProjectItemEvent, + user_text_mention: str, + shared_forum_channel: SharedForumChannel, + client: RESTClientImpl, + user_mentions: list[str], +) -> GuildPublicThread: + bot_logger.info(f"Post not found, creating new post for item: {event.node_id}") + item_name = await fetch_item_name(event.node_id) + message = ( + f"Nowy task stworzony {item_name} przez: {user_text_mention}.\n" + f" Link do taska: {create_item_link(event.item_id)}" + ) + async with shared_forum_channel.lock.reader_lock: + return await client.create_forum_post( + shared_forum_channel.forum_channel, + item_name, + message, + auto_archive_duration=10080, + user_mentions=user_mentions, + ) diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..e2a6f55 --- /dev/null +++ b/src/main.py @@ -0,0 +1,35 @@ +import asyncio +import os +from contextlib import asynccontextmanager + +import dotenv +import uvicorn +from fastapi import FastAPI + +from src.bot import run +from src.utils.misc import handle_task_exception + + +def main(): + dotenv.load_dotenv() + host, port = os.getenv("IP_ADDRESS", "0.0.0.0"), os.getenv("PORT", "8000") + uvicorn.run("src.server:app", host=host, port=int(port), reload=True) + + +@asynccontextmanager +async def lifespan(app: FastAPI): + # startup + app.update_queue = asyncio.Queue() + bot_task = asyncio.create_task(run(app.update_queue)) + bot_task.add_done_callback(lambda task: handle_task_exception(task, "Bot task crashed:")) + yield + # shutdown + bot_task.cancel() + try: + await bot_task + except asyncio.CancelledError: + pass + + +if __name__ == "__main__": + main() diff --git a/src/server.py b/src/server.py new file mode 100644 index 0000000..68993e0 --- /dev/null +++ b/src/server.py @@ -0,0 +1,128 @@ +import os + +from fastapi import FastAPI, HTTPException, Request +from pydantic import ValidationError +from starlette.exceptions import HTTPException as StarletteHttpException +from starlette.responses import JSONResponse + +from src.main import lifespan +from src.utils.data_types import ( + ProjectItemEditedAssignees, + ProjectItemEditedBody, + ProjectItemEditedSingleSelect, + ProjectItemEditedTitle, + ProjectItemEvent, + SimpleProjectItemEvent, + WebhookRequest, +) +from src.utils.github_api import fetch_assignees, fetch_item_name, fetch_single_select_value +from src.utils.misc import server_logger +from src.utils.signature_verification import verify_signature + +app = FastAPI(lifespan=lifespan) + + +@app.exception_handler(StarletteHttpException) +async def http_exception_handler(_request: Request, exception: StarletteHttpException) -> JSONResponse: + server_logger.error(f"HTTP exception occurred: {exception.detail}") + return JSONResponse(status_code=exception.status_code, content={"detail": exception.detail}) + + +@app.exception_handler(ValidationError) +async def validation_exception_handler(_request: Request, exception: ValidationError) -> JSONResponse: + server_logger.error( + f"ValidationError occurred: {exception.errors(include_url=False, include_context=False, include_input=False)}" + ) + try: + return JSONResponse( + status_code=400, + content={ + "detail": "Invalid request body.", + "validation_errors": exception.errors(include_url=False, include_context=False, include_input=False), + }, + ) + except TypeError: + # Can happen when there is error in JSON parsing + return JSONResponse(status_code=400, content={"detail": "Invalid request body."}) + + +@app.exception_handler(Exception) +async def default_exception_handler(_request: Request, exception: Exception) -> JSONResponse: + server_logger.error(f"Unhandled exception occurred: {str(exception)}") + return JSONResponse(status_code=500, content={"detail": "Internal server error."}) + + +@app.post("/webhook_endpoint") +async def webhook_endpoint(request: Request) -> JSONResponse: + body_bytes = await request.body() + if not body_bytes: + raise HTTPException(status_code=400, detail="Missing request body.") + + signature = request.headers.get("X-Hub-Signature-256") + verify_signature(signature, body_bytes) + + body = WebhookRequest.model_validate_json(body_bytes) + if body.projects_v2_item.project_node_id != os.getenv("GITHUB_PROJECT_NODE_ID"): + raise HTTPException(status_code=400, detail="Invalid project_node_id.") + + project_item_event = await process_action(body) + await app.update_queue.put(project_item_event) + + server_logger.info(f"Received webhook event for item: {body.projects_v2_item.node_id}") + return JSONResponse(content={"detail": "Successfully received webhook data"}) + + +async def process_action(body: WebhookRequest) -> ProjectItemEvent: + if body.action == "edited": + return await process_edition(body) + else: + try: + return SimpleProjectItemEvent( + body.projects_v2_item.item_id, body.projects_v2_item.node_id, body.sender.node_id, body.action + ) + except ValueError as error: + raise HTTPException(status_code=400, detail="Unsupported action.") from error + + +async def process_edition( + body: WebhookRequest, +) -> ProjectItemEditedBody | ProjectItemEditedTitle | ProjectItemEditedAssignees | ProjectItemEditedSingleSelect: + editor = body.sender.node_id + body_changed = body.changes.body + item_node_id = body.projects_v2_item.node_id + item_id = body.projects_v2_item.item_id + + if body_changed is not None: + project_item_edited = ProjectItemEditedBody(item_id, item_node_id, editor, body_changed.to) + return project_item_edited + + field_changed = body.changes.field_value + + if field_changed is None: + raise HTTPException(status_code=400, detail="Failed to recognize the edited event.") + + match field_changed.field_type: + case "assignees": + new_assignees = await fetch_assignees(body.projects_v2_item.node_id) + project_item_edited = ProjectItemEditedAssignees(item_id, item_node_id, editor, new_assignees) + return project_item_edited + case "title": + new_title = await fetch_item_name(body.projects_v2_item.node_id) + project_item_edited = ProjectItemEditedTitle(item_id, item_node_id, editor, new_title) + return project_item_edited + case "single_select": + new_value = field_changed.to.name + field_name = field_changed.field_name + if new_value is None: + new_value = await fetch_single_select_value(body.projects_v2_item.node_id, field_name) + try: + project_item_edited = ProjectItemEditedSingleSelect( + item_id, item_node_id, editor, new_value, field_name + ) + except ValueError as error: + raise HTTPException(status_code=400, detail="Unsupported single select field.") from error + return project_item_edited + case "iteration": + new_value = field_changed.to.title + project_item_edited = ProjectItemEditedSingleSelect(item_id, item_node_id, editor, new_value, "Iteration") + return project_item_edited diff --git a/src/tests/__init__.py b/src/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/tests/conftest.py b/src/tests/conftest.py new file mode 100644 index 0000000..1c5a1b5 --- /dev/null +++ b/src/tests/conftest.py @@ -0,0 +1,141 @@ +import datetime + +import pytest +from hikari import ( + ChannelFlag, + ForumLayoutType, + ForumSortOrderType, + ForumTag, + GuildForumChannel, + GuildPublicThread, + PartialChannel, + RESTAware, + Snowflake, + ThreadMetadata, +) +from hikari.impl import EntityFactoryImpl, HTTPSettings, ProxySettings, RESTClientImpl + +from src.utils.misc import SharedForumChannel + + +class MockShelf(dict): + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + pass + + +class MockResponse(dict): + async def __aenter__(self): + return self + + async def __aexit__(self, exc_type, exc, tb): + pass + + async def json(self): + return self + + +class RestClientContextManagerMock: + rest_client_mock: RESTClientImpl + + def __init__(self, rest_client_mock): + self.rest_client_mock = rest_client_mock + + async def __aenter__(self): + return self.rest_client_mock + + async def __aexit__(self, exc_type, exc_val, exc_tb): + pass + + +@pytest.fixture +def post_mock(): + return PartialChannel(app=RESTAware, id=Snowflake(621), name="audacity4", type=0) + + +@pytest.fixture +def rest_client_mock(): + entity_factory = EntityFactoryImpl(app=RESTAware) + http_settings = HTTPSettings() + proxy_settings = ProxySettings() + return RESTClientImpl( + cache=None, + entity_factory=entity_factory, + executor=None, + http_settings=http_settings, + proxy_settings=proxy_settings, + token=None, + token_type=None, + rest_url=None, + ) + + +@pytest.fixture +def forum_channel_mock(): + mock_timedelta = datetime.timedelta(seconds=0) + return GuildForumChannel( + app=RESTAware, + id=Snowflake(67), + name="forum-channel", + topic="A forum channel", + is_nsfw=False, + default_auto_archive_duration=mock_timedelta, + available_tags=[ForumTag(id=Snowflake(1), name="Size: smol", moderated=False)], + type=0, + guild_id=Snowflake(41), + parent_id=None, + position=0, + permission_overwrites={}, + last_thread_id=None, + rate_limit_per_user=mock_timedelta, + default_thread_rate_limit_per_user=mock_timedelta, + flags=ChannelFlag(0), + default_sort_order=ForumSortOrderType.CREATION_DATE, + default_layout=ForumLayoutType.GALLERY_VIEW, + default_reaction_emoji_id=None, + default_reaction_emoji_name=None, + ) + + +@pytest.fixture +def shared_forum_channel_mock(forum_channel_mock): + return SharedForumChannel(forum_channel_mock) + + +@pytest.fixture +def full_post_mock(): + mock_timedelta = datetime.timedelta(seconds=0) + mock_datetime = datetime.datetime.now() + mock_metadata = ThreadMetadata( + is_archived=False, + archive_timestamp=mock_datetime, + auto_archive_duration=mock_timedelta, + is_invitable=False, + is_locked=False, + created_at=mock_datetime, + ) + return GuildPublicThread( + app=RESTAware, + id=Snowflake(621), + name="audacity4", + type=0, + guild_id=Snowflake(0), + last_message_id=None, + last_pin_timestamp=None, + rate_limit_per_user=mock_timedelta, + approximate_message_count=0, + approximate_member_count=0, + member=None, + owner_id=Snowflake(0), + parent_id=Snowflake(0), + metadata=mock_metadata, + applied_tag_ids=[Snowflake(1)], + flags=ChannelFlag(0), + ) + + +@pytest.fixture +def user_text_mention(): + return "<@123456789012345678>" diff --git a/src/tests/test_e2e.py b/src/tests/test_e2e.py new file mode 100644 index 0000000..e27ab35 --- /dev/null +++ b/src/tests/test_e2e.py @@ -0,0 +1,103 @@ +import asyncio +import json +from logging import Logger +from unittest.mock import AsyncMock, mock_open, patch + +import aiohttp +import pytest +from hikari import RESTApp +from hikari.impl import RESTClientImpl +from uvicorn import Config, Server + +from src.server import app +from src.tests.conftest import MockShelf +from src.tests.test_integration.test_bot import RestClientContextManagerMock +from src.utils.signature_verification import generate_signature + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +@patch.object(Logger, "info") +@patch.object(RESTClientImpl, "create_message", new_callable=AsyncMock) +@patch("builtins.open", new_callable=mock_open, read_data="") +@patch.object(RESTClientImpl, "fetch_active_threads", new_callable=AsyncMock) +@patch("shelve.open") +@patch("os.getenv") +@patch.object(RESTClientImpl, "fetch_channel", new_callable=AsyncMock) +@patch.object(RESTApp, "acquire") +@patch.object(RESTApp, "start", new_callable=AsyncMock) +async def test_e2e( + _mock_restapp_start, + mock_restapp_acquire, + mock_fetch_channel, + mock_getenv, + mock_shelve_open, + mock_fetch_active_threads, + _mock_open, + mock_create_message, + mock_logger, + mock_send_request, + rest_client_mock, + forum_channel_mock, + full_post_mock, +): + mock_restapp_acquire.return_value = RestClientContextManagerMock(rest_client_mock) + mock_fetch_channel.side_effect = [forum_channel_mock, full_post_mock] + mock_getenv.side_effect = [ + "some_token", + 1, + 2, + "some_secret", + "fake_project_id", + "db-path.db", + "meow.yaml", + "db-path.db", + ] + post_id_shelf = MockShelf({}) + mock_shelve_open.return_value = post_id_shelf + mock_fetch_active_threads.return_value = [full_post_mock] + mock_send_request.return_value = {"data": {"node": {"content": {"title": "audacity4"}}}} + config = Config(app=app, host="127.0.0.1", port=8000, log_level="critical") + server = Server(config=config) + + server_task = asyncio.create_task(server.serve()) + for _ in range(100): + try: + _, writer = await asyncio.open_connection("127.0.0.1", 8000) + writer.close() + await writer.wait_closed() + break + except ConnectionRefusedError: + await asyncio.sleep(0.01) + else: + pytest.fail("Server did not start in time") + + payload = { + "action": "edited", + "sender": {"node_id": "github_user"}, + "projects_v2_item": {"id": 123, "node_id": "item123", "project_node_id": "fake_project_id"}, + "changes": {"body": {"to": "Updated description"}}, + } + signature = generate_signature("some_secret", json.dumps(payload).encode()) + async with aiohttp.ClientSession() as client: + resp = await client.post( + "http://127.0.0.1:8000/webhook_endpoint", json=payload, headers={"X-Hub-Signature-256": signature} + ) + + assert resp.status == 200 + + for _ in range(500): # up to ~5 seconds total + try: + mock_logger.assert_any_call("Post item123 body updated.") + break + except AssertionError: + pass + await asyncio.sleep(0.01) + else: + pytest.fail("Expected log 'body updated' not found in output") + assert post_id_shelf.get("audacity4") == 621 + mock_create_message.assert_called_with( + 621, "Opis taska zaktualizowany przez: nieznany użytkownik. Nowy opis: \nUpdated description", user_mentions=[] + ) + + server.should_exit = True + await server_task diff --git a/src/tests/test_integration/__init__.py b/src/tests/test_integration/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/tests/test_integration/test_bot.py b/src/tests/test_integration/test_bot.py new file mode 100644 index 0000000..425a0d5 --- /dev/null +++ b/src/tests/test_integration/test_bot.py @@ -0,0 +1,61 @@ +import asyncio +from unittest.mock import AsyncMock, mock_open, patch + +from hikari import RESTApp +from hikari.impl import RESTClientImpl + +from src.bot import run +from src.tests.conftest import MockShelf, RestClientContextManagerMock +from src.utils.data_types import ProjectItemEvent + + +@patch("src.bot.fetch_item_name", new_callable=AsyncMock) +@patch("src.utils.discord_rest_client.fetch_item_name", new_callable=AsyncMock) +@patch("builtins.open", new_callable=mock_open, read_data="") +@patch("shelve.open") +@patch.object(RESTClientImpl, "create_forum_post", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_public_archived_threads", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_active_threads", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_channel", new_callable=AsyncMock) +@patch.object(RESTApp, "acquire") +@patch.object(RESTApp, "start", new_callable=AsyncMock) +@patch("os.getenv") +async def test_basic_event_only_creation( + mock_os_getenv, + _mock_restapp_start, + mock_restapp_acquire, + mock_fetch_channel, + mock_fetch_active_threads, + mock_fetch_public_archived_threads, + mock_create_forum_post, + mock_shelve_open, + _mock_open, + mock_fetch_item_name, + mock_fetch_item_name2, + rest_client_mock, + forum_channel_mock, +): + mock_os_getenv.side_effect = ["some_token", 1, 2, "some_path", "db-path.db", "my-org", "1"] + mock_restapp_acquire.return_value = RestClientContextManagerMock(rest_client_mock) + mock_fetch_channel.return_value = forum_channel_mock + mock_fetch_active_threads.return_value = [] + mock_fetch_public_archived_threads.return_value = [] + mock_create_forum_post.return_value = None + mock_shelve_open.return_value = MockShelf({}) + mock_create_forum_post.return_value = "created_forum_post" + mock_fetch_item_name.return_value = "audacity4" + mock_fetch_item_name2.return_value = "audacity4" + update_queue = asyncio.Queue() + await update_queue.put(ProjectItemEvent(item_id=123, node_id="node_id", sender="test_sender")) + + await run(update_queue, stop_after_one_event=True) + + for _ in range(999): # up to ~1 seconds total + try: + mock_create_forum_post.assert_called() + break + except AssertionError: + pass + await asyncio.sleep(0.001) + else: + mock_create_forum_post.assert_called() diff --git a/src/tests/test_integration/test_server.py b/src/tests/test_integration/test_server.py new file mode 100644 index 0000000..9d5d688 --- /dev/null +++ b/src/tests/test_integration/test_server.py @@ -0,0 +1,71 @@ +import asyncio +import json +import logging +from typing import Any +from unittest.mock import patch + +from aiohttp import ClientSession +from fastapi.testclient import TestClient + +from src.server import app +from src.tests.conftest import MockResponse, MockShelf +from src.utils.signature_verification import generate_signature + +test_client = TestClient(app) +test_client.app.logger = logging.getLogger("uvicorn.error") +test_client.app.update_queue = asyncio.Queue() + + +def test_missing_body(): + response = test_client.post("/webhook_endpoint", data=None) + assert response.status_code == 400 + assert response.json() == {"detail": "Missing request body."} + + +def test_github_project_node_id_mismatch(): + payload: dict[str, Any] = { + "projects_v2_item": {"id": 123, "project_node_id": "wrong_id", "node_id": "123"}, + "action": "edited", + "changes": {"field_value": {"field_type": "title", "field_name": "Title"}}, + "sender": {"node_id": "456"}, + } + payload: str = json.dumps(payload) + signature = generate_signature( + "some_secret", + payload.encode("utf-8"), + ) + response = test_client.post( + "/webhook_endpoint", + content=payload, + headers={"X-Hub-Signature-256": signature}, + ) + assert response.status_code == 400 + assert response.json() == {"detail": "Invalid project_node_id."} + + +@patch.object(ClientSession, "post") +@patch("shelve.open") +@patch("os.getenv") +def test_edited_action(mock_os_getenv, mock_shelve_open, mock_post_request): + payload: dict[str, Any] = { + "projects_v2_item": {"id": 123, "project_node_id": "123", "node_id": "123"}, + "action": "edited", + "changes": {"field_value": {"field_type": "title", "field_name": "Title"}}, + "sender": {"node_id": "456"}, + } + payload: str = json.dumps(payload) + mock_os_getenv.side_effect = ["some_secret", "123", "some_token", "db-path.db"] + mock_shelve_open.return_value = MockShelf({"123": "Meow"}) + mock_post_request.return_value = MockResponse({"data": {"node": {"content": {"title": "Meow"}}}}) + signature = generate_signature( + "some_secret", + payload.encode("utf-8"), + ) + response = test_client.post( + "/webhook_endpoint", + content=payload, + headers={"X-Hub-Signature-256": signature}, + ) + assert response.json() == {"detail": "Successfully received webhook data"} + assert response.status_code == 200 + mock_post_request.assert_called() diff --git a/src/tests/test_unit/__init__.py b/src/tests/test_unit/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/tests/test_unit/test_bot.py b/src/tests/test_unit/test_bot.py new file mode 100644 index 0000000..e7c27bd --- /dev/null +++ b/src/tests/test_unit/test_bot.py @@ -0,0 +1,249 @@ +import asyncio +import logging +from unittest.mock import ANY, AsyncMock, patch + +import pytest +from hikari import RESTApp +from hikari.impl import RESTClientImpl + +from src import bot +from src.tests.conftest import RestClientContextManagerMock +from src.utils.data_types import SimpleProjectItemEvent +from src.utils.error import ForumChannelNotFound + + +@patch("src.bot.fetch_item_name", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "create_forum_post", new_callable=AsyncMock) +async def test_create_post( + mock_create_forum_post, + mock_fetch_item_name, + rest_client_mock, + shared_forum_channel_mock, + user_text_mention, +): + mock_fetch_item_name.return_value = "audacity4" + message = f"Nowy task stworzony audacity4 przez: {user_text_mention}.\n Link do taska: https://github.com/orgs/my-org/projects/1?pane=issue&item_id=1" + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "created") + await bot.create_post(event, user_text_mention, shared_forum_channel_mock, rest_client_mock, []) + mock_create_forum_post.assert_called_with( + shared_forum_channel_mock.forum_channel, event.node_id, message, auto_archive_duration=10080, user_mentions=[] + ) + + +@patch("src.bot.create_post", new_callable=AsyncMock) +@patch("src.bot.retrieve_discord_id") +@patch("src.bot.get_post_id_or_post", new_callable=AsyncMock) +async def test_process_no_post( + mock_get_post_id_or_post, + mock_retrieve_discord_id, + mock_create_post, + rest_client_mock, + shared_forum_channel_mock, + full_post_mock, + user_text_mention, +): + mock_get_post_id_or_post.return_value = None + mock_retrieve_discord_id.return_value = "123456789012345678" + mock_create_post.return_value = full_post_mock + event = SimpleProjectItemEvent(1, "node_id", "norbiros", "created") + await bot.process_update( + rest_client_mock, + 1, + 1, + shared_forum_channel_mock, + event, + ) + + mock_create_post.assert_called_with( + event, user_text_mention, shared_forum_channel_mock, rest_client_mock, ["123456789012345678"] + ) + + +@patch.object(RESTClientImpl, "fetch_channel", new_callable=AsyncMock) +@patch("src.bot.retrieve_discord_id") +@patch("src.bot.get_post_id_or_post", new_callable=AsyncMock) +async def test_process_post_id_found( + mock_get_post_id_or_post, + mock_retrieve_discord_id, + mock_fetch_channel, + rest_client_mock, + shared_forum_channel_mock, + full_post_mock, + user_text_mention, +): + mock_get_post_id_or_post.return_value = 67 + mock_retrieve_discord_id.return_value = "123456789012345678" + mock_fetch_channel.return_value = full_post_mock + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "created") + await bot.process_update( + rest_client_mock, + 1, + 1, + shared_forum_channel_mock, + event, + ) + + mock_fetch_channel.assert_called_with(67) + + +@patch("src.bot.create_post", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_channel", new_callable=AsyncMock) +@patch("src.bot.retrieve_discord_id") +@patch("src.bot.get_post_id_or_post", new_callable=AsyncMock) +async def test_process_post_fetched( + mock_get_post_id_or_post, + mock_retrieve_discord_id, + mock_fetch_channel, + mock_create_post, + rest_client_mock, + shared_forum_channel_mock, + full_post_mock, + user_text_mention, +): + mock_get_post_id_or_post.return_value = full_post_mock + mock_retrieve_discord_id.return_value = "123456789012345678" + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "created") + await bot.process_update( + rest_client_mock, + 1, + 1, + shared_forum_channel_mock, + event, + ) + + mock_fetch_channel.assert_not_called() + mock_create_post.assert_not_called() + + +@patch.object(logging.Logger, "error") +@patch("src.bot.retrieve_discord_id") +@patch("src.bot.get_post_id_or_post", new_callable=AsyncMock) +async def test_process_post_not_guild_public_thread( + mock_get_post_id_or_post, + mock_retrieve_discord_id, + mock_logger_error, + rest_client_mock, + shared_forum_channel_mock, + post_mock, + user_text_mention, +): + mock_get_post_id_or_post.return_value = post_mock + mock_retrieve_discord_id.return_value = "123456789012345678" + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "created") + await bot.process_update( + rest_client_mock, + 1, + 1, + shared_forum_channel_mock, + event, + ) + + mock_logger_error.assert_called_with("Post with ID 621 is not a GuildPublicThread.") + + +@patch.object(SimpleProjectItemEvent, "process", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "create_message", new_callable=AsyncMock) +@patch("src.bot.retrieve_discord_id") +@patch("src.bot.get_post_id_or_post", new_callable=AsyncMock) +async def test_process_post_created_message( + mock_get_post_id_or_post, + mock_retrieve_discord_id, + mock_create_message, + mock_event_process, + rest_client_mock, + shared_forum_channel_mock, + full_post_mock, + user_text_mention, +): + mock_get_post_id_or_post.return_value = full_post_mock + mock_retrieve_discord_id.return_value = "123456789012345678" + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "archived") + mock_event_process.return_value = "Test message content" + await bot.process_update( + rest_client_mock, + 1, + 1, + shared_forum_channel_mock, + event, + ) + + mock_create_message.assert_called_with(621, "Test message content", user_mentions=["123456789012345678"]) + + +@patch("src.bot.process_update", new_callable=AsyncMock) +@patch("src.bot.fetch_forum_channel", new_callable=AsyncMock) +@patch.object(RESTApp, "acquire") +@patch.object(RESTApp, "start", new_callable=AsyncMock) +@patch("os.getenv") +async def test_bot_run( + mock_os_getenv, + _mock_restapp_start, + mock_restapp_acquire, + mock_fetch_forum_channel, + mock_process_update, + rest_client_mock, + forum_channel_mock, +): + mock_os_getenv.side_effect = ["some_token", 1, 2] + mock_restapp_acquire.return_value = RestClientContextManagerMock(rest_client_mock) + mock_fetch_forum_channel.return_value = forum_channel_mock + state = asyncio.Queue() + await state.put("event") + + await bot.run(state, stop_after_one_event=True) + mock_process_update.assert_called_with(rest_client_mock, 1, 2, ANY, "event") + + +@patch("src.bot.fetch_forum_channel", new_callable=AsyncMock) +@patch.object(RESTApp, "acquire") +@patch.object(RESTApp, "start", new_callable=AsyncMock) +@patch("os.getenv") +async def test_bot_run_forum_channel_is_none( + mock_os_getenv, + _mock_restapp_start, + mock_restapp_acquire, + mock_fetch_forum_channel, + rest_client_mock, +): + mock_os_getenv.side_effect = ["some_token", 1, 2] + mock_restapp_acquire.return_value = RestClientContextManagerMock(rest_client_mock) + mock_fetch_forum_channel.return_value = None + state = asyncio.Queue() + + with pytest.raises(ForumChannelNotFound): + await bot.run(state, stop_after_one_event=True) + + +@patch("src.bot.bot_logger.error") +@patch("src.bot.process_update", new_callable=AsyncMock) +@patch("src.bot.fetch_forum_channel", new_callable=AsyncMock) +@patch.object(RESTApp, "acquire") +@patch.object(RESTApp, "start", new_callable=AsyncMock) +@patch("os.getenv") +async def test_bot_run_exception_during_process( + mock_os_getenv, + _mock_restapp_start, + mock_restapp_acquire, + mock_fetch_forum_channel, + mock_process_update, + mock_logger_error, + rest_client_mock, + forum_channel_mock, +): + mock_os_getenv.side_effect = ["some_token", 1, 2] + mock_restapp_acquire.return_value = RestClientContextManagerMock(rest_client_mock) + mock_fetch_forum_channel.return_value = forum_channel_mock + mock_process_update.side_effect = Exception("Some error occurred") + state = asyncio.Queue() + await state.put("event") + + await bot.run(state, stop_after_one_event=True) + for _ in range(500): # up to ~0.5 seconds total + try: + mock_logger_error.assert_called_with("Error processing update: Some error occurred") + break + except AssertionError: + pass + await asyncio.sleep(0.001) + else: + pytest.fail("Expected log 'Error processing update: Some error occurred' not found in output") diff --git a/src/tests/test_unit/test_process.py b/src/tests/test_unit/test_process.py new file mode 100644 index 0000000..50eb1a2 --- /dev/null +++ b/src/tests/test_unit/test_process.py @@ -0,0 +1,224 @@ +from unittest.mock import AsyncMock, mock_open, patch + +from hikari import ForumTag, Snowflake +from hikari.impl import RESTClientImpl + +from src.utils.data_types import ( + ProjectItemEditedAssignees, + ProjectItemEditedBody, + ProjectItemEditedSingleSelect, + ProjectItemEditedTitle, + SimpleProjectItemEvent, +) + + +@patch.object(RESTClientImpl, "edit_channel") +async def test_simple_project_item_event_process_archived( + mock_edit_channel, user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock +): + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "archived") + assert ( + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + == "Task zarchiwizowany przez: <@123456789012345678>." + ) + mock_edit_channel.assert_called_with(post_mock.id, archived=True) + + +@patch.object(RESTClientImpl, "edit_channel") +async def test_simple_project_item_event_process_restored( + mock_edit_channel, user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock +): + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "restored") + assert ( + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + == "Task przywrócony przez: <@123456789012345678>." + ) + mock_edit_channel.assert_called_with(post_mock.id, archived=False) + + +@patch.object(RESTClientImpl, "delete_channel") +async def test_simple_project_item_event_process_deleted( + mock_delete_channel, user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock +): + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "deleted") + assert ( + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + is None + ) + mock_delete_channel.assert_called_with(post_mock.id) + + +async def test_simple_project_item_event_process_created( + user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock +): + event = SimpleProjectItemEvent(1, "audacity4", "norbiros", "created") + assert ( + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + is None + ) + + +async def test_project_item_edited_body(user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock): + event = ProjectItemEditedBody(1, "audacity4", "norbiros", "edited_body") + assert ( + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + == "Opis taska zaktualizowany przez: <@123456789012345678>. Nowy opis: \nedited_body" + ) + + +@patch.object(RESTClientImpl, "create_message") +@patch("builtins.open", new_callable=mock_open, read_data="node_id1: 123\nnode_id2: 321\n") +async def test_project_item_edited_assignees(user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock): + event = ProjectItemEditedAssignees(1, "audacity4", "norbiros", ["node_id1", "node_id2"]) + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + + rest_client_mock.create_message.assert_called_with( + post_mock.id, + "Osoby przypisane do taska edytowane, aktualni przypisani: <@123>, <@321>", + user_mentions=[123, 321], + ) + + +@patch.object(RESTClientImpl, "create_message") +@patch("builtins.open", new_callable=mock_open, read_data="") +async def test_project_item_edited_assignees_not_in_mapping( + user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock +): + event = ProjectItemEditedAssignees(1, "audacity4", "norbiros", ["node_id1", "node_id2"]) + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + + rest_client_mock.create_message.assert_called_with( + post_mock.id, "Osoby przypisane do taska edytowane, aktualni przypisani: ", user_mentions=[] + ) + + +@patch.object(RESTClientImpl, "create_message") +@patch("builtins.open", new_callable=mock_open, read_data="") +async def test_project_item_edited_assignees_no_assignees( + user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock +): + event = ProjectItemEditedAssignees(1, "audacity4", "norbiros", []) + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + + rest_client_mock.create_message.assert_called_with( + post_mock.id, + "Osoby przypisane do taska edytowane, aktualni przypisani: Brak przypisanych osób", + user_mentions=[], + ) + + +@patch.object(RESTClientImpl, "edit_channel") +async def test_project_item_edited_title( + mock_edit_channel, user_text_mention, post_mock, rest_client_mock, shared_forum_channel_mock +): + event = ProjectItemEditedTitle(1, "audacity4", "norbiros", "edited_title") + await event.process( + user_text_mention, + post_mock, + rest_client_mock, + shared_forum_channel_mock, + shared_forum_channel_mock.forum_channel.id, + ) + mock_edit_channel.assert_called_with(post_mock.id, name="edited_title") + + +@patch.object(RESTClientImpl, "edit_channel") +async def test_project_item_edited_single_select_existing_tag( + mock_edit_channel, + user_text_mention, + full_post_mock, + rest_client_mock, + shared_forum_channel_mock, + forum_channel_mock, +): + event = ProjectItemEditedSingleSelect(1, "audacity4", "norbiros", "smol", "Size") + await event.process( + user_text_mention, + full_post_mock, + rest_client_mock, + shared_forum_channel_mock, + forum_channel_mock.id, + ) + + mock_edit_channel.assert_called_with(full_post_mock.id, applied_tags=[Snowflake(1)]) + + +@patch("src.utils.data_types.get_new_tag") +@patch("src.utils.data_types.fetch_forum_channel", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "edit_channel") +async def test_project_item_edited_single_select_tag_unavailable( + mock_edit_channel, + mock_fetch_forum_channel, + mock_get_new_tag, + user_text_mention, + full_post_mock, + rest_client_mock, + shared_forum_channel_mock, + forum_channel_mock, +): + event = ProjectItemEditedSingleSelect(1, "audacity4", "norbiros", "medium", "Size") + new_tag = ForumTag(id=Snowflake(0), name="Size: medium") + mock_fetch_forum_channel.return_value = forum_channel_mock + mock_get_new_tag.side_effect = [None, new_tag] + + await event.process( + user_text_mention, + full_post_mock, + rest_client_mock, + shared_forum_channel_mock, + forum_channel_mock.id, + ) + + mock_edit_channel.assert_any_call( + 67, + available_tags=[*shared_forum_channel_mock.forum_channel.available_tags, new_tag], + ) + mock_edit_channel.assert_called_with(full_post_mock.id, applied_tags=[Snowflake(0)]) diff --git a/src/tests/test_unit/test_server.py b/src/tests/test_unit/test_server.py new file mode 100644 index 0000000..61b8c3d --- /dev/null +++ b/src/tests/test_unit/test_server.py @@ -0,0 +1,93 @@ +from unittest.mock import AsyncMock, patch + +import pytest + +from src.server import process_action, process_edition +from src.utils.data_types import ( + Body, + Changes, + FieldValue, + FieldValueTo, + ProjectItemEditedAssignees, + ProjectItemEditedBody, + ProjectItemEditedSingleSelect, + ProjectItemEditedTitle, + ProjectV2Item, + Sender, + SimpleProjectItemEvent, + WebhookRequest, +) + + +@pytest.fixture +def mock_webhook_request_model(): + projects_v2_item = ProjectV2Item(id=1, project_node_id="node_id", node_id="node_id") + sender = Sender(node_id="node_id") + return WebhookRequest( + projects_v2_item=projects_v2_item, action="edited", sender=sender, changes=Changes(body=Body(to="placeholder")) + ) + + +async def test_process_edition_body_changes(mock_webhook_request_model): + mock_webhook_request_model.changes = Changes(body=Body(to="We need to pet more cats")) + expected_object = ProjectItemEditedBody(1, "node_id", "node_id", "We need to pet more cats") + + assert await process_edition(mock_webhook_request_model) == expected_object + + +@patch("src.server.fetch_assignees") +async def test_process_edition_assignees_changed(mock_fetch_assignees, mock_webhook_request_model): + mock_webhook_request_model.changes = Changes(field_value=FieldValue(field_name="Assignees", field_type="assignees")) + new_assignees = ["Kubaryt", "Salieri", "Aniela"] + mock_fetch_assignees.return_value = new_assignees + expected_object = ProjectItemEditedAssignees(1, "node_id", "node_id", new_assignees) + + assert await process_edition(mock_webhook_request_model) == expected_object + + +@patch("src.server.fetch_item_name") +async def test_process_edition_title_changed(mock_fetch_item_name, mock_webhook_request_model): + mock_webhook_request_model.changes = Changes(field_value=FieldValue(field_name="Title", field_type="title")) + new_item_name = "ActuallyNotFunAtAll" + mock_fetch_item_name.return_value = new_item_name + expected_object = ProjectItemEditedTitle(1, "node_id", "node_id", new_item_name) + + assert await process_edition(mock_webhook_request_model) == expected_object + + +async def test_process_edition_single_select_changed(mock_webhook_request_model): + mock_webhook_request_model.changes = Changes( + field_value=FieldValue( + field_name="Size", field_type="single_select", to=FieldValueTo(name="Smol like lil kitten") + ) + ) + expected_object = ProjectItemEditedSingleSelect(1, "node_id", "node_id", "Smol like lil kitten", "Size") + + assert await process_edition(mock_webhook_request_model) == expected_object + + +async def test_process_edition_iteration_changed(mock_webhook_request_model): + new_title = "1.0.0 - FinallyWeShipItAfter25Years" + mock_webhook_request_model.changes = Changes( + field_value=FieldValue(field_name="Iteration", field_type="iteration", to=FieldValueTo(title=new_title)) + ) + expected_object = ProjectItemEditedSingleSelect(1, "node_id", "node_id", new_title, "Iteration") + + assert await process_edition(mock_webhook_request_model) == expected_object + + +@patch("src.server.process_edition", new_callable=AsyncMock) +async def test_process_action_process_edition(mock_process_edition, mock_webhook_request_model): + test_event = SimpleProjectItemEvent(1, "node_id", "node_id", "created") + mock_process_edition.return_value = test_event + + assert await process_action(mock_webhook_request_model) == test_event + + +@patch("src.server.process_edition", new_callable=AsyncMock) +async def test_process_action_simple_event(mock_process_edition, mock_webhook_request_model): + mock_webhook_request_model.action = "created" + test_event = SimpleProjectItemEvent(1, "node_id", "node_id", "created") + mock_process_edition.return_value = test_event + + assert await process_action(mock_webhook_request_model) == test_event diff --git a/src/tests/test_unit/test_utils/__init__.py b/src/tests/test_unit/test_utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/tests/test_unit/test_utils/test_datatypes.py b/src/tests/test_unit/test_utils/test_datatypes.py new file mode 100644 index 0000000..931f238 --- /dev/null +++ b/src/tests/test_unit/test_utils/test_datatypes.py @@ -0,0 +1,23 @@ +import pytest + +from src.utils.data_types import SimpleProjectItemEventType, SingleSelectType + + +def test_action_type_to_event_type(): + assert SimpleProjectItemEventType("created") == SimpleProjectItemEventType.CREATED + assert SimpleProjectItemEventType("archived") == SimpleProjectItemEventType.ARCHIVED + assert SimpleProjectItemEventType("restored") == SimpleProjectItemEventType.RESTORED + assert SimpleProjectItemEventType("deleted") == SimpleProjectItemEventType.DELETED + with pytest.raises(ValueError): + SimpleProjectItemEventType("unknown") + + +def test_field_name_to_event_type(): + assert SingleSelectType("Status") == SingleSelectType.STATUS + assert SingleSelectType("Priority") == SingleSelectType.PRIORITY + assert SingleSelectType("Size") == SingleSelectType.SIZE + assert SingleSelectType("Iteration") == SingleSelectType.ITERATION + assert SingleSelectType("Section") == SingleSelectType.SECTION + + with pytest.raises(ValueError): + SingleSelectType("Unknown") diff --git a/src/tests/test_unit/test_utils/test_discord_rest_client.py b/src/tests/test_unit/test_utils/test_discord_rest_client.py new file mode 100644 index 0000000..a336fe0 --- /dev/null +++ b/src/tests/test_unit/test_utils/test_discord_rest_client.py @@ -0,0 +1,109 @@ +from unittest.mock import AsyncMock, patch + +from hikari import ForumTag, Snowflake +from hikari.impl import RESTClientImpl + +from src.tests.conftest import MockShelf +from src.utils import discord_rest_client + + +@patch.object(RESTClientImpl, "fetch_channel", new_callable=AsyncMock) +async def test_fetch_forum_channel_success(mock_fetch_channel, rest_client_mock, forum_channel_mock): + mock_fetch_channel.return_value = forum_channel_mock + + assert await discord_rest_client.fetch_forum_channel(rest_client_mock, 67) == forum_channel_mock + + +@patch.object(RESTClientImpl, "fetch_channel", new_callable=AsyncMock) +async def test_fetch_forum_channel_none(mock_fetch_channel, rest_client_mock): + mock_fetch_channel.return_value = None + + assert await discord_rest_client.fetch_forum_channel(rest_client_mock, 67) is None + + +@patch.object(RESTClientImpl, "fetch_channel", new_callable=AsyncMock) +async def test_fetch_forum_channel_not_forum_channel(mock_fetch_channel, rest_client_mock, post_mock): + mock_fetch_channel.return_value = post_mock + + assert await discord_rest_client.fetch_forum_channel(rest_client_mock, 67) is None + + +def test_get_new_tag_success(): + tag1 = ForumTag(id=Snowflake(1), name="enchantment", moderated=False) + available_tags = [tag1] + + assert discord_rest_client.get_new_tag("enchantment", available_tags) == tag1 + + +def test_get_new_tag_none(): + tag1 = ForumTag(id=Snowflake(1), name="enchantment", moderated=False) + available_tags = [tag1] + + assert discord_rest_client.get_new_tag("build", available_tags) is None + + +@patch("shelve.open") +async def test_get_post_id_exist_in_db(mock_shelve_open, rest_client_mock): + mock_db = {"node_id": 621} + mock_shelve_open.return_value = MockShelf(mock_db) + + assert await discord_rest_client.get_post_id_or_post("node_id", 1, 1, rest_client_mock) == 621 + + +@patch("src.utils.discord_rest_client.fetch_item_name", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_active_threads", new_callable=AsyncMock) +@patch("shelve.open") +async def test_get_post_id_active_thread( + mock_shelve_open, mock_fetch_active_threads, mock_fetch_item_name, rest_client_mock, post_mock +): + mock_shelf = MockShelf({}) + mock_shelve_open.return_value = mock_shelf + mock_fetch_active_threads.return_value = [post_mock] + mock_fetch_item_name.return_value = "audacity4" + + assert await discord_rest_client.get_post_id_or_post("node_id", 1, 1, rest_client_mock) == post_mock + assert mock_shelf.get("audacity4") == 621 + + +@patch("src.utils.discord_rest_client.fetch_item_name", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_public_archived_threads", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_active_threads", new_callable=AsyncMock) +@patch("shelve.open") +async def test_get_post_id_archived_thread( + mock_shelve_open, + mock_fetch_active_threads, + mock_fetch_public_archived_threads, + mock_fetch_item_name, + rest_client_mock, + post_mock, +): + mock_shelf = MockShelf({}) + mock_shelve_open.return_value = mock_shelf + mock_fetch_active_threads.return_value = [] + mock_fetch_public_archived_threads.return_value = [post_mock] + mock_fetch_item_name.return_value = "audacity4" + + assert await discord_rest_client.get_post_id_or_post("node_id", 1, 1, rest_client_mock) == post_mock + assert mock_shelf.get("audacity4") == 621 + + +@patch("src.utils.discord_rest_client.fetch_item_name", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_public_archived_threads", new_callable=AsyncMock) +@patch.object(RESTClientImpl, "fetch_active_threads", new_callable=AsyncMock) +@patch("shelve.open") +async def test_get_post_id_none( + mock_shelve_open, + mock_fetch_active_threads, + mock_fetch_public_archived_threads, + mock_fetch_item_name, + rest_client_mock, + post_mock, +): + mock_shelf = MockShelf({}) + mock_shelve_open.return_value = mock_shelf + mock_fetch_active_threads.return_value = [] + mock_fetch_public_archived_threads.return_value = [] + mock_fetch_item_name.return_value = "audacity4" + + assert await discord_rest_client.get_post_id_or_post("node_id", 1, 1, rest_client_mock) is None + assert mock_shelf.get("audacity4") is None diff --git a/src/tests/test_unit/test_utils/test_github_api.py b/src/tests/test_unit/test_utils/test_github_api.py new file mode 100644 index 0000000..d0a07eb --- /dev/null +++ b/src/tests/test_unit/test_utils/test_github_api.py @@ -0,0 +1,82 @@ +from unittest.mock import AsyncMock, patch + +import pytest +from fastapi import HTTPException + +from src.utils import github_api + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_item_name_success(mock_send_request): + mock_send_request.return_value = {"data": {"node": {"content": {"title": "42"}}}} + + assert await github_api.fetch_item_name("") == "42" + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_item_name_partial(mock_send_request): + mock_send_request.return_value = {"data": {"node": {"content": None}}} + + with pytest.raises(HTTPException) as exception: + await github_api.fetch_item_name("") + + assert exception.value.status_code == 500 + assert exception.value.detail == "Could not fetch item name." + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_item_name_none(mock_send_request): + mock_send_request.return_value = {} + + with pytest.raises(HTTPException) as exception: + await github_api.fetch_item_name("") + assert exception.value.status_code == 500 + assert exception.value.detail == "Could not fetch item name." + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_assignees_success(mock_send_request): + mock_send_request.return_value = { + "data": { + "node": { + "content": {"assignees": {"nodes": [{"id": "MDQ6VXNlcjg4MjY4MDYz"}, {"id": "MDQ6VXNlcjg5ODM3NzI0"}]}} + } + } + } + + assert await github_api.fetch_assignees("") == ["MDQ6VXNlcjg4MjY4MDYz", "MDQ6VXNlcjg5ODM3NzI0"] + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_assignees_partial(mock_send_request): + mock_send_request.return_value = {"data": {"node": {"content": None}}} + + assert await github_api.fetch_assignees("") == [] + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_assignees_none(mock_send_request): + mock_send_request.return_value = {} + + assert await github_api.fetch_assignees("") == [] + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_single_select_value_success(mock_send_request): + mock_send_request.return_value = {"data": {"node": {"fieldValueByName": {"name": "Dziengiel"}}}} + + assert await github_api.fetch_single_select_value("", "Salieri") == "Dziengiel" + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_single_select_value_partial(mock_send_request): + mock_send_request.return_value = {"data": {"node": {"fieldValueByName": None}}} + + assert await github_api.fetch_single_select_value("", "Salieri") is None + + +@patch("src.utils.github_api.send_request", new_callable=AsyncMock) +async def test_fetch_single_select_value_none(mock_send_request): + mock_send_request.return_value = {} + + assert await github_api.fetch_single_select_value("", "Salieri") is None diff --git a/src/tests/test_unit/test_utils/test_misc.py b/src/tests/test_unit/test_utils/test_misc.py new file mode 100644 index 0000000..35c1857 --- /dev/null +++ b/src/tests/test_unit/test_utils/test_misc.py @@ -0,0 +1,89 @@ +import asyncio +import logging +from io import StringIO +from unittest.mock import mock_open, patch + +from src.utils import misc + + +@patch("builtins.open", new_callable=mock_open, read_data='MDQ6VXNlcjY2NTE0ODg1: "393756120952602625"') +@patch("yaml.load") +def test_retrieve_discord_id_present_id(mock_yaml_load, _mock_open_file): + mock_yaml_load.return_value = {"MDQ6VXNlcjY2NTE0ODg1": "393756120952602625"} + + assert misc.retrieve_discord_id("MDQ6VXNlcjY2NTE0ODg1") == "393756120952602625" + + +@patch("builtins.open", new_callable=mock_open, read_data="") +def test_retrieve_discord_id_absent_id(_mock_open_file): + assert misc.retrieve_discord_id("") is None + + +def test_bot_logger_prefix(): + stream = StringIO() + + logger = misc.get_bot_logger() + logger.setLevel(logging.INFO) + + handler = logging.StreamHandler(stream) + handler.setFormatter(logging.Formatter("%(levelname)s %(message)s")) + logger.handlers.clear() + logger.addHandler(handler) + + logger.info("hello") + + output = stream.getvalue().strip() + assert output == "INFO [BOT] hello" + + +async def test_shared_forum_channel_concurrent_readers(shared_forum_channel_mock): + started = asyncio.Event() + completed = [] + + async def reader(reader_id): + async with shared_forum_channel_mock.lock.reader_lock: + await started.wait() + completed.append(reader_id) + + tasks = [asyncio.create_task(reader(i)) for i in range(5)] + started.set() + await asyncio.gather(*tasks) + + assert sorted(completed) == [0, 1, 2, 3, 4] + + +async def test_shared_forum_channel_writer_blocks_readers(shared_forum_channel_mock): + enter_order = [] + + async def writer(): + async with shared_forum_channel_mock.lock.writer_lock: + enter_order.append("writer") + await asyncio.sleep(0.1) + + async def reader(): + async with shared_forum_channel_mock.lock.reader_lock: + enter_order.append("reader") + + writer_task = asyncio.create_task(writer()) + + reader_task = asyncio.create_task(reader()) + await asyncio.gather(writer_task, reader_task) + + assert enter_order == ["writer", "reader"] + + +async def test_shared_forum_channel_writers_are_exclusive(shared_forum_channel_mock): + execution = [] + + async def writer(writer_id): + async with shared_forum_channel_mock.lock.writer_lock: + execution.append(writer_id) + await asyncio.sleep(0.05) + + t1 = asyncio.create_task(writer(1)) + t2 = asyncio.create_task(writer(2)) + + await asyncio.gather(t1, t2) + + assert execution == [1, 2] or execution == [2, 1] + assert execution[0] != execution[1] diff --git a/src/tests/test_unit/test_utils/test_signature_verification.py b/src/tests/test_unit/test_utils/test_signature_verification.py new file mode 100644 index 0000000..9a622ba --- /dev/null +++ b/src/tests/test_unit/test_utils/test_signature_verification.py @@ -0,0 +1,77 @@ +from logging import Logger +from unittest.mock import patch + +import pytest +from fastapi import HTTPException + +from src.utils import signature_verification + + +def test_generate_signature(): + expected_signature = "sha256=9b40ac77c0653bed6e678ebd8db8b8d96a7c8ea8983b1a77577797d0a43b97c6" + signature = signature_verification.generate_signature("H-letter", b"I freaking love H letter") + + assert signature == expected_signature + + +def test_verify_secret_correct(): + secret = "H-letter" + payload = b"I freaking love H letter" + signature_header = "sha256=9b40ac77c0653bed6e678ebd8db8b8d96a7c8ea8983b1a77577797d0a43b97c6" + + assert signature_verification.verify_secret(secret, payload, signature_header) + + +def test_verify_secret_incorrect(): + secret = "H-letter" + payload = b"malicious" + signature_header = "sha256=9b40ac77c0653bed6e678ebd8db8b8d96a7c8ea8983b1a77577797d0a43b97c6" + + assert not signature_verification.verify_secret(secret, payload, signature_header) + + +@patch.object(Logger, "warning") +@patch("os.getenv") +def test_verify_signature_correct(mock_getenv, mock_logger_warning): + signature = "sha256=9b40ac77c0653bed6e678ebd8db8b8d96a7c8ea8983b1a77577797d0a43b97c6" + body_bytes = b"I freaking love H letter" + mock_getenv.return_value = "H-letter" + + signature_verification.verify_signature(signature, body_bytes) + mock_logger_warning.assert_not_called() + + +@patch("os.getenv") +def test_verify_signature_incorrect(mock_getenv): + signature = "sha256=9b40ac77c0653bed6e678ebd8db8b8d96a7c8ea8983b1a77577797d0a43b97c6" + body_bytes = b"I freaking love H letter" + mock_getenv.return_value = "K-letter" + + with pytest.raises(HTTPException) as error: + signature_verification.verify_signature(signature, body_bytes) + + assert error.value.status_code == 401 + assert error.value.detail == "Invalid signature." + + +@patch("os.getenv") +def test_verify_signature_missing(mock_getenv): + body_bytes = b"I freaking love H letter" + mock_getenv.return_value = "K-letter" + + with pytest.raises(HTTPException) as error: + signature_verification.verify_signature("", body_bytes) + + assert error.value.status_code == 401 + assert error.value.detail == "Missing signature." + + +@patch.object(Logger, "warning") +@patch("os.getenv") +def test_verify_signature_not_set(mock_getenv, mock_logger_warning): + signature = "sha256=9b40ac77c0653bed6e678ebd8db8b8d96a7c8ea8983b1a77577797d0a43b97c6" + body_bytes = b"I freaking love H letter" + mock_getenv.return_value = "" + + signature_verification.verify_signature(signature, body_bytes) + mock_logger_warning.assert_called_with("GITHUB_WEBHOOK_SECRET is not set; skipping signature verification.") diff --git a/src/utils/__init__.py b/src/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/utils/data_types.py b/src/utils/data_types.py new file mode 100644 index 0000000..49d5c7e --- /dev/null +++ b/src/utils/data_types.py @@ -0,0 +1,275 @@ +from dataclasses import dataclass +from enum import Enum +from typing import Literal + +from hikari import ForumTag, GuildForumChannel, GuildPublicThread +from hikari.impl import RESTClientImpl +from pydantic import BaseModel, ConfigDict, Field, model_validator +from pydantic_core import PydanticCustomError + +from src.utils.discord_rest_client import fetch_forum_channel, get_new_tag +from src.utils.error import ForumChannelNotFound +from src.utils.misc import SharedForumChannel, bot_logger, retrieve_discord_id + + +class SimpleProjectItemEventType(Enum): + CREATED = "created" + ARCHIVED = "archived" + RESTORED = "restored" + DELETED = "deleted" + + +class SingleSelectType(Enum): + STATUS = "Status" + PRIORITY = "Priority" + SIZE = "Size" + ITERATION = "Iteration" + SECTION = "Section" + + +@dataclass +class ProjectItemEvent: + # Used for appending link to Discord post + item_id: int + # Used for request to GitHub API + node_id: str + sender: str + + async def process( + self, + user_text_mention: str, + post: GuildPublicThread, + client: RESTClientImpl, + shared_forum_channel: SharedForumChannel, + forum_channel_id: int, + ) -> str | GuildForumChannel | None: + """ + Interface method to process the event and optionally return message to be posted in Discord. + """ + + +class SimpleProjectItemEvent(ProjectItemEvent): + def __init__(self, item_id: int, node_id: str, sender: str, action_type: str): + super().__init__(item_id, node_id, sender) + self.event_type = SimpleProjectItemEventType(action_type) + + async def process( + self, + user_text_mention: str, + post: GuildPublicThread, + client: RESTClientImpl, + _shared_forum_channel: SharedForumChannel, + _forum_channel_id: int, + ) -> str | None: + match self.event_type: + case SimpleProjectItemEventType.ARCHIVED: + message = f"Task zarchiwizowany przez: {user_text_mention}." + await client.edit_channel(post.id, archived=True) + bot_logger.info(f"Post {self.node_id} archived.") + return message + case SimpleProjectItemEventType.RESTORED: + message = f"Task przywrócony przez: {user_text_mention}." + await client.edit_channel(post.id, archived=False) + bot_logger.info(f"Post {self.node_id} restored.") + return message + case SimpleProjectItemEventType.DELETED: + await client.delete_channel(post.id) + bot_logger.info(f"Post {self.node_id} deleted.") + return None + case _: + return None + + +class ProjectItemEditedBody(ProjectItemEvent): + def __init__(self, item_id: int, node_id: str, editor: str, new_body: str): + super().__init__(item_id, node_id, editor) + self.new_body = new_body + + async def process( + self, + user_text_mention: str, + _post: GuildPublicThread, + client: RESTClientImpl, + _shared_forum_channel: SharedForumChannel, + forum_channel_id: int, + ) -> str: + message = f"Opis taska zaktualizowany przez: {user_text_mention}. Nowy opis: \n{self.new_body}" + bot_logger.info(f"Post {self.node_id} body updated.") + + return message + + +class ProjectItemEditedAssignees(ProjectItemEvent): + def __init__(self, item_id: int, node_id: str, editor: str, new_assignees: list[str]): + super().__init__(item_id, node_id, editor) + self.new_assignees = new_assignees + + async def process( + self, + user_text_mention: str, + post: GuildPublicThread, + client: RESTClientImpl, + _shared_forum_channel: SharedForumChannel, + forum_channel_id: int, + ) -> None: + assignee_mentions: list[str] = [] + assignee_discord_ids: list[int] = [] + if self.new_assignees: + for assignee in self.new_assignees: + discord_id = retrieve_discord_id(assignee) + if discord_id: + assignee_mentions.append(f"<@{discord_id}>") + assignee_discord_ids.append(int(discord_id)) + else: + assignee_mentions.append("Brak przypisanych osób") + + message = f"Osoby przypisane do taska edytowane, aktualni przypisani: {', '.join(assignee_mentions)}" + await client.create_message(post.id, message, user_mentions=assignee_discord_ids) + bot_logger.info(f"Post {self.node_id} assignees updated.") + + +class ProjectItemEditedTitle(ProjectItemEvent): + def __init__(self, item_id: int, node_id: str, editor: str, new_name: str): + super().__init__(item_id, node_id, editor) + self.new_title = new_name + + async def process( + self, + user_text_mention: str, + post: GuildPublicThread, + client: RESTClientImpl, + _shared_forum_channel: SharedForumChannel, + forum_channel_id: int, + ) -> None: + await client.edit_channel(post.id, name=self.new_title) + bot_logger.info(f"Post {self.node_id} title updated to {self.new_title}.") + + +class ProjectItemEditedSingleSelect(ProjectItemEvent): + def __init__(self, item_id: int, node_id: str, editor: str, new_value: str, field_name: str): + super().__init__(item_id, node_id, editor) + self.new_value = new_value + self.value_type = SingleSelectType(field_name) + + async def process( + self, + user_text_mention: str, + post: GuildPublicThread, + client: RESTClientImpl, + shared_forum_channel: SharedForumChannel, + forum_channel_id: int, + ) -> None: + async with shared_forum_channel.lock.reader_lock: + available_tags = list(shared_forum_channel.forum_channel.available_tags) + current_tag_ids = list(post.applied_tag_ids) + + for tag in available_tags: + if tag.id in current_tag_ids and tag.name.startswith(f"{self.value_type.value}: "): + current_tag_ids.remove(tag.id) + + new_tag_name = f"{self.value_type.value}: {self.new_value}"[:48] + new_tag = get_new_tag(new_tag_name, available_tags) + + if new_tag is None: + bot_logger.info(f"Tag {new_tag_name} not found, creating new tag.") + await client.edit_channel(forum_channel_id, available_tags=[*available_tags, ForumTag(name=new_tag_name)]) + forum_channel = await fetch_forum_channel(client, forum_channel_id) + if forum_channel is None: + raise ForumChannelNotFound(f"Forum channel with ID {forum_channel_id} not found.") + async with shared_forum_channel.lock.writer_lock: + shared_forum_channel.forum_channel = forum_channel + async with shared_forum_channel.lock.reader_lock: + available_tags = list(shared_forum_channel.forum_channel.available_tags) + new_tag = get_new_tag(new_tag_name, available_tags) + + current_tag_ids.append(new_tag.id) + + await client.edit_channel(post.id, applied_tags=current_tag_ids) + bot_logger.info(f"Post {self.node_id} tag updated to {new_tag_name}.") + + +class ProjectV2Item(BaseModel): + item_id: int = Field(alias="id") + node_id: str + project_node_id: str + + model_config = ConfigDict(extra="allow") + + +class Sender(BaseModel): + node_id: str + + model_config = ConfigDict(extra="allow") + + +class Body(BaseModel): + to: str + + model_config = ConfigDict(extra="allow") + + +class FieldValueTo(BaseModel): + name: str | None = None + title: str | None = None + + model_config = ConfigDict(extra="allow") + + @model_validator(mode="after") + def check_name_or_title(self): + if self.name is None and self.title is None: + raise PydanticCustomError( + "missing_name_or_title", + "either 'name' or 'title' must be provided in field_value.to", + ) + return self + + +class FieldValue(BaseModel): + field_type: Literal["assignees", "title", "single_select", "iteration"] + to: FieldValueTo | None = None + field_name: str + + model_config = ConfigDict(extra="allow") + + @model_validator(mode="after") + def check_iteration_must_have_to(self): + if self.field_type == "iteration" and self.to is None: + raise PydanticCustomError( + "missing_to", + "'to' must be provided in field_value when field_type is 'single_select' or 'iteration'", + ) + return self + + +class Changes(BaseModel): + body: Body | None = None + field_value: FieldValue | None = None + + model_config = ConfigDict(extra="allow") + + @model_validator(mode="after") + def check_name_or_title(self): + if self.body is None and self.field_value is None: + raise PydanticCustomError( + "missing_name_or_title", + "either 'body' or 'field_value' must be provided in body.changes", + ) + return self + + +class WebhookRequest(BaseModel): + projects_v2_item: ProjectV2Item + action: str + sender: Sender + changes: Changes | None = None + + @model_validator(mode="after") + def changes_must_be_present_for_edited_action(self): + if self.action == "edited" and self.changes is None: + raise PydanticCustomError( + "missing_changes", + "'changes' must be provided in webhook request when action is 'edited'", + ) + return self + + model_config = ConfigDict(extra="allow") diff --git a/src/utils/discord_rest_client.py b/src/utils/discord_rest_client.py new file mode 100644 index 0000000..90adee6 --- /dev/null +++ b/src/utils/discord_rest_client.py @@ -0,0 +1,41 @@ +import os +import shelve + +from hikari import ForumTag, GuildForumChannel, GuildThreadChannel +from hikari.impl import RESTClientImpl + +from src.utils.github_api import fetch_item_name + + +async def fetch_forum_channel(client: RESTClientImpl, forum_channel_id: int) -> GuildForumChannel | None: + forum_channel = await client.fetch_channel(forum_channel_id) + if forum_channel is None or not isinstance(forum_channel, GuildForumChannel): + return None + return forum_channel + + +def get_new_tag(new_tag_name: str, available_tags: list[ForumTag]) -> ForumTag | None: + new_tag = next((tag for tag in available_tags if tag.name == new_tag_name), None) + return new_tag + + +async def get_post_id_or_post( + node_id: str, discord_guild_id: int, forum_channel_id: int, rest_client: RESTClientImpl +) -> int | GuildThreadChannel | None: + with shelve.open(os.getenv("POST_ID_DB_PATH", "post_id.db")) as db: + try: + post_id: str = db[node_id] + return int(post_id) + except KeyError: + pass + name = await fetch_item_name(node_id) + for thread in await rest_client.fetch_active_threads(discord_guild_id): + if thread.name == name: + db[name] = thread.id + return thread + for thread in await rest_client.fetch_public_archived_threads(forum_channel_id): + if thread.name == name: + db[name] = thread.id + return thread + + return None diff --git a/src/utils/error.py b/src/utils/error.py new file mode 100644 index 0000000..ff33dca --- /dev/null +++ b/src/utils/error.py @@ -0,0 +1,2 @@ +class ForumChannelNotFound(SystemExit): + pass diff --git a/src/utils/github_api.py b/src/utils/github_api.py new file mode 100644 index 0000000..503eaba --- /dev/null +++ b/src/utils/github_api.py @@ -0,0 +1,123 @@ +import os + +import aiohttp +from fastapi import HTTPException + + +async def send_request(query: str, variables: dict) -> dict: + async with aiohttp.ClientSession() as session: + async with session.post( + "https://api.github.com/graphql", + json={"query": query, "variables": variables}, + headers={"Authorization": f"Bearer {os.getenv('GITHUB_TOKEN')}"}, + ) as response: + return await response.json() + + +async def fetch_item_name(item_node_id: str) -> str: + query = """ + query ($id: ID!) { + node(id: $id) { + ... on ProjectV2Item { + content { + ... on DraftIssue { + title + } + ... on Issue { + title + } + ... on PullRequest { + title + } + } + } + } + } + """ + + variables = {"id": item_node_id} + + response_body = await send_request(query, variables) + + try: + item_name: str | None = response_body["data"]["node"]["content"]["title"] + except TypeError, KeyError, AttributeError: + raise HTTPException(status_code=500, detail="Could not fetch item name.") from None + + return item_name + + +async def fetch_assignees(item_node_id: str) -> list[str]: + query = """ + query ($id: ID!) { + node(id: $id) { + ... on ProjectV2Item { + content { + ... on DraftIssue { + assignees(first: 10) { + nodes { + id + } + } + } + ... on Issue { + assignees(first: 10) { + nodes { + id + } + } + } + ... on PullRequest { + assignees(first: 10) { + nodes { + id + } + } + } + } + } + } + } + """ + + variables = {"id": item_node_id} + + response_body = await send_request(query, variables) + + try: + assignees_data = response_body["data"]["node"]["content"]["assignees"]["nodes"] + except TypeError, KeyError, AttributeError: + return [] + assignees = [assignee.get("id", None) for assignee in assignees_data] + + return assignees + + +async def fetch_single_select_value(item_node_id: str, field_name: str) -> str | None: + if field_name is None: + return None + + query = """ + query ($id: ID!, $field_type: String!) { + node(id: $id) { + ... on ProjectV2Item { + fieldValueByName(name: $field_type) { + ... on ProjectV2ItemFieldSingleSelectValue { + name + } + } + } + } + } + """ + + variables = {"id": item_node_id, "field_type": field_name} + + response_body = await send_request(query, variables) + + try: + name: str | None = response_body["data"]["node"]["fieldValueByName"]["name"] + except TypeError, KeyError, AttributeError: + return None + + return name diff --git a/src/utils/misc.py b/src/utils/misc.py new file mode 100644 index 0000000..f01539e --- /dev/null +++ b/src/utils/misc.py @@ -0,0 +1,61 @@ +import asyncio +import logging +import os + +import yaml +from aiorwlock import RWLock +from hikari import GuildForumChannel + + +class SharedForumChannel: + forum_channel: GuildForumChannel + lock: RWLock + + def __init__(self, forum_channel: GuildForumChannel): + self.forum_channel = forum_channel + self.lock = RWLock() + + +def retrieve_discord_id(node_id: str) -> str | None: + with open(os.getenv("GITHUB_ID_TO_DISCORD_ID_MAPPING_PATH", "github_id_to_discord_id_mapping.yaml")) as file: + mapping: dict[str, str] = yaml.load("".join(file.readlines()), Loader=yaml.Loader) + + if mapping is None: + return None + + return mapping.get(node_id, None) + + +def create_item_link(item_id: int) -> str: + organization_name = os.getenv("GITHUB_ORGANIZATION_NAME", "my-org") + project_number = os.getenv("GITHUB_PROJECT_NUMBER", "1") + return f"https://github.com/orgs/{organization_name}/projects/{project_number}?pane=issue&item_id={item_id}" + + +def handle_task_exception(task: asyncio.Task, error_message: str): + try: + exception = task.exception() + except asyncio.CancelledError: + return + + if exception: + bot_logger.error(f"{error_message} {exception}") + + +class BotPrefixFilter(logging.Filter): + def filter(self, record: logging.LogRecord) -> bool: + record.msg = f"[BOT] {record.msg}" + return True + + +def get_bot_logger() -> logging.Logger: + logger = logging.getLogger("uvicorn.error.bot") + + if not any(isinstance(f, BotPrefixFilter) for f in logger.filters): + logger.addFilter(BotPrefixFilter()) + + return logger + + +server_logger = logging.getLogger("uvicorn.error") +bot_logger = get_bot_logger() diff --git a/src/utils/signature_verification.py b/src/utils/signature_verification.py new file mode 100644 index 0000000..ffe85e7 --- /dev/null +++ b/src/utils/signature_verification.py @@ -0,0 +1,32 @@ +import hashlib +import hmac +import os + +from fastapi import HTTPException + +from src.utils.misc import server_logger + + +def verify_signature(signature: str | None, body_bytes: bytes) -> None: + secret = os.getenv("GITHUB_WEBHOOK_SECRET", "") + if not secret: + server_logger.warning("GITHUB_WEBHOOK_SECRET is not set; skipping signature verification.") + return + if signature: + correct_signature = verify_secret(secret, body_bytes, signature) + if not correct_signature: + raise HTTPException(status_code=401, detail="Invalid signature.") + else: + raise HTTPException(status_code=401, detail="Missing signature.") + + +def generate_signature(secret: str, payload: bytes) -> str: + hash_object = hmac.new(secret.encode("utf-8"), msg=payload, digestmod=hashlib.sha256) + return f"sha256={hash_object.hexdigest()}" + + +def verify_secret(secret: str, payload: bytes, signature_header: str) -> bool: + if not secret: + return True + expected_signature = generate_signature(secret, payload) + return hmac.compare_digest(expected_signature, signature_header) diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..b19b0d3 --- /dev/null +++ b/uv.lock @@ -0,0 +1,903 @@ +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.2" +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/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload-time = "2025-10-28T20:59:39.937Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/36/e2abae1bd815f01c957cbf7be817b3043304e1c87bad526292a0410fdcf9/aiohttp-3.13.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2475391c29230e063ef53a66669b7b691c9bfc3f1426a0f7bcdf1216bdbac38b", size = 735234, upload-time = "2025-10-28T20:57:36.415Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e3/1ee62dde9b335e4ed41db6bba02613295a0d5b41f74a783c142745a12763/aiohttp-3.13.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f33c8748abef4d8717bb20e8fb1b3e07c6adacb7fd6beaae971a764cf5f30d61", size = 490733, upload-time = "2025-10-28T20:57:38.205Z" }, + { url = "https://files.pythonhosted.org/packages/1a/aa/7a451b1d6a04e8d15a362af3e9b897de71d86feac3babf8894545d08d537/aiohttp-3.13.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ae32f24bbfb7dbb485a24b30b1149e2f200be94777232aeadba3eecece4d0aa4", size = 491303, upload-time = "2025-10-28T20:57:40.122Z" }, + { url = "https://files.pythonhosted.org/packages/57/1e/209958dbb9b01174870f6a7538cd1f3f28274fdbc88a750c238e2c456295/aiohttp-3.13.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d7f02042c1f009ffb70067326ef183a047425bb2ff3bc434ead4dd4a4a66a2b", size = 1717965, upload-time = "2025-10-28T20:57:42.28Z" }, + { url = "https://files.pythonhosted.org/packages/08/aa/6a01848d6432f241416bc4866cae8dc03f05a5a884d2311280f6a09c73d6/aiohttp-3.13.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93655083005d71cd6c072cdab54c886e6570ad2c4592139c3fb967bfc19e4694", size = 1667221, upload-time = "2025-10-28T20:57:44.869Z" }, + { url = "https://files.pythonhosted.org/packages/87/4f/36c1992432d31bbc789fa0b93c768d2e9047ec8c7177e5cd84ea85155f36/aiohttp-3.13.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0db1e24b852f5f664cd728db140cf11ea0e82450471232a394b3d1a540b0f906", size = 1757178, upload-time = "2025-10-28T20:57:47.216Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b4/8e940dfb03b7e0f68a82b88fd182b9be0a65cb3f35612fe38c038c3112cf/aiohttp-3.13.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b009194665bcd128e23eaddef362e745601afa4641930848af4c8559e88f18f9", size = 1838001, upload-time = "2025-10-28T20:57:49.337Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ef/39f3448795499c440ab66084a9db7d20ca7662e94305f175a80f5b7e0072/aiohttp-3.13.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c038a8fdc8103cd51dbd986ecdce141473ffd9775a7a8057a6ed9c3653478011", size = 1716325, upload-time = "2025-10-28T20:57:51.327Z" }, + { url = "https://files.pythonhosted.org/packages/d7/51/b311500ffc860b181c05d91c59a1313bdd05c82960fdd4035a15740d431e/aiohttp-3.13.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66bac29b95a00db411cd758fea0e4b9bdba6d549dfe333f9a945430f5f2cc5a6", size = 1547978, upload-time = "2025-10-28T20:57:53.554Z" }, + { url = "https://files.pythonhosted.org/packages/31/64/b9d733296ef79815226dab8c586ff9e3df41c6aff2e16c06697b2d2e6775/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4ebf9cfc9ba24a74cf0718f04aac2a3bbe745902cc7c5ebc55c0f3b5777ef213", size = 1682042, upload-time = "2025-10-28T20:57:55.617Z" }, + { url = "https://files.pythonhosted.org/packages/3f/30/43d3e0f9d6473a6db7d472104c4eff4417b1e9df01774cb930338806d36b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a4b88ebe35ce54205c7074f7302bd08a4cb83256a3e0870c72d6f68a3aaf8e49", size = 1680085, upload-time = "2025-10-28T20:57:57.59Z" }, + { url = "https://files.pythonhosted.org/packages/16/51/c709f352c911b1864cfd1087577760ced64b3e5bee2aa88b8c0c8e2e4972/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:98c4fb90bb82b70a4ed79ca35f656f4281885be076f3f970ce315402b53099ae", size = 1728238, upload-time = "2025-10-28T20:57:59.525Z" }, + { url = "https://files.pythonhosted.org/packages/19/e2/19bd4c547092b773caeb48ff5ae4b1ae86756a0ee76c16727fcfd281404b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:ec7534e63ae0f3759df3a1ed4fa6bc8f75082a924b590619c0dd2f76d7043caa", size = 1544395, upload-time = "2025-10-28T20:58:01.914Z" }, + { url = "https://files.pythonhosted.org/packages/cf/87/860f2803b27dfc5ed7be532832a3498e4919da61299b4a1f8eb89b8ff44d/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5b927cf9b935a13e33644cbed6c8c4b2d0f25b713d838743f8fe7191b33829c4", size = 1742965, upload-time = "2025-10-28T20:58:03.972Z" }, + { url = "https://files.pythonhosted.org/packages/67/7f/db2fc7618925e8c7a601094d5cbe539f732df4fb570740be88ed9e40e99a/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:88d6c017966a78c5265d996c19cdb79235be5e6412268d7e2ce7dee339471b7a", size = 1697585, upload-time = "2025-10-28T20:58:06.189Z" }, + { url = "https://files.pythonhosted.org/packages/0c/07/9127916cb09bb38284db5036036042b7b2c514c8ebaeee79da550c43a6d6/aiohttp-3.13.2-cp314-cp314-win32.whl", hash = "sha256:f7c183e786e299b5d6c49fb43a769f8eb8e04a2726a2bd5887b98b5cc2d67940", size = 431621, upload-time = "2025-10-28T20:58:08.636Z" }, + { url = "https://files.pythonhosted.org/packages/fb/41/554a8a380df6d3a2bba8a7726429a23f4ac62aaf38de43bb6d6cde7b4d4d/aiohttp-3.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:fe242cd381e0fb65758faf5ad96c2e460df6ee5b2de1072fe97e4127927e00b4", size = 457627, upload-time = "2025-10-28T20:58:11Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8e/3824ef98c039d3951cb65b9205a96dd2b20f22241ee17d89c5701557c826/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f10d9c0b0188fe85398c61147bbd2a657d616c876863bfeff43376e0e3134673", size = 767360, upload-time = "2025-10-28T20:58:13.358Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0f/6a03e3fc7595421274fa34122c973bde2d89344f8a881b728fa8c774e4f1/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e7c952aefdf2460f4ae55c5e9c3e80aa72f706a6317e06020f80e96253b1accd", size = 504616, upload-time = "2025-10-28T20:58:15.339Z" }, + { url = "https://files.pythonhosted.org/packages/c6/aa/ed341b670f1bc8a6f2c6a718353d13b9546e2cef3544f573c6a1ff0da711/aiohttp-3.13.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c20423ce14771d98353d2e25e83591fa75dfa90a3c1848f3d7c68243b4fbded3", size = 509131, upload-time = "2025-10-28T20:58:17.693Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f0/c68dac234189dae5c4bbccc0f96ce0cc16b76632cfc3a08fff180045cfa4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e96eb1a34396e9430c19d8338d2ec33015e4a87ef2b4449db94c22412e25ccdf", size = 1864168, upload-time = "2025-10-28T20:58:20.113Z" }, + { url = "https://files.pythonhosted.org/packages/8f/65/75a9a76db8364b5d0e52a0c20eabc5d52297385d9af9c35335b924fafdee/aiohttp-3.13.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:23fb0783bc1a33640036465019d3bba069942616a6a2353c6907d7fe1ccdaf4e", size = 1719200, upload-time = "2025-10-28T20:58:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/f5/55/8df2ed78d7f41d232f6bd3ff866b6f617026551aa1d07e2f03458f964575/aiohttp-3.13.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1a9bea6244a1d05a4e57c295d69e159a5c50d8ef16aa390948ee873478d9a5", size = 1843497, upload-time = "2025-10-28T20:58:24.672Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e0/94d7215e405c5a02ccb6a35c7a3a6cfff242f457a00196496935f700cde5/aiohttp-3.13.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0a3d54e822688b56e9f6b5816fb3de3a3a64660efac64e4c2dc435230ad23bad", size = 1935703, upload-time = "2025-10-28T20:58:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/0b/78/1eeb63c3f9b2d1015a4c02788fb543141aad0a03ae3f7a7b669b2483f8d4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a653d872afe9f33497215745da7a943d1dc15b728a9c8da1c3ac423af35178e", size = 1792738, upload-time = "2025-10-28T20:58:29.787Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/aaf1eea4c188e51538c04cc568040e3082db263a57086ea74a7d38c39e42/aiohttp-3.13.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:56d36e80d2003fa3fc0207fac644216d8532e9504a785ef9a8fd013f84a42c61", size = 1624061, upload-time = "2025-10-28T20:58:32.529Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c2/3b6034de81fbcc43de8aeb209073a2286dfb50b86e927b4efd81cf848197/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:78cd586d8331fb8e241c2dd6b2f4061778cc69e150514b39a9e28dd050475661", size = 1789201, upload-time = "2025-10-28T20:58:34.618Z" }, + { url = "https://files.pythonhosted.org/packages/c9/38/c15dcf6d4d890217dae79d7213988f4e5fe6183d43893a9cf2fe9e84ca8d/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:20b10bbfbff766294fe99987f7bb3b74fdd2f1a2905f2562132641ad434dcf98", size = 1776868, upload-time = "2025-10-28T20:58:38.835Z" }, + { url = "https://files.pythonhosted.org/packages/04/75/f74fd178ac81adf4f283a74847807ade5150e48feda6aef024403716c30c/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9ec49dff7e2b3c85cdeaa412e9d438f0ecd71676fde61ec57027dd392f00c693", size = 1790660, upload-time = "2025-10-28T20:58:41.507Z" }, + { url = "https://files.pythonhosted.org/packages/e7/80/7368bd0d06b16b3aba358c16b919e9c46cf11587dc572091031b0e9e3ef0/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:94f05348c4406450f9d73d38efb41d669ad6cd90c7ee194810d0eefbfa875a7a", size = 1617548, upload-time = "2025-10-28T20:58:43.674Z" }, + { url = "https://files.pythonhosted.org/packages/7d/4b/a6212790c50483cb3212e507378fbe26b5086d73941e1ec4b56a30439688/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:fa4dcb605c6f82a80c7f95713c2b11c3b8e9893b3ebd2bc9bde93165ed6107be", size = 1817240, upload-time = "2025-10-28T20:58:45.787Z" }, + { url = "https://files.pythonhosted.org/packages/ff/f7/ba5f0ba4ea8d8f3c32850912944532b933acbf0f3a75546b89269b9b7dde/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf00e5db968c3f67eccd2778574cf64d8b27d95b237770aa32400bd7a1ca4f6c", size = 1762334, upload-time = "2025-10-28T20:58:47.936Z" }, + { url = "https://files.pythonhosted.org/packages/7e/83/1a5a1856574588b1cad63609ea9ad75b32a8353ac995d830bf5da9357364/aiohttp-3.13.2-cp314-cp314t-win32.whl", hash = "sha256:d23b5fe492b0805a50d3371e8a728a9134d8de5447dce4c885f5587294750734", size = 464685, upload-time = "2025-10-28T20:58:50.642Z" }, + { url = "https://files.pythonhosted.org/packages/9f/4d/d22668674122c08f4d56972297c51a624e64b3ed1efaa40187607a7cb66e/aiohttp-3.13.2-cp314-cp314t-win_amd64.whl", hash = "sha256:ff0a7b0a82a7ab905cbda74006318d1b12e37c797eb1b0d4eb3e316cf47f658f", size = 498093, upload-time = "2025-10-28T20:58:52.782Z" }, +] + +[[package]] +name = "aiorwlock" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/bf/d1ddcd676be027a963b3b01fdf9915daf4590b4dfd03bf1c8c2858aac7e3/aiorwlock-1.5.0.tar.gz", hash = "sha256:b529da24da659bdedcf68faf216595bde00db228c905197ac554773620e7fd2f", size = 7315, upload-time = "2024-11-25T06:03:46.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/4c/072b4097b2d05dbc4739b12a073da27496ca8241dec044c1ebc611eacf25/aiorwlock-1.5.0-py3-none-any.whl", hash = "sha256:0010cd2d2c603eb84bfee1cfd06233a976618dab90ec7108191e936137a8420a", size = 7833, upload-time = "2024-11-25T06:03:44.88Z" }, +] + +[[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 = "annotated-doc" +version = "0.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "anyio" +version = "4.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" }, +] + +[[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 = "certifi" +version = "2025.11.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" }, +] + +[[package]] +name = "cfgv" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114, upload-time = "2023-08-12T20:38:17.776Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249, upload-time = "2023-08-12T20:38:16.269Z" }, +] + +[[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 = "colorlog" +version = "6.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", hash = "sha256:2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c", size = 11743, upload-time = "2025-10-16T16:14:10.512Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" }, +] + +[[package]] +name = "dotenv" +version = "0.9.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dotenv" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892, upload-time = "2025-02-19T22:15:01.647Z" }, +] + +[[package]] +name = "fastapi" +version = "0.121.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/48/f08f264da34cf160db82c62ffb335e838b1fc16cbcc905f474c7d4c815db/fastapi-0.121.2.tar.gz", hash = "sha256:ca8e932b2b823ec1721c641e3669472c855ad9564a2854c9899d904c2848b8b9", size = 342944, upload-time = "2025-11-13T17:05:54.692Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/23/dfb161e91db7c92727db505dc72a384ee79681fe0603f706f9f9f52c2901/fastapi-0.121.2-py3-none-any.whl", hash = "sha256:f2d80b49a86a846b70cc3a03eb5ea6ad2939298bf6a7fe377aa9cd3dd079d358", size = 109201, upload-time = "2025-11-13T17:05:52.718Z" }, +] + +[[package]] +name = "filelock" +version = "3.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/46/0028a82567109b5ef6e4d2a1f04a583fb513e6cf9527fcdd09afd817deeb/filelock-3.20.0.tar.gz", hash = "sha256:711e943b4ec6be42e1d4e6690b48dc175c822967466bb31c0c293f34334c13f4", size = 18922, upload-time = "2025-10-08T18:03:50.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" }, +] + +[[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 = "github-project-discord-bot" +version = "1.0.0" +source = { editable = "." } +dependencies = [ + { name = "aiohttp" }, + { name = "aiorwlock" }, + { name = "dotenv" }, + { name = "fastapi" }, + { name = "hikari" }, + { name = "setuptools" }, + { name = "uvicorn" }, +] + +[package.dev-dependencies] +dev = [ + { name = "httpx" }, + { name = "pre-commit" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "ruff" }, +] +prod = [ + { name = "gunicorn" }, + { name = "uvicorn", extra = ["standard"] }, +] + +[package.metadata] +requires-dist = [ + { name = "aiohttp", specifier = ">=3.13.2" }, + { name = "aiorwlock", specifier = ">=1.5.0" }, + { name = "dotenv", specifier = ">=0.9.9" }, + { name = "fastapi", specifier = ">=0.121.2" }, + { name = "hikari", specifier = ">=2.5.0" }, + { name = "setuptools", specifier = ">=80.9.0" }, + { name = "uvicorn", specifier = ">=0.38.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "httpx", specifier = ">=0.28.1" }, + { name = "pre-commit", specifier = ">=4.4.0" }, + { name = "pytest", specifier = ">=9.0.1" }, + { name = "pytest-asyncio", specifier = ">=1.3.0" }, + { name = "ruff", specifier = ">=0.14.5" }, +] +prod = [ + { name = "gunicorn", specifier = ">=23.0.0" }, + { name = "uvicorn", extras = ["standard"], specifier = ">=0.38.0" }, +] + +[[package]] +name = "gunicorn" +version = "23.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/34/72/9614c465dc206155d93eff0ca20d42e1e35afc533971379482de953521a4/gunicorn-23.0.0.tar.gz", hash = "sha256:f014447a0101dc57e294f6c18ca6b40227a4c90e9bdb586042628030cba004ec", size = 375031, upload-time = "2024-08-10T20:25:27.378Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/7d/6dac2a6e1eba33ee43f318edbed4ff29151a49b5d37f080aad1e6469bca4/gunicorn-23.0.0-py3-none-any.whl", hash = "sha256:ec400d38950de4dfd418cff8328b2c8faed0edb0d517d3394e457c317908ca4d", size = 85029, upload-time = "2024-08-10T20:25:24.996Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "hikari" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "attrs" }, + { name = "colorlog" }, + { name = "multidict" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/bd/e4bd16c662fe7614bb6f38aba40a095aef998af0602674fe24740d3814cd/hikari-2.5.0.tar.gz", hash = "sha256:b8fe7e5cd5adfedcdcc488a86781bc946002fb79d984a473736624dd8201993b", size = 1924829, upload-time = "2025-10-31T12:34:27.838Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/c5/256c7d498cbe8e67edfd9bb2971740eadb662effcf9b9c1aff8e6d21e90d/hikari-2.5.0-py3-none-any.whl", hash = "sha256:fd108b51c73f46b562ac9e7cd48d4f74655224083ae37a319a417c30418a40ec", size = 580206, upload-time = "2025-10-31T12:34:25.633Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httptools" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" }, + { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" }, + { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" }, + { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" }, + { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" }, + { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "identify" +version = "2.6.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ff/e7/685de97986c916a6d93b3876139e00eef26ad5bbbd61925d670ae8013449/identify-2.6.15.tar.gz", hash = "sha256:e4f4864b96c6557ef2a1e1c951771838f4edc9df3a72ec7118b338801b11c7bf", size = 99311, upload-time = "2025-10-02T17:43:40.631Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/1c/e5fd8f973d4f375adb21565739498e2e9a1e54c858a97b9a8ccfdc81da9b/identify-2.6.15-py2.py3-none-any.whl", hash = "sha256:1181ef7608e00704db228516541eb83a88a9f94433a8c80bb9b5bd54b1d81757", size = 99183, upload-time = "2025-10-02T17:43:39.137Z" }, +] + +[[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 = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/80/1e/5492c365f222f907de1039b91f922b93fa4f764c713ee858d235495d8f50/multidict-6.7.0.tar.gz", hash = "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5", size = 101834, upload-time = "2025-10-06T14:52:30.657Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/b1/3da6934455dd4b261d4c72f897e3a5728eba81db59959f3a639245891baa/multidict-6.7.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bab1e4aff7adaa34410f93b1f8e57c4b36b9af0426a76003f441ee1d3c7e842", size = 75128, upload-time = "2025-10-06T14:50:51.92Z" }, + { url = "https://files.pythonhosted.org/packages/14/2c/f069cab5b51d175a1a2cb4ccdf7a2c2dabd58aa5bd933fa036a8d15e2404/multidict-6.7.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b8512bac933afc3e45fb2b18da8e59b78d4f408399a960339598374d4ae3b56b", size = 44410, upload-time = "2025-10-06T14:50:53.275Z" }, + { url = "https://files.pythonhosted.org/packages/42/e2/64bb41266427af6642b6b128e8774ed84c11b80a90702c13ac0a86bb10cc/multidict-6.7.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:79dcf9e477bc65414ebfea98ffd013cb39552b5ecd62908752e0e413d6d06e38", size = 43205, upload-time = "2025-10-06T14:50:54.911Z" }, + { url = "https://files.pythonhosted.org/packages/02/68/6b086fef8a3f1a8541b9236c594f0c9245617c29841f2e0395d979485cde/multidict-6.7.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:31bae522710064b5cbeddaf2e9f32b1abab70ac6ac91d42572502299e9953128", size = 245084, upload-time = "2025-10-06T14:50:56.369Z" }, + { url = "https://files.pythonhosted.org/packages/15/ee/f524093232007cd7a75c1d132df70f235cfd590a7c9eaccd7ff422ef4ae8/multidict-6.7.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a0df7ff02397bb63e2fd22af2c87dfa39e8c7f12947bc524dbdc528282c7e34", size = 252667, upload-time = "2025-10-06T14:50:57.991Z" }, + { url = "https://files.pythonhosted.org/packages/02/a5/eeb3f43ab45878f1895118c3ef157a480db58ede3f248e29b5354139c2c9/multidict-6.7.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a0222514e8e4c514660e182d5156a415c13ef0aabbd71682fc714e327b95e99", size = 233590, upload-time = "2025-10-06T14:50:59.589Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/76d02f8270b97269d7e3dbd45644b1785bda457b474315f8cf999525a193/multidict-6.7.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2397ab4daaf2698eb51a76721e98db21ce4f52339e535725de03ea962b5a3202", size = 264112, upload-time = "2025-10-06T14:51:01.183Z" }, + { url = "https://files.pythonhosted.org/packages/76/0b/c28a70ecb58963847c2a8efe334904cd254812b10e535aefb3bcce513918/multidict-6.7.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8891681594162635948a636c9fe0ff21746aeb3dd5463f6e25d9bea3a8a39ca1", size = 261194, upload-time = "2025-10-06T14:51:02.794Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/2ab26e4209773223159b83aa32721b4021ffb08102f8ac7d689c943fded1/multidict-6.7.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18706cc31dbf402a7945916dd5cddf160251b6dab8a2c5f3d6d5a55949f676b3", size = 248510, upload-time = "2025-10-06T14:51:04.724Z" }, + { url = "https://files.pythonhosted.org/packages/93/cd/06c1fa8282af1d1c46fd55c10a7930af652afdce43999501d4d68664170c/multidict-6.7.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f844a1bbf1d207dd311a56f383f7eda2d0e134921d45751842d8235e7778965d", size = 248395, upload-time = "2025-10-06T14:51:06.306Z" }, + { url = "https://files.pythonhosted.org/packages/99/ac/82cb419dd6b04ccf9e7e61befc00c77614fc8134362488b553402ecd55ce/multidict-6.7.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4393e3581e84e5645506923816b9cc81f5609a778c7e7534054091acc64d1c6", size = 239520, upload-time = "2025-10-06T14:51:08.091Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f3/a0f9bf09493421bd8716a362e0cd1d244f5a6550f5beffdd6b47e885b331/multidict-6.7.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fbd18dc82d7bf274b37aa48d664534330af744e03bccf696d6f4c6042e7d19e7", size = 245479, upload-time = "2025-10-06T14:51:10.365Z" }, + { url = "https://files.pythonhosted.org/packages/8d/01/476d38fc73a212843f43c852b0eee266b6971f0e28329c2184a8df90c376/multidict-6.7.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b6234e14f9314731ec45c42fc4554b88133ad53a09092cc48a88e771c125dadb", size = 258903, upload-time = "2025-10-06T14:51:12.466Z" }, + { url = "https://files.pythonhosted.org/packages/49/6d/23faeb0868adba613b817d0e69c5f15531b24d462af8012c4f6de4fa8dc3/multidict-6.7.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:08d4379f9744d8f78d98c8673c06e202ffa88296f009c71bbafe8a6bf847d01f", size = 252333, upload-time = "2025-10-06T14:51:14.48Z" }, + { url = "https://files.pythonhosted.org/packages/1e/cc/48d02ac22b30fa247f7dad82866e4b1015431092f4ba6ebc7e77596e0b18/multidict-6.7.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fe04da3f79387f450fd0061d4dd2e45a72749d31bf634aecc9e27f24fdc4b3f", size = 243411, upload-time = "2025-10-06T14:51:16.072Z" }, + { url = "https://files.pythonhosted.org/packages/4a/03/29a8bf5a18abf1fe34535c88adbdfa88c9fb869b5a3b120692c64abe8284/multidict-6.7.0-cp314-cp314-win32.whl", hash = "sha256:fbafe31d191dfa7c4c51f7a6149c9fb7e914dcf9ffead27dcfd9f1ae382b3885", size = 40940, upload-time = "2025-10-06T14:51:17.544Z" }, + { url = "https://files.pythonhosted.org/packages/82/16/7ed27b680791b939de138f906d5cf2b4657b0d45ca6f5dd6236fdddafb1a/multidict-6.7.0-cp314-cp314-win_amd64.whl", hash = "sha256:2f67396ec0310764b9222a1728ced1ab638f61aadc6226f17a71dd9324f9a99c", size = 45087, upload-time = "2025-10-06T14:51:18.875Z" }, + { url = "https://files.pythonhosted.org/packages/cd/3c/e3e62eb35a1950292fe39315d3c89941e30a9d07d5d2df42965ab041da43/multidict-6.7.0-cp314-cp314-win_arm64.whl", hash = "sha256:ba672b26069957ee369cfa7fc180dde1fc6f176eaf1e6beaf61fbebbd3d9c000", size = 42368, upload-time = "2025-10-06T14:51:20.225Z" }, + { url = "https://files.pythonhosted.org/packages/8b/40/cd499bd0dbc5f1136726db3153042a735fffd0d77268e2ee20d5f33c010f/multidict-6.7.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:c1dcc7524066fa918c6a27d61444d4ee7900ec635779058571f70d042d86ed63", size = 82326, upload-time = "2025-10-06T14:51:21.588Z" }, + { url = "https://files.pythonhosted.org/packages/13/8a/18e031eca251c8df76daf0288e6790561806e439f5ce99a170b4af30676b/multidict-6.7.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:27e0b36c2d388dc7b6ced3406671b401e84ad7eb0656b8f3a2f46ed0ce483718", size = 48065, upload-time = "2025-10-06T14:51:22.93Z" }, + { url = "https://files.pythonhosted.org/packages/40/71/5e6701277470a87d234e433fb0a3a7deaf3bcd92566e421e7ae9776319de/multidict-6.7.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a7baa46a22e77f0988e3b23d4ede5513ebec1929e34ee9495be535662c0dfe2", size = 46475, upload-time = "2025-10-06T14:51:24.352Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6a/bab00cbab6d9cfb57afe1663318f72ec28289ea03fd4e8236bb78429893a/multidict-6.7.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7bf77f54997a9166a2f5675d1201520586439424c2511723a7312bdb4bcc034e", size = 239324, upload-time = "2025-10-06T14:51:25.822Z" }, + { url = "https://files.pythonhosted.org/packages/2a/5f/8de95f629fc22a7769ade8b41028e3e5a822c1f8904f618d175945a81ad3/multidict-6.7.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e011555abada53f1578d63389610ac8a5400fc70ce71156b0aa30d326f1a5064", size = 246877, upload-time = "2025-10-06T14:51:27.604Z" }, + { url = "https://files.pythonhosted.org/packages/23/b4/38881a960458f25b89e9f4a4fdcb02ac101cfa710190db6e5528841e67de/multidict-6.7.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:28b37063541b897fd6a318007373930a75ca6d6ac7c940dbe14731ffdd8d498e", size = 225824, upload-time = "2025-10-06T14:51:29.664Z" }, + { url = "https://files.pythonhosted.org/packages/1e/39/6566210c83f8a261575f18e7144736059f0c460b362e96e9cf797a24b8e7/multidict-6.7.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05047ada7a2fde2631a0ed706f1fd68b169a681dfe5e4cf0f8e4cb6618bbc2cd", size = 253558, upload-time = "2025-10-06T14:51:31.684Z" }, + { url = "https://files.pythonhosted.org/packages/00/a3/67f18315100f64c269f46e6c0319fa87ba68f0f64f2b8e7fd7c72b913a0b/multidict-6.7.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:716133f7d1d946a4e1b91b1756b23c088881e70ff180c24e864c26192ad7534a", size = 252339, upload-time = "2025-10-06T14:51:33.699Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2a/1cb77266afee2458d82f50da41beba02159b1d6b1f7973afc9a1cad1499b/multidict-6.7.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1bed1b467ef657f2a0ae62844a607909ef1c6889562de5e1d505f74457d0b96", size = 244895, upload-time = "2025-10-06T14:51:36.189Z" }, + { url = "https://files.pythonhosted.org/packages/dd/72/09fa7dd487f119b2eb9524946ddd36e2067c08510576d43ff68469563b3b/multidict-6.7.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ca43bdfa5d37bd6aee89d85e1d0831fb86e25541be7e9d376ead1b28974f8e5e", size = 241862, upload-time = "2025-10-06T14:51:41.291Z" }, + { url = "https://files.pythonhosted.org/packages/65/92/bc1f8bd0853d8669300f732c801974dfc3702c3eeadae2f60cef54dc69d7/multidict-6.7.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:44b546bd3eb645fd26fb949e43c02a25a2e632e2ca21a35e2e132c8105dc8599", size = 232376, upload-time = "2025-10-06T14:51:43.55Z" }, + { url = "https://files.pythonhosted.org/packages/09/86/ac39399e5cb9d0c2ac8ef6e10a768e4d3bc933ac808d49c41f9dc23337eb/multidict-6.7.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a6ef16328011d3f468e7ebc326f24c1445f001ca1dec335b2f8e66bed3006394", size = 240272, upload-time = "2025-10-06T14:51:45.265Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b6/fed5ac6b8563ec72df6cb1ea8dac6d17f0a4a1f65045f66b6d3bf1497c02/multidict-6.7.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:5aa873cbc8e593d361ae65c68f85faadd755c3295ea2c12040ee146802f23b38", size = 248774, upload-time = "2025-10-06T14:51:46.836Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8d/b954d8c0dc132b68f760aefd45870978deec6818897389dace00fcde32ff/multidict-6.7.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:3d7b6ccce016e29df4b7ca819659f516f0bc7a4b3efa3bb2012ba06431b044f9", size = 242731, upload-time = "2025-10-06T14:51:48.541Z" }, + { url = "https://files.pythonhosted.org/packages/16/9d/a2dac7009125d3540c2f54e194829ea18ac53716c61b655d8ed300120b0f/multidict-6.7.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:171b73bd4ee683d307599b66793ac80981b06f069b62eea1c9e29c9241aa66b0", size = 240193, upload-time = "2025-10-06T14:51:50.355Z" }, + { url = "https://files.pythonhosted.org/packages/39/ca/c05f144128ea232ae2178b008d5011d4e2cea86e4ee8c85c2631b1b94802/multidict-6.7.0-cp314-cp314t-win32.whl", hash = "sha256:b2d7f80c4e1fd010b07cb26820aae86b7e73b681ee4889684fb8d2d4537aab13", size = 48023, upload-time = "2025-10-06T14:51:51.883Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8f/0a60e501584145588be1af5cc829265701ba3c35a64aec8e07cbb71d39bb/multidict-6.7.0-cp314-cp314t-win_amd64.whl", hash = "sha256:09929cab6fcb68122776d575e03c6cc64ee0b8fca48d17e135474b042ce515cd", size = 53507, upload-time = "2025-10-06T14:51:53.672Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ae/3148b988a9c6239903e786eac19c889fab607c31d6efa7fb2147e5680f23/multidict-6.7.0-cp314-cp314t-win_arm64.whl", hash = "sha256:cc41db090ed742f32bd2d2c721861725e6109681eddf835d0a82bd3a5c382827", size = 44804, upload-time = "2025-10-06T14:51:55.415Z" }, + { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.9.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/49/7845c2d7bf6474efd8e27905b51b11e6ce411708c91e829b93f324de9929/pre_commit-4.4.0.tar.gz", hash = "sha256:f0233ebab440e9f17cabbb558706eb173d19ace965c68cdce2c081042b4fab15", size = 197501, upload-time = "2025-11-08T21:12:11.607Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/11/574fe7d13acf30bfd0a8dd7fa1647040f2b8064f13f43e8c963b1e65093b/pre_commit-4.4.0-py2.py3-none-any.whl", hash = "sha256:b35ea52957cbf83dcc5d8ee636cbead8624e3a15fbfa61a370e42158ac8a5813", size = 226049, upload-time = "2025-11-08T21:12:10.228Z" }, +] + +[[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 = "pydantic" +version = "2.12.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/96/ad/a17bc283d7d81837c061c49e3eaa27a45991759a1b7eae1031921c6bd924/pydantic-2.12.4.tar.gz", hash = "sha256:0f8cb9555000a4b5b617f66bfd2566264c4984b27589d3b845685983e8ea85ac", size = 821038, upload-time = "2025-11-05T10:50:08.59Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/2f/e68750da9b04856e2a7ec56fc6f034a5a79775e9b9a81882252789873798/pydantic-2.12.4-py3-none-any.whl", hash = "sha256:92d3d202a745d46f9be6df459ac5a064fdaa3c1c4cd8adcfa332ccf3c05f871e", size = 463400, upload-time = "2025-11-05T10:50:06.732Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/56/f013048ac4bc4c1d9be45afd4ab209ea62822fb1598f40687e6bf45dcea4/pytest-9.0.1.tar.gz", hash = "sha256:3e9c069ea73583e255c3b21cf46b8d3c56f6e3a1a8f6da94ccb0fcf57b9d73c8", size = 1564125, upload-time = "2025-11-12T13:05:09.333Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/8b/6300fb80f858cda1c51ffa17075df5d846757081d11ab4aa35cef9e6258b/pytest-9.0.1-py3-none-any.whl", hash = "sha256:67be0030d194df2dfa7b556f2e56fb3c3315bd5c8822c6951162b92b32ce7dad", size = 373668, upload-time = "2025-11-12T13:05:07.379Z" }, +] + +[[package]] +name = "pytest-asyncio" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "ruff" +version = "0.14.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/fa/fbb67a5780ae0f704876cb8ac92d6d76da41da4dc72b7ed3565ab18f2f52/ruff-0.14.5.tar.gz", hash = "sha256:8d3b48d7d8aad423d3137af7ab6c8b1e38e4de104800f0d596990f6ada1a9fc1", size = 5615944, upload-time = "2025-11-13T19:58:51.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/31/c07e9c535248d10836a94e4f4e8c5a31a1beed6f169b31405b227872d4f4/ruff-0.14.5-py3-none-linux_armv6l.whl", hash = "sha256:f3b8248123b586de44a8018bcc9fefe31d23dda57a34e6f0e1e53bd51fd63594", size = 13171630, upload-time = "2025-11-13T19:57:54.894Z" }, + { url = "https://files.pythonhosted.org/packages/8e/5c/283c62516dca697cd604c2796d1487396b7a436b2f0ecc3fd412aca470e0/ruff-0.14.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f7a75236570318c7a30edd7f5491945f0169de738d945ca8784500b517163a72", size = 13413925, upload-time = "2025-11-13T19:57:59.181Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f3/aa319f4afc22cb6fcba2b9cdfc0f03bbf747e59ab7a8c5e90173857a1361/ruff-0.14.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6d146132d1ee115f8802356a2dc9a634dbf58184c51bff21f313e8cd1c74899a", size = 12574040, upload-time = "2025-11-13T19:58:02.056Z" }, + { url = "https://files.pythonhosted.org/packages/f9/7f/cb5845fcc7c7e88ed57f58670189fc2ff517fe2134c3821e77e29fd3b0c8/ruff-0.14.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2380596653dcd20b057794d55681571a257a42327da8894b93bbd6111aa801f", size = 13009755, upload-time = "2025-11-13T19:58:05.172Z" }, + { url = "https://files.pythonhosted.org/packages/21/d2/bcbedbb6bcb9253085981730687ddc0cc7b2e18e8dc13cf4453de905d7a0/ruff-0.14.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2d1fa985a42b1f075a098fa1ab9d472b712bdb17ad87a8ec86e45e7fa6273e68", size = 12937641, upload-time = "2025-11-13T19:58:08.345Z" }, + { url = "https://files.pythonhosted.org/packages/a4/58/e25de28a572bdd60ffc6bb71fc7fd25a94ec6a076942e372437649cbb02a/ruff-0.14.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88f0770d42b7fa02bbefddde15d235ca3aa24e2f0137388cc15b2dcbb1f7c7a7", size = 13610854, upload-time = "2025-11-13T19:58:11.419Z" }, + { url = "https://files.pythonhosted.org/packages/7d/24/43bb3fd23ecee9861970978ea1a7a63e12a204d319248a7e8af539984280/ruff-0.14.5-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:3676cb02b9061fee7294661071c4709fa21419ea9176087cb77e64410926eb78", size = 15061088, upload-time = "2025-11-13T19:58:14.551Z" }, + { url = "https://files.pythonhosted.org/packages/23/44/a022f288d61c2f8c8645b24c364b719aee293ffc7d633a2ca4d116b9c716/ruff-0.14.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b595bedf6bc9cab647c4a173a61acf4f1ac5f2b545203ba82f30fcb10b0318fb", size = 14734717, upload-time = "2025-11-13T19:58:17.518Z" }, + { url = "https://files.pythonhosted.org/packages/58/81/5c6ba44de7e44c91f68073e0658109d8373b0590940efe5bd7753a2585a3/ruff-0.14.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f55382725ad0bdb2e8ee2babcbbfb16f124f5a59496a2f6a46f1d9d99d93e6e2", size = 14028812, upload-time = "2025-11-13T19:58:20.533Z" }, + { url = "https://files.pythonhosted.org/packages/ad/ef/41a8b60f8462cb320f68615b00299ebb12660097c952c600c762078420f8/ruff-0.14.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7497d19dce23976bdaca24345ae131a1d38dcfe1b0850ad8e9e6e4fa321a6e19", size = 13825656, upload-time = "2025-11-13T19:58:23.345Z" }, + { url = "https://files.pythonhosted.org/packages/7c/00/207e5de737fdb59b39eb1fac806904fe05681981b46d6a6db9468501062e/ruff-0.14.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:410e781f1122d6be4f446981dd479470af86537fb0b8857f27a6e872f65a38e4", size = 13959922, upload-time = "2025-11-13T19:58:26.537Z" }, + { url = "https://files.pythonhosted.org/packages/bc/7e/fa1f5c2776db4be405040293618846a2dece5c70b050874c2d1f10f24776/ruff-0.14.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c01be527ef4c91a6d55e53b337bfe2c0f82af024cc1a33c44792d6844e2331e1", size = 12932501, upload-time = "2025-11-13T19:58:29.822Z" }, + { url = "https://files.pythonhosted.org/packages/67/d8/d86bf784d693a764b59479a6bbdc9515ae42c340a5dc5ab1dabef847bfaa/ruff-0.14.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f66e9bb762e68d66e48550b59c74314168ebb46199886c5c5aa0b0fbcc81b151", size = 12927319, upload-time = "2025-11-13T19:58:32.923Z" }, + { url = "https://files.pythonhosted.org/packages/ac/de/ee0b304d450ae007ce0cb3e455fe24fbcaaedae4ebaad6c23831c6663651/ruff-0.14.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d93be8f1fa01022337f1f8f3bcaa7ffee2d0b03f00922c45c2207954f351f465", size = 13206209, upload-time = "2025-11-13T19:58:35.952Z" }, + { url = "https://files.pythonhosted.org/packages/33/aa/193ca7e3a92d74f17d9d5771a765965d2cf42c86e6f0fd95b13969115723/ruff-0.14.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:c135d4b681f7401fe0e7312017e41aba9b3160861105726b76cfa14bc25aa367", size = 13953709, upload-time = "2025-11-13T19:58:39.002Z" }, + { url = "https://files.pythonhosted.org/packages/cc/f1/7119e42aa1d3bf036ffc9478885c2e248812b7de9abea4eae89163d2929d/ruff-0.14.5-py3-none-win32.whl", hash = "sha256:c83642e6fccfb6dea8b785eb9f456800dcd6a63f362238af5fc0c83d027dd08b", size = 12925808, upload-time = "2025-11-13T19:58:42.779Z" }, + { url = "https://files.pythonhosted.org/packages/3b/9d/7c0a255d21e0912114784e4a96bf62af0618e2190cae468cd82b13625ad2/ruff-0.14.5-py3-none-win_amd64.whl", hash = "sha256:9d55d7af7166f143c94eae1db3312f9ea8f95a4defef1979ed516dbb38c27621", size = 14331546, upload-time = "2025-11-13T19:58:45.691Z" }, + { url = "https://files.pythonhosted.org/packages/e5/80/69756670caedcf3b9be597a6e12276a6cf6197076eb62aad0c608f8efce0/ruff-0.14.5-py3-none-win_arm64.whl", hash = "sha256:4b700459d4649e2594b31f20a9de33bc7c19976d4746d8d0798ad959621d64a4", size = 13433331, upload-time = "2025-11-13T19:58:48.434Z" }, +] + +[[package]] +name = "setuptools" +version = "80.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "starlette" +version = "0.49.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/de/1a/608df0b10b53b0beb96a37854ee05864d182ddd4b1156a22f1ad3860425a/starlette-0.49.3.tar.gz", hash = "sha256:1c14546f299b5901a1ea0e34410575bc33bbd741377a10484a54445588d00284", size = 2655031, upload-time = "2025-11-01T15:12:26.13Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/e0/021c772d6a662f43b63044ab481dc6ac7592447605b5b35a957785363122/starlette-0.49.3-py3-none-any.whl", hash = "sha256:b579b99715fdc2980cf88c8ec96d3bf1ce16f5a8051a7c2b84ef9b1cdecaea2f", size = 74340, upload-time = "2025-11-01T15:12:24.387Z" }, +] + +[[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 = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.38.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" }, +] + +[package.optional-dependencies] +standard = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" }, + { name = "watchfiles" }, + { name = "websockets" }, +] + +[[package]] +name = "uvloop" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" }, + { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" }, + { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" }, + { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" }, + { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" }, + { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" }, + { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" }, + { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" }, +] + +[[package]] +name = "virtualenv" +version = "20.35.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "platformdirs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/20/28/e6f1a6f655d620846bd9df527390ecc26b3805a0c5989048c210e22c5ca9/virtualenv-20.35.4.tar.gz", hash = "sha256:643d3914d73d3eeb0c552cbb12d7e82adf0e504dbf86a3182f8771a153a1971c", size = 6028799, upload-time = "2025-10-29T06:57:40.511Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/0c/c05523fa3181fdf0c9c52a6ba91a23fbf3246cc095f26f6516f9c60e6771/virtualenv-20.35.4-py3-none-any.whl", hash = "sha256:c21c9cede36c9753eeade68ba7d523529f228a403463376cf821eaae2b650f1b", size = 6005095, upload-time = "2025-10-29T06:57:37.598Z" }, +] + +[[package]] +name = "watchfiles" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" }, + { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" }, + { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" }, + { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" }, + { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" }, + { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" }, + { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" }, + { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" }, + { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" }, + { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" }, + { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" }, + { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" }, + { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" }, + { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" }, + { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" }, + { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" }, + { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" }, +] + +[[package]] +name = "websockets" +version = "15.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" }, +] + +[[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" }, +]