commit 896699535de1348bb8fd520858608f0c164a58bb
Author: kaffa <kaffa@anvil.it.com>
Date:   Thu Jan 15 10:21:46 2026 +0900

    Initial commit: Namecheap API library with REST/MCP servers
    
    Features:
    - Domain management (check, register, renew, contacts)
    - DNS management (nameservers, records)
    - Glue records (child nameserver) support
    - TLD price tracking with KRW conversion
    - FastAPI REST server with OpenAI schema
    - MCP server for Claude integration
    
    Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..edcb12c
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,20 @@
+NAMECHEAP_API_USER=your_api_user
+NAMECHEAP_API_KEY=your_api_key
+NAMECHEAP_USERNAME=your_username
+NAMECHEAP_CLIENT_IP=your_whitelisted_ip
+NAMECHEAP_SANDBOX=true
+
+# REST API Server Auth
+API_SERVER_KEY=your_api_server_key
+
+# Registrant Info
+REGISTRANT_ORGANIZATION=
+REGISTRANT_FIRST_NAME=
+REGISTRANT_LAST_NAME=
+REGISTRANT_ADDRESS1=
+REGISTRANT_CITY=
+REGISTRANT_STATE_PROVINCE=
+REGISTRANT_POSTAL_CODE=
+REGISTRANT_COUNTRY=
+REGISTRANT_PHONE=
+REGISTRANT_EMAIL=
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..303cc54
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Environment variables
+.env
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..24ee5b1
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.13
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..105ddc1
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+Namecheap domain management Python library with REST API server and MCP server. Includes TLD price tracking with automatic exchange rate conversion (USD to KRW).
+
+## Commands
+
+```bash
+# Run scripts (uses uv for dependency management)
+uv run python <script>.py
+
+# API server (runs on port 8000)
+uv run python api_server.py
+
+# MCP server (for Claude integration)
+uv run python mcp_server.py
+
+# Update TLD prices (fetches from Namecheap API + exchange rate)
+uv run python update_prices.py
+
+# Query prices CLI
+uv run python prices.py          # All TLDs (cheapest first)
+uv run python prices.py com      # Filter by TLD
+
+# Service management
+systemctl --user status namecheap-api.service
+systemctl --user restart namecheap-api.service
+systemctl --user list-timers namecheap-prices.timer
+journalctl --user -u namecheap-api.service -f
+```
+
+## Architecture
+
+### Core Components
+
+- **namecheap.py**: API client wrapping Namecheap XML API. Classes: `NamecheapConfig`, `NamecheapAPI`, `RegistrantInfo`, `NamecheapError`
+- **api_server.py**: FastAPI REST server with X-API-Key authentication. Exposes domain/DNS/pricing endpoints and OpenAI function calling schema at `/openai/schema`
+- **mcp_server.py**: MCP server using FastMCP for Claude Code/Desktop integration
+- **db.py**: SQLite database for TLD prices and exchange rates
+- **update_prices.py**: Fetches Namecheap pricing + exchange rate, calculates KRW prices with formula: `USD × rate × 1.10 (VAT) × 1.03 (margin)`, rounded up to nearest 1000
+
+### Data Flow
+
+Namecheap XML API → `namecheap.py` → REST API (`api_server.py`) / MCP (`mcp_server.py`)
+                                    ↓
+                           `prices.db` (SQLite)
+
+### Configuration
+
+Environment variables in `.env` (copy from `.env.example`):
+- `NAMECHEAP_API_USER`, `NAMECHEAP_API_KEY`, `NAMECHEAP_USERNAME`, `NAMECHEAP_CLIENT_IP` - Namecheap API credentials
+- `NAMECHEAP_SANDBOX` - Use sandbox API (true/false)
+- `API_SERVER_KEY` - REST API authentication key (stored in Vault: `secret/namecheap/api-server`)
+
+### systemd Services
+
+Located at `~/.config/systemd/user/`:
+- `namecheap-api.service` - REST API server
+- `namecheap-prices.service` + `namecheap-prices.timer` - Auto price updates (09:30, 12:30, 16:00)
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f63577a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,423 @@
+# Namecheap API
+
+Namecheap 도메인 관리 및 가격 조회 Python 라이브러리
+
+## 설치
+
+```bash
+cd /home/admin/namecheap_api
+source ~/.local/bin/env
+```
+
+## 환경 설정
+
+`.env` 파일 설정:
+
+```bash
+cp .env.example .env
+nano .env
+```
+
+```env
+# Namecheap API 설정
+NAMECHEAP_API_USER=your_api_user
+NAMECHEAP_API_KEY=your_api_key
+NAMECHEAP_USERNAME=your_username
+NAMECHEAP_CLIENT_IP=your_whitelisted_ip
+NAMECHEAP_SANDBOX=false
+
+# REST API 서버 인증
+API_SERVER_KEY=your_api_server_key  # Vault: secret/namecheap/api-server
+
+# 등록자 정보
+REGISTRANT_ORGANIZATION=회사명
+REGISTRANT_FIRST_NAME=이름
+REGISTRANT_LAST_NAME=성
+REGISTRANT_ADDRESS1=주소
+REGISTRANT_CITY=도시
+REGISTRANT_STATE_PROVINCE=시/도
+REGISTRANT_POSTAL_CODE=우편번호
+REGISTRANT_COUNTRY=국가코드 (JP, KR, US 등)
+REGISTRANT_PHONE=+국가번호.전화번호
+REGISTRANT_EMAIL=이메일
+```
+
+## 사용법
+
+### 도메인 목록 조회
+
+```python
+from dotenv import load_dotenv
+import os
+load_dotenv()
+from namecheap import NamecheapAPI, NamecheapConfig
+
+config = NamecheapConfig(
+    api_user=os.getenv('NAMECHEAP_API_USER'),
+    api_key=os.getenv('NAMECHEAP_API_KEY'),
+    username=os.getenv('NAMECHEAP_USERNAME'),
+    client_ip=os.getenv('NAMECHEAP_CLIENT_IP'),
+    sandbox=False,
+)
+api = NamecheapAPI(config)
+
+# 도메인 목록
+domains = api.domains_get_list()
+for d in domains:
+    print(f"{d['name']} - 만료: {d['expires']}")
+```
+
+### 도메인 가용성 확인
+
+```python
+result = api.domains_check(["example.com", "example.net"])
+for domain, available in result.items():
+    print(f"{domain}: {'사용 가능' if available else '등록됨'}")
+```
+
+### 도메인 등록
+
+```python
+from namecheap import RegistrantInfo
+
+registrant = RegistrantInfo(
+    organization=os.getenv('REGISTRANT_ORGANIZATION'),
+    first_name=os.getenv('REGISTRANT_FIRST_NAME'),
+    last_name=os.getenv('REGISTRANT_LAST_NAME'),
+    address1=os.getenv('REGISTRANT_ADDRESS1'),
+    city=os.getenv('REGISTRANT_CITY'),
+    state_province=os.getenv('REGISTRANT_STATE_PROVINCE'),
+    postal_code=os.getenv('REGISTRANT_POSTAL_CODE'),
+    country=os.getenv('REGISTRANT_COUNTRY'),
+    phone=os.getenv('REGISTRANT_PHONE'),
+    email=os.getenv('REGISTRANT_EMAIL'),
+)
+
+result = api.domains_create("newdomain.com", registrant, years=1)
+print(result)
+# {'domain': 'newdomain.com', 'registered': True, 'charged_amount': 11.48, ...}
+```
+
+### 도메인 갱신
+
+```python
+result = api.domains_renew("example.com", years=1)
+print(result)
+# {'domain': 'example.com', 'renewed': True, 'charged_amount': 11.48, ...}
+```
+
+### 등록자 정보 조회/수정
+
+```python
+# 조회
+contacts = api.domains_get_contacts("example.com")
+print(contacts['registrant'])
+# {'firstName': 'Taro', 'lastName': 'Tanaka', 'organizationName': 'LIBEHAIM Inc.', ...}
+
+# 수정
+from namecheap import RegistrantInfo
+
+new_contact = RegistrantInfo(
+    organization="New Company",
+    first_name="Taro",
+    last_name="Tanaka",
+    address1="123 Street",
+    city="Tokyo",
+    state_province="Tokyo-to",
+    postal_code="100-0001",
+    country="JP",
+    phone="+81.312345678",
+    email="new@example.com",
+)
+api.domains_set_contacts("example.com", new_contact)
+```
+
+### DNS 관리
+
+```python
+# 네임서버 조회
+ns_info = api.dns_get_list("example", "com")
+print(ns_info)
+# {'domain': 'example.com', 'is_using_our_dns': False, 'nameservers': ['ns1.cloudflare.com', ...]}
+
+# DNS 레코드 조회 (Namecheap DNS 사용 시에만 가능)
+records = api.dns_get_hosts("example", "com")
+
+# DNS 레코드 설정
+new_records = [
+    {"name": "@", "type": "A", "address": "1.2.3.4", "ttl": "1800"},
+    {"name": "www", "type": "CNAME", "address": "example.com", "ttl": "1800"},
+]
+api.dns_set_hosts("example", "com", new_records)
+
+# 커스텀 네임서버로 변경
+api.dns_set_custom("example", "com", ["ns1.cloudflare.com", "ns2.cloudflare.com"])
+
+# Namecheap 기본 네임서버로 복원
+api.dns_set_default("example", "com")
+```
+
+### 글루 레코드 (Child Nameserver)
+
+자신의 도메인을 네임서버로 사용하려면 먼저 글루 레코드를 등록해야 합니다.
+
+```python
+# 글루 레코드 생성 (ns1.example.com → 1.2.3.4)
+result = api.ns_create("example", "com", "ns1.example.com", "1.2.3.4")
+print(result)
+# {'domain': 'example.com', 'nameserver': 'ns1.example.com', 'ip': '1.2.3.4', 'success': True}
+
+# 글루 레코드 조회
+info = api.ns_get_info("example", "com", "ns1.example.com")
+print(info)
+# {'domain': 'example.com', 'nameserver': 'ns1.example.com', 'ip': '1.2.3.4', 'statuses': ['ok']}
+
+# 글루 레코드 IP 변경
+result = api.ns_update("example", "com", "ns1.example.com", "1.2.3.4", "5.6.7.8")
+
+# 글루 레코드 삭제
+result = api.ns_delete("example", "com", "ns1.example.com")
+```
+
+### 계정 정보
+
+```python
+# 잔액 조회
+balance = api.users_get_balances()
+print(f"잔액: ${balance['available_balance']}")
+```
+
+## 가격 조회 시스템
+
+### 수동 가격 업데이트
+
+```bash
+uv run python update_prices.py
+```
+
+### 가격 조회 CLI
+
+```bash
+# 전체 TLD (저렴한 순)
+uv run python prices.py
+
+# 특정 TLD 검색
+uv run python prices.py com
+uv run python prices.py io
+```
+
+### 가격 계산 방식
+
+```
+최종가격 = USD × 환율 × 1.10(부가세) × 1.03(마진)
+→ 1,000원 단위 올림
+```
+
+### 자동 업데이트 스케줄
+
+systemd timer로 하루 3회 자동 업데이트:
+
+| 시간 | 설명 |
+|------|------|
+| 09:30 | 시장 개장 후 |
+| 12:30 | 중간 |
+| 16:00 | 시장 마감 후 |
+
+```bash
+# 타이머 상태 확인
+systemctl --user list-timers namecheap-prices.timer
+
+# 로그 확인
+journalctl --user -u namecheap-prices.service
+
+# 타이머 재시작
+systemctl --user restart namecheap-prices.timer
+```
+
+## REST API 서버 (OpenAI 호환)
+
+OpenAI Function Calling / Custom GPT / Cloudflare Workers에서 사용할 수 있는 REST API 서버입니다.
+
+### 공개 엔드포인트
+
+```
+https://namecheap-api.anvil.it.com
+```
+
+### 인증
+
+모든 요청에 `X-API-Key` 헤더 필요:
+
+```bash
+curl -H "X-API-Key: YOUR_API_KEY" https://namecheap-api.anvil.it.com/domains
+```
+
+API Key는 Vault에 저장됨:
+- 경로: `secret/namecheap/api-server`
+- 키: `key`
+
+```bash
+vault kv get secret/namecheap/api-server
+```
+
+### 수동 실행
+
+```bash
+uv run python api_server.py
+# http://localhost:8000 에서 실행
+```
+
+### systemd 서비스
+
+```bash
+# 상태 확인
+systemctl --user status namecheap-api.service
+
+# 재시작
+systemctl --user restart namecheap-api.service
+
+# 로그 확인
+journalctl --user -u namecheap-api.service -f
+```
+
+### API 엔드포인트
+
+| Method | Endpoint | 설명 |
+|--------|----------|------|
+| GET | `/domains` | 도메인 목록 |
+| POST | `/domains/check` | 도메인 가용성 확인 |
+| GET | `/domains/{domain}` | 도메인 상세 정보 |
+| POST | `/domains/{domain}/renew` | 도메인 갱신 |
+| GET | `/domains/{domain}/contacts` | 등록자 정보 조회 |
+| PUT | `/domains/{domain}/contacts` | 등록자 정보 수정 |
+| GET | `/dns/{domain}/nameservers` | 네임서버 조회 |
+| PUT | `/dns/{domain}/nameservers` | 네임서버 변경 |
+| POST | `/dns/{domain}/nameservers/default` | 기본 NS 복원 |
+| GET | `/dns/{domain}/records` | DNS 레코드 조회 |
+| POST | `/dns/{domain}/glue` | 글루 레코드 생성 |
+| GET | `/dns/{domain}/glue/{nameserver}` | 글루 레코드 조회 |
+| PUT | `/dns/{domain}/glue` | 글루 레코드 수정 |
+| DELETE | `/dns/{domain}/glue/{nameserver}` | 글루 레코드 삭제 |
+| GET | `/account/balance` | 계정 잔액 |
+| GET | `/prices/{tld}` | TLD 가격 조회 |
+| GET | `/prices` | 전체 가격 목록 |
+| GET | `/openai/schema` | OpenAI Function 스키마 |
+
+### Swagger UI
+
+http://localhost:8000/docs
+
+### OpenAI Custom GPT 설정
+
+1. Custom GPT 생성
+2. Actions 추가
+3. Import from URL: `http://your-server:8000/openapi.json`
+
+## MCP 서버
+
+Claude에서 직접 Namecheap API를 사용할 수 있는 MCP 서버입니다.
+
+### MCP 도구 목록
+
+| 도구 | 설명 |
+|------|------|
+| `domains_check` | 도메인 가용성 확인 |
+| `domains_list` | 보유 도메인 목록 |
+| `domains_info` | 도메인 상세 정보 |
+| `domains_renew` | 도메인 갱신 |
+| `domains_get_contacts` | 등록자 정보 조회 |
+| `dns_get_nameservers` | 네임서버 조회 |
+| `dns_set_nameservers` | 네임서버 변경 |
+| `dns_set_default` | 기본 NS로 복원 |
+| `dns_get_records` | DNS 레코드 조회 |
+| `glue_create` | 글루 레코드 생성 |
+| `glue_get` | 글루 레코드 조회 |
+| `glue_update` | 글루 레코드 수정 |
+| `glue_delete` | 글루 레코드 삭제 |
+| `account_balance` | 계정 잔액 |
+| `price_check` | TLD 가격 조회 |
+
+### Claude Code 설정
+
+`~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "namecheap": {
+      "command": "/home/admin/.local/bin/uv",
+      "args": ["run", "--directory", "/home/admin/namecheap_api", "python", "mcp_server.py"]
+    }
+  }
+}
+```
+
+### Claude Desktop 설정
+
+`~/Library/Application Support/Claude/claude_desktop_config.json` (macOS):
+
+```json
+{
+  "mcpServers": {
+    "namecheap": {
+      "command": "uv",
+      "args": ["run", "--directory", "/path/to/namecheap_api", "python", "mcp_server.py"]
+    }
+  }
+}
+```
+
+### 테스트 실행
+
+```bash
+uv run python mcp_server.py
+```
+
+## 파일 구조
+
+```
+namecheap_api/
+├── .env                 # 환경 설정 (git 제외)
+├── .env.example         # 환경 설정 템플릿
+├── namecheap.py         # API 클라이언트
+├── __init__.py          # 패키지 export
+├── api_server.py        # REST API 서버 (OpenAI 호환)
+├── mcp_server.py        # MCP 서버 (Claude)
+├── db.py                # 데이터베이스 모듈
+├── prices.db            # SQLite 가격 DB
+├── prices.py            # 가격 조회 CLI
+├── update_prices.py     # 가격 업데이트 스크립트
+└── example.py           # 사용 예제
+```
+
+## systemd 서비스 파일
+
+```
+~/.config/systemd/user/
+├── namecheap-api.service     # REST API 서버
+├── namecheap-prices.service  # 가격 업데이트 서비스
+└── namecheap-prices.timer    # 가격 업데이트 타이머
+```
+
+## API 메서드
+
+| 메서드 | 설명 |
+|--------|------|
+| `domains_check(domains)` | 도메인 가용성 확인 |
+| `domains_get_list()` | 보유 도메인 목록 |
+| `domains_get_info(domain)` | 도메인 상세 정보 |
+| `domains_create(domain, registrant)` | 새 도메인 등록 |
+| `domains_renew(domain, years)` | 도메인 갱신 |
+| `domains_get_contacts(domain)` | 등록자 정보 조회 |
+| `domains_set_contacts(domain, registrant)` | 등록자 정보 수정 |
+| `dns_get_list(sld, tld)` | 네임서버 조회 |
+| `dns_get_hosts(sld, tld)` | DNS 레코드 조회 |
+| `dns_set_hosts(sld, tld, records)` | DNS 레코드 설정 |
+| `dns_set_custom(sld, tld, nameservers)` | 커스텀 NS 설정 |
+| `dns_set_default(sld, tld)` | 기본 NS로 복원 |
+| `ns_create(sld, tld, nameserver, ip)` | 글루 레코드 생성 |
+| `ns_get_info(sld, tld, nameserver)` | 글루 레코드 조회 |
+| `ns_update(sld, tld, nameserver, old_ip, ip)` | 글루 레코드 수정 |
+| `ns_delete(sld, tld, nameserver)` | 글루 레코드 삭제 |
+| `users_get_balances()` | 계정 잔액 조회 |
+| `users_get_pricing(type, category)` | 상품 가격 조회 |
diff --git a/__init__.py b/__init__.py
new file mode 100644
index 0000000..56761f3
--- /dev/null
+++ b/__init__.py
@@ -0,0 +1,3 @@
+from .namecheap import NamecheapAPI, NamecheapConfig, NamecheapError, RegistrantInfo
+
+__all__ = ["NamecheapAPI", "NamecheapConfig", "NamecheapError", "RegistrantInfo"]
diff --git a/api_server.py b/api_server.py
new file mode 100644
index 0000000..456c4c8
--- /dev/null
+++ b/api_server.py
@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+Namecheap REST API Server for OpenAI Function Calling
+"""
+
+import os
+from typing import Optional
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Header, Depends
+from pydantic import BaseModel
+
+from namecheap import NamecheapAPI, NamecheapConfig, RegistrantInfo
+
+load_dotenv()
+
+# API Key for authentication
+API_KEY = os.getenv("API_SERVER_KEY", "")
+
+
+def verify_api_key(x_api_key: str = Header(None)):
+    if API_KEY and x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+
+app = FastAPI(
+    title="Namecheap API",
+    description="REST API for Namecheap domain management",
+    version="1.0.0",
+    dependencies=[Depends(verify_api_key)],
+)
+
+# Initialize Namecheap API
+config = NamecheapConfig(
+    api_user=os.getenv("NAMECHEAP_API_USER", ""),
+    api_key=os.getenv("NAMECHEAP_API_KEY", ""),
+    username=os.getenv("NAMECHEAP_USERNAME", ""),
+    client_ip=os.getenv("NAMECHEAP_CLIENT_IP", ""),
+    sandbox=os.getenv("NAMECHEAP_SANDBOX", "false").lower() == "true",
+)
+api = NamecheapAPI(config)
+
+
+# ===== Models =====
+
+class DomainCheckRequest(BaseModel):
+    domains: list[str]
+
+class DomainRenewRequest(BaseModel):
+    domain: str
+    years: int = 1
+
+class NameserverRequest(BaseModel):
+    domain: str
+    nameservers: list[str]
+
+
+class GlueRecordRequest(BaseModel):
+    nameserver: str
+    ip: str
+
+
+class GlueRecordUpdateRequest(BaseModel):
+    nameserver: str
+    old_ip: str
+    ip: str
+
+class ContactRequest(BaseModel):
+    domain: str
+    organization: str = ""
+    first_name: str
+    last_name: str
+    address1: str
+    address2: str = ""
+    city: str
+    state_province: str
+    postal_code: str
+    country: str
+    phone: str
+    email: str
+
+
+# ===== Domain Endpoints =====
+
+@app.get("/domains")
+def list_domains(page: int = 1, page_size: int = 20):
+    """Get list of domains in account"""
+    return api.domains_get_list(page=page, page_size=page_size)
+
+
+@app.post("/domains/check")
+def check_domains(req: DomainCheckRequest):
+    """Check domain availability"""
+    return api.domains_check(req.domains)
+
+
+@app.get("/domains/{domain}")
+def get_domain_info(domain: str):
+    """Get detailed info about a domain"""
+    return api.domains_get_info(domain)
+
+
+@app.post("/domains/{domain}/renew")
+def renew_domain(domain: str, years: int = 1):
+    """Renew a domain. WARNING: This will charge your account."""
+    return api.domains_renew(domain, years=years)
+
+
+@app.get("/domains/{domain}/contacts")
+def get_domain_contacts(domain: str):
+    """Get domain contact information"""
+    return api.domains_get_contacts(domain)
+
+
+@app.put("/domains/{domain}/contacts")
+def set_domain_contacts(domain: str, req: ContactRequest):
+    """Set domain contact information"""
+    registrant = RegistrantInfo(
+        organization=req.organization,
+        first_name=req.first_name,
+        last_name=req.last_name,
+        address1=req.address1,
+        address2=req.address2,
+        city=req.city,
+        state_province=req.state_province,
+        postal_code=req.postal_code,
+        country=req.country,
+        phone=req.phone,
+        email=req.email,
+    )
+    success = api.domains_set_contacts(domain, registrant)
+    return {"success": success}
+
+
+# ===== DNS Endpoints =====
+
+@app.get("/dns/{domain}/nameservers")
+def get_nameservers(domain: str):
+    """Get nameserver information for a domain"""
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    return api.dns_get_list(sld, tld)
+
+
+@app.put("/dns/{domain}/nameservers")
+def set_nameservers(domain: str, req: NameserverRequest):
+    """Set custom nameservers for a domain"""
+    from namecheap import NamecheapError
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    try:
+        success = api.dns_set_custom(sld, tld, req.nameservers)
+        return {"success": success, "nameservers": req.nameservers}
+    except NamecheapError as e:
+        error_msg = str(e)
+        if "subordinate" in error_msg.lower() or "non existen" in error_msg.lower():
+            raise HTTPException(
+                status_code=400,
+                detail=f"네임서버 {req.nameservers}는 등록되지 않았습니다. 자기 도메인을 네임서버로 사용하려면 먼저 Child Nameserver(글루 레코드)를 IP 주소와 함께 등록해야 합니다."
+            )
+        raise HTTPException(status_code=400, detail=error_msg)
+
+
+@app.post("/dns/{domain}/nameservers/default")
+def set_default_nameservers(domain: str):
+    """Set default Namecheap nameservers"""
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    success = api.dns_set_default(sld, tld)
+    return {"success": success}
+
+
+@app.get("/dns/{domain}/records")
+def get_dns_records(domain: str):
+    """Get DNS records. Only works if using Namecheap DNS."""
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    return api.dns_get_hosts(sld, tld)
+
+
+# ===== Glue Record (Child Nameserver) Endpoints =====
+
+@app.post("/dns/{domain}/glue")
+def create_glue_record(domain: str, req: GlueRecordRequest):
+    """Create a glue record (child nameserver) for a domain"""
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    return api.ns_create(sld, tld, req.nameserver, req.ip)
+
+
+@app.get("/dns/{domain}/glue/{nameserver}")
+def get_glue_record(domain: str, nameserver: str):
+    """Get info about a glue record (child nameserver)"""
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    return api.ns_get_info(sld, tld, nameserver)
+
+
+@app.put("/dns/{domain}/glue")
+def update_glue_record(domain: str, req: GlueRecordUpdateRequest):
+    """Update a glue record (child nameserver) IP address"""
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    return api.ns_update(sld, tld, req.nameserver, req.old_ip, req.ip)
+
+
+@app.delete("/dns/{domain}/glue/{nameserver}")
+def delete_glue_record(domain: str, nameserver: str):
+    """Delete a glue record (child nameserver)"""
+    parts = domain.rsplit(".", 1)
+    if len(parts) != 2:
+        raise HTTPException(status_code=400, detail="Invalid domain format")
+    sld, tld = parts
+    return api.ns_delete(sld, tld, nameserver)
+
+
+# ===== Account Endpoints =====
+
+@app.get("/account/balance")
+def get_balance():
+    """Get account balance"""
+    return api.users_get_balances()
+
+
+@app.get("/prices/{tld}")
+def get_price(tld: str):
+    """Get registration price for a TLD"""
+    from db import get_prices, init_db
+    init_db()
+
+    prices = get_prices()
+    for p in prices:
+        if p["tld"] == tld:
+            return {"tld": tld, "usd": p["usd"], "krw": p["krw"]}
+
+    raise HTTPException(status_code=404, detail=f"TLD '{tld}' not found")
+
+
+@app.get("/prices")
+def list_prices(limit: int = 50):
+    """Get all TLD prices"""
+    from db import get_prices, init_db
+    init_db()
+    return get_prices()[:limit]
+
+
+# ===== OpenAI Schema =====
+
+@app.get("/openai/schema")
+def get_openai_schema():
+    """Get OpenAI Function Calling schema"""
+    return {
+        "functions": [
+            {
+                "name": "list_domains",
+                "description": "Get list of domains in account",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "page": {"type": "integer", "default": 1},
+                        "page_size": {"type": "integer", "default": 20}
+                    }
+                }
+            },
+            {
+                "name": "check_domains",
+                "description": "Check domain availability",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "domains": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "List of domains to check"
+                        }
+                    },
+                    "required": ["domains"]
+                }
+            },
+            {
+                "name": "get_domain_info",
+                "description": "Get detailed info about a domain",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "domain": {"type": "string"}
+                    },
+                    "required": ["domain"]
+                }
+            },
+            {
+                "name": "get_nameservers",
+                "description": "Get nameserver information for a domain",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "domain": {"type": "string"}
+                    },
+                    "required": ["domain"]
+                }
+            },
+            {
+                "name": "set_nameservers",
+                "description": "Set custom nameservers for a domain",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "domain": {"type": "string"},
+                        "nameservers": {
+                            "type": "array",
+                            "items": {"type": "string"}
+                        }
+                    },
+                    "required": ["domain", "nameservers"]
+                }
+            },
+            {
+                "name": "get_balance",
+                "description": "Get account balance",
+                "parameters": {"type": "object", "properties": {}}
+            },
+            {
+                "name": "get_price",
+                "description": "Get registration price for a TLD",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "tld": {"type": "string", "description": "TLD like com, net, io"}
+                    },
+                    "required": ["tld"]
+                }
+            }
+        ]
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
diff --git a/db.py b/db.py
new file mode 100644
index 0000000..4b37c6b
--- /dev/null
+++ b/db.py
@@ -0,0 +1,62 @@
+"""
+Database module for TLD prices
+"""
+
+import sqlite3
+from pathlib import Path
+
+DB_PATH = Path(__file__).parent / "prices.db"
+
+
+def get_connection():
+    return sqlite3.connect(DB_PATH)
+
+
+def init_db():
+    """Initialize database and create tables"""
+    conn = get_connection()
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS tld_prices (
+            tld TEXT PRIMARY KEY,
+            usd REAL NOT NULL,
+            krw INTEGER NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS exchange_rates (
+            currency TEXT PRIMARY KEY,
+            rate REAL NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+def get_prices() -> list[dict]:
+    """Get all TLD prices"""
+    conn = get_connection()
+    conn.row_factory = sqlite3.Row
+    cursor = conn.execute(
+        "SELECT tld, usd, krw, updated_at FROM tld_prices ORDER BY krw"
+    )
+    results = [dict(row) for row in cursor.fetchall()]
+    conn.close()
+    return results
+
+
+def get_exchange_rate(currency: str = "KRW") -> float | None:
+    """Get exchange rate for currency"""
+    conn = get_connection()
+    cursor = conn.execute(
+        "SELECT rate FROM exchange_rates WHERE currency = ?", (currency,)
+    )
+    row = cursor.fetchone()
+    conn.close()
+    return row[0] if row else None
+
+
+if __name__ == "__main__":
+    init_db()
+    print(f"Database initialized: {DB_PATH}")
diff --git a/example.py b/example.py
new file mode 100644
index 0000000..c55733e
--- /dev/null
+++ b/example.py
@@ -0,0 +1,64 @@
+"""
+Namecheap API 사용 예제
+"""
+
+import os
+from dotenv import load_dotenv
+from namecheap import NamecheapAPI, NamecheapConfig, NamecheapError
+
+load_dotenv()
+
+# 설정
+config = NamecheapConfig(
+    api_user=os.getenv("NAMECHEAP_API_USER", ""),
+    api_key=os.getenv("NAMECHEAP_API_KEY", ""),
+    username=os.getenv("NAMECHEAP_USERNAME", ""),
+    client_ip=os.getenv("NAMECHEAP_CLIENT_IP", ""),
+    sandbox=os.getenv("NAMECHEAP_SANDBOX", "true").lower() == "true",
+)
+
+api = NamecheapAPI(config)
+
+# === 도메인 가용성 확인 ===
+try:
+    result = api.domains_check(["example.com", "example.net", "example.org"])
+    for domain, available in result.items():
+        status = "사용 가능" if available else "이미 등록됨"
+        print(f"{domain}: {status}")
+except NamecheapError as e:
+    print(f"Error: {e}")
+
+# === 내 도메인 목록 조회 ===
+try:
+    domains = api.domains_get_list()
+    for d in domains:
+        print(f"{d['name']} - 만료일: {d['expires']}")
+except NamecheapError as e:
+    print(f"Error: {e}")
+
+# === DNS 레코드 조회 ===
+try:
+    records = api.dns_get_hosts("example", "com")
+    for r in records:
+        print(f"{r['name']}.example.com -> {r['type']} -> {r['address']}")
+except NamecheapError as e:
+    print(f"Error: {e}")
+
+# === DNS 레코드 설정 ===
+try:
+    new_records = [
+        {"name": "@", "type": "A", "address": "1.2.3.4", "ttl": "1800"},
+        {"name": "www", "type": "CNAME", "address": "example.com", "ttl": "1800"},
+        {"name": "@", "type": "MX", "address": "mail.example.com", "mx_pref": "10"},
+    ]
+    success = api.dns_set_hosts("example", "com", new_records)
+    print(f"DNS 설정 {'성공' if success else '실패'}")
+except NamecheapError as e:
+    print(f"Error: {e}")
+
+# === 계정 잔액 조회 ===
+try:
+    balance = api.users_get_balances()
+    print(f"잔액: ${balance['available_balance']:.2f} {balance['currency']}")
+except NamecheapError as e:
+    print(f"Error: {e}")
diff --git a/mcp_server.py b/mcp_server.py
new file mode 100644
index 0000000..76f4798
--- /dev/null
+++ b/mcp_server.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+Namecheap MCP Server
+"""
+
+import os
+from dotenv import load_dotenv
+from mcp.server.fastmcp import FastMCP
+
+from namecheap import NamecheapAPI, NamecheapConfig, RegistrantInfo
+
+load_dotenv()
+
+# Initialize MCP server
+mcp = FastMCP("namecheap")
+
+# Initialize Namecheap API
+config = NamecheapConfig(
+    api_user=os.getenv("NAMECHEAP_API_USER", ""),
+    api_key=os.getenv("NAMECHEAP_API_KEY", ""),
+    username=os.getenv("NAMECHEAP_USERNAME", ""),
+    client_ip=os.getenv("NAMECHEAP_CLIENT_IP", ""),
+    sandbox=os.getenv("NAMECHEAP_SANDBOX", "false").lower() == "true",
+)
+api = NamecheapAPI(config)
+
+
+# ===== Domain Tools =====
+
+@mcp.tool()
+def domains_check(domains: str) -> dict:
+    """
+    Check domain availability.
+
+    Args:
+        domains: Comma-separated domain names (e.g., "example.com,example.net")
+    """
+    domain_list = [d.strip() for d in domains.split(",")]
+    return api.domains_check(domain_list)
+
+
+@mcp.tool()
+def domains_list(page: int = 1, page_size: int = 20) -> list[dict]:
+    """
+    Get list of domains in account.
+
+    Args:
+        page: Page number (default: 1)
+        page_size: Number of domains per page (default: 20)
+    """
+    return api.domains_get_list(page=page, page_size=page_size)
+
+
+@mcp.tool()
+def domains_info(domain: str) -> dict:
+    """
+    Get detailed info about a domain.
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+    """
+    return api.domains_get_info(domain)
+
+
+@mcp.tool()
+def domains_renew(domain: str, years: int = 1) -> dict:
+    """
+    Renew a domain. WARNING: This will charge your account.
+
+    Args:
+        domain: Domain name to renew
+        years: Number of years (1-10)
+    """
+    return api.domains_renew(domain, years=years)
+
+
+@mcp.tool()
+def domains_get_contacts(domain: str) -> dict:
+    """
+    Get domain contact information.
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+    """
+    return api.domains_get_contacts(domain)
+
+
+# ===== DNS Tools =====
+
+@mcp.tool()
+def dns_get_nameservers(domain: str) -> dict:
+    """
+    Get nameserver information for a domain.
+
+    Args:
+        domain: Domain name (e.g., "example.com" or "sub.it.com")
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return {"error": "Invalid domain format"}
+
+    return api.dns_get_list(sld, tld)
+
+
+@mcp.tool()
+def dns_set_nameservers(domain: str, nameservers: str) -> dict:
+    """
+    Set custom nameservers for a domain.
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+        nameservers: Comma-separated nameservers (e.g., "ns1.cloudflare.com,ns2.cloudflare.com")
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return {"error": "Invalid domain format"}
+
+    ns_list = [ns.strip() for ns in nameservers.split(",")]
+    success = api.dns_set_custom(sld, tld, ns_list)
+
+    return {"success": success, "domain": domain, "nameservers": ns_list}
+
+
+@mcp.tool()
+def dns_set_default(domain: str) -> dict:
+    """
+    Set default Namecheap nameservers for a domain.
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return {"error": "Invalid domain format"}
+
+    success = api.dns_set_default(sld, tld)
+
+    return {"success": success, "domain": domain}
+
+
+@mcp.tool()
+def dns_get_records(domain: str) -> list[dict]:
+    """
+    Get DNS records for a domain. Only works if using Namecheap DNS.
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return [{"error": "Invalid domain format"}]
+
+    return api.dns_get_hosts(sld, tld)
+
+
+# ===== Glue Record (Child Nameserver) Tools =====
+
+@mcp.tool()
+def glue_create(domain: str, nameserver: str, ip: str) -> dict:
+    """
+    Create a glue record (child nameserver) for a domain.
+    Use this when you want to use your own domain as a nameserver (e.g., ns1.example.com for example.com).
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+        nameserver: Full nameserver hostname (e.g., "ns1.example.com")
+        ip: IP address for the nameserver
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return {"error": "Invalid domain format"}
+
+    return api.ns_create(sld, tld, nameserver, ip)
+
+
+@mcp.tool()
+def glue_get(domain: str, nameserver: str) -> dict:
+    """
+    Get info about a glue record (child nameserver).
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+        nameserver: Full nameserver hostname (e.g., "ns1.example.com")
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return {"error": "Invalid domain format"}
+
+    return api.ns_get_info(sld, tld, nameserver)
+
+
+@mcp.tool()
+def glue_update(domain: str, nameserver: str, old_ip: str, ip: str) -> dict:
+    """
+    Update a glue record (child nameserver) IP address.
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+        nameserver: Full nameserver hostname (e.g., "ns1.example.com")
+        old_ip: Current IP address
+        ip: New IP address
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return {"error": "Invalid domain format"}
+
+    return api.ns_update(sld, tld, nameserver, old_ip, ip)
+
+
+@mcp.tool()
+def glue_delete(domain: str, nameserver: str) -> dict:
+    """
+    Delete a glue record (child nameserver).
+
+    Args:
+        domain: Domain name (e.g., "example.com")
+        nameserver: Full nameserver hostname to delete (e.g., "ns1.example.com")
+    """
+    parts = domain.rsplit(".", 1)
+    if len(parts) == 2:
+        sld, tld = parts
+    else:
+        return {"error": "Invalid domain format"}
+
+    return api.ns_delete(sld, tld, nameserver)
+
+
+# ===== Account Tools =====
+
+@mcp.tool()
+def account_balance() -> dict:
+    """Get account balance."""
+    return api.users_get_balances()
+
+
+@mcp.tool()
+def price_check(tld: str) -> dict:
+    """
+    Get registration price for a TLD.
+
+    Args:
+        tld: TLD to check (e.g., "com", "net", "io")
+    """
+    from db import get_prices, init_db
+    init_db()
+
+    prices = get_prices()
+    for p in prices:
+        if p["tld"] == tld:
+            return {"tld": tld, "usd": p["usd"], "krw": p["krw"]}
+
+    return {"error": f"TLD '{tld}' not found"}
+
+
+if __name__ == "__main__":
+    mcp.run()
diff --git a/namecheap.py b/namecheap.py
new file mode 100644
index 0000000..fe8f88e
--- /dev/null
+++ b/namecheap.py
@@ -0,0 +1,549 @@
+"""
+Namecheap API Python Wrapper
+"""
+
+import requests
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+
+NS = {"nc": "http://api.namecheap.com/xml.response"}
+
+
+@dataclass
+class NamecheapConfig:
+    api_user: str
+    api_key: str
+    username: str
+    client_ip: str
+    sandbox: bool = False
+
+    @property
+    def base_url(self) -> str:
+        if self.sandbox:
+            return "https://api.sandbox.namecheap.com/xml.response"
+        return "https://api.namecheap.com/xml.response"
+
+
+@dataclass
+class RegistrantInfo:
+    first_name: str
+    last_name: str
+    address1: str
+    city: str
+    state_province: str
+    postal_code: str
+    country: str
+    phone: str
+    email: str
+    organization: str = ""
+    address2: str = ""
+
+
+class NamecheapError(Exception):
+    """Namecheap API error"""
+    def __init__(self, code: str, message: str):
+        self.code = code
+        self.message = message
+        super().__init__(f"[{code}] {message}")
+
+
+class NamecheapAPI:
+    def __init__(self, config: NamecheapConfig):
+        self.config = config
+
+    def _base_params(self) -> dict:
+        return {
+            "ApiUser": self.config.api_user,
+            "ApiKey": self.config.api_key,
+            "UserName": self.config.username,
+            "ClientIp": self.config.client_ip,
+        }
+
+    def _request(self, command: str, **kwargs) -> ET.Element:
+        params = self._base_params()
+        params["Command"] = command
+        params.update(kwargs)
+
+        response = requests.get(self.config.base_url, params=params, timeout=30)
+        response.raise_for_status()
+
+        root = ET.fromstring(response.text)
+        status = root.attrib.get("Status")
+
+        if status == "ERROR":
+            errors = root.find("nc:Errors", NS)
+            if errors is not None:
+                error = errors.find("nc:Error", NS)
+                if error is not None:
+                    raise NamecheapError(
+                        error.attrib.get("Number", "Unknown"),
+                        error.text or "Unknown error"
+                    )
+            raise NamecheapError("Unknown", "API returned error status")
+
+        return root
+
+    # ===== Domains =====
+
+    def domains_check(self, domains: list[str]) -> dict[str, bool]:
+        """Check domain availability"""
+        domain_list = ",".join(domains)
+        root = self._request("namecheap.domains.check", DomainList=domain_list)
+
+        result = {}
+        for domain in root.findall(".//nc:DomainCheckResult", NS):
+            name = domain.attrib.get("Domain", "")
+            available = domain.attrib.get("Available", "false").lower() == "true"
+            result[name] = available
+
+        return result
+
+    def domains_get_list(self, page: int = 1, page_size: int = 20) -> list[dict]:
+        """Get list of domains in account"""
+        root = self._request(
+            "namecheap.domains.getList",
+            Page=str(page),
+            PageSize=str(page_size)
+        )
+
+        domains = []
+        for domain in root.findall(".//nc:Domain", NS):
+            domains.append({
+                "id": domain.attrib.get("ID"),
+                "name": domain.attrib.get("Name"),
+                "user": domain.attrib.get("User"),
+                "created": domain.attrib.get("Created"),
+                "expires": domain.attrib.get("Expires"),
+                "is_expired": domain.attrib.get("IsExpired") == "true",
+                "is_locked": domain.attrib.get("IsLocked") == "true",
+                "auto_renew": domain.attrib.get("AutoRenew") == "true",
+                "whois_guard": domain.attrib.get("WhoisGuard"),
+            })
+
+        return domains
+
+    def domains_get_info(self, domain: str) -> dict:
+        """Get detailed info about a domain"""
+        root = self._request("namecheap.domains.getInfo", DomainName=domain)
+
+        info_elem = root.find(".//nc:DomainGetInfoResult", NS)
+        if info_elem is None:
+            return {}
+
+        return {
+            "domain": info_elem.attrib.get("DomainName"),
+            "owner": info_elem.attrib.get("OwnerName"),
+            "status": info_elem.attrib.get("Status"),
+            "is_premium": info_elem.attrib.get("IsPremiumName") == "true",
+        }
+
+    def domains_create(
+        self,
+        domain: str,
+        registrant: RegistrantInfo,
+        years: int = 1,
+        add_whois_guard: bool = True,
+    ) -> dict:
+        """
+        Register a new domain.
+
+        Args:
+            domain: Domain name to register (e.g., "example.com")
+            registrant: Registrant contact information
+            years: Number of years to register (1-10)
+            add_whois_guard: Enable WhoisGuard privacy protection
+
+        Returns:
+            dict with domain, registered, charged_amount, etc.
+        """
+        params = {
+            "DomainName": domain,
+            "Years": str(years),
+            "AddFreeWhoisguard": "yes" if add_whois_guard else "no",
+            "WGEnabled": "yes" if add_whois_guard else "no",
+        }
+
+        # Contact info for all 4 contact types (Registrant, Tech, Admin, AuxBilling)
+        for prefix in ["Registrant", "Tech", "Admin", "AuxBilling"]:
+            params[f"{prefix}FirstName"] = registrant.first_name
+            params[f"{prefix}LastName"] = registrant.last_name
+            params[f"{prefix}Address1"] = registrant.address1
+            params[f"{prefix}City"] = registrant.city
+            params[f"{prefix}StateProvince"] = registrant.state_province
+            params[f"{prefix}PostalCode"] = registrant.postal_code
+            params[f"{prefix}Country"] = registrant.country
+            params[f"{prefix}Phone"] = registrant.phone
+            params[f"{prefix}EmailAddress"] = registrant.email
+            if registrant.organization:
+                params[f"{prefix}OrganizationName"] = registrant.organization
+            if registrant.address2:
+                params[f"{prefix}Address2"] = registrant.address2
+
+        root = self._request("namecheap.domains.create", **params)
+        result = root.find(".//nc:DomainCreateResult", NS)
+
+        if result is None:
+            return {}
+
+        return {
+            "domain": result.attrib.get("Domain"),
+            "registered": result.attrib.get("Registered") == "true",
+            "charged_amount": float(result.attrib.get("ChargedAmount", 0)),
+            "domain_id": result.attrib.get("DomainID"),
+            "order_id": result.attrib.get("OrderID"),
+            "transaction_id": result.attrib.get("TransactionID"),
+            "whois_guard_enabled": result.attrib.get("WhoisguardEnable") == "true",
+        }
+
+    def domains_renew(self, domain: str, years: int = 1) -> dict:
+        """
+        Renew a domain.
+
+        Args:
+            domain: Domain name to renew (e.g., "example.com")
+            years: Number of years to renew (1-10)
+
+        Returns:
+            dict with domain, renewed, charged_amount, expiration_date, etc.
+        """
+        root = self._request(
+            "namecheap.domains.renew",
+            DomainName=domain,
+            Years=str(years),
+        )
+
+        result = root.find(".//nc:DomainRenewResult", NS)
+        if result is None:
+            return {}
+
+        return {
+            "domain": result.attrib.get("DomainName"),
+            "domain_id": result.attrib.get("DomainID"),
+            "renewed": result.attrib.get("Renew") == "true",
+            "charged_amount": float(result.attrib.get("ChargedAmount", 0)),
+            "order_id": result.attrib.get("OrderID"),
+            "transaction_id": result.attrib.get("TransactionID"),
+            "expiration_date": result.attrib.get("DomainDetails", {}).get("ExpiredDate") if isinstance(result.attrib.get("DomainDetails"), dict) else None,
+        }
+
+    def _parse_contact(self, contact_elem) -> dict:
+        """Parse contact element to dict"""
+        if contact_elem is None:
+            return {}
+
+        fields = [
+            "OrganizationName", "FirstName", "LastName", "Address1", "Address2",
+            "City", "StateProvince", "PostalCode", "Country", "Phone", "EmailAddress"
+        ]
+        result = {}
+        for field in fields:
+            elem = contact_elem.find(f"nc:{field}", NS)
+            key = field[0].lower() + field[1:]  # camelCase to snake_case style
+            result[key] = elem.text if elem is not None and elem.text else ""
+
+        return result
+
+    def domains_get_contacts(self, domain: str) -> dict:
+        """
+        Get domain contact information.
+
+        Args:
+            domain: Domain name (e.g., "example.com")
+
+        Returns:
+            dict with registrant, tech, admin, aux_billing contacts
+        """
+        root = self._request("namecheap.domains.getContacts", DomainName=domain)
+
+        result = root.find(".//nc:DomainContactsResult", NS)
+        if result is None:
+            return {}
+
+        return {
+            "domain": result.attrib.get("Domain"),
+            "registrant": self._parse_contact(result.find("nc:Registrant", NS)),
+            "tech": self._parse_contact(result.find("nc:Tech", NS)),
+            "admin": self._parse_contact(result.find("nc:Admin", NS)),
+            "aux_billing": self._parse_contact(result.find("nc:AuxBilling", NS)),
+        }
+
+    def domains_set_contacts(self, domain: str, registrant: RegistrantInfo) -> bool:
+        """
+        Set domain contact information.
+
+        Args:
+            domain: Domain name (e.g., "example.com")
+            registrant: Contact information (applied to all contact types)
+
+        Returns:
+            bool indicating success
+        """
+        params = {"DomainName": domain}
+
+        for prefix in ["Registrant", "Tech", "Admin", "AuxBilling"]:
+            params[f"{prefix}FirstName"] = registrant.first_name
+            params[f"{prefix}LastName"] = registrant.last_name
+            params[f"{prefix}Address1"] = registrant.address1
+            params[f"{prefix}City"] = registrant.city
+            params[f"{prefix}StateProvince"] = registrant.state_province
+            params[f"{prefix}PostalCode"] = registrant.postal_code
+            params[f"{prefix}Country"] = registrant.country
+            params[f"{prefix}Phone"] = registrant.phone
+            params[f"{prefix}EmailAddress"] = registrant.email
+            if registrant.organization:
+                params[f"{prefix}OrganizationName"] = registrant.organization
+            if registrant.address2:
+                params[f"{prefix}Address2"] = registrant.address2
+
+        root = self._request("namecheap.domains.setContacts", **params)
+        result = root.find(".//nc:DomainSetContactResult", NS)
+
+        return result is not None and result.attrib.get("IsSuccess") == "true"
+
+    # ===== DNS =====
+
+    def dns_get_list(self, sld: str, tld: str) -> dict:
+        """Get nameserver information for a domain"""
+        root = self._request("namecheap.domains.dns.getList", SLD=sld, TLD=tld)
+
+        result = root.find(".//nc:DomainDNSGetListResult", NS)
+        if result is None:
+            return {}
+
+        nameservers = []
+        for ns in result.findall("nc:Nameserver", NS):
+            nameservers.append(ns.text)
+
+        return {
+            "domain": result.attrib.get("Domain"),
+            "is_using_our_dns": result.attrib.get("IsUsingOurDNS") == "true",
+            "nameservers": nameservers,
+        }
+
+    def dns_get_hosts(self, sld: str, tld: str) -> list[dict]:
+        """Get DNS host records"""
+        root = self._request("namecheap.domains.dns.getHosts", SLD=sld, TLD=tld)
+
+        records = []
+        for host in root.findall(".//nc:host", NS):
+            records.append({
+                "host_id": host.attrib.get("HostId"),
+                "name": host.attrib.get("Name"),
+                "type": host.attrib.get("Type"),
+                "address": host.attrib.get("Address"),
+                "mx_pref": host.attrib.get("MXPref"),
+                "ttl": host.attrib.get("TTL"),
+            })
+
+        return records
+
+    def dns_set_hosts(self, sld: str, tld: str, records: list[dict]) -> bool:
+        """
+        Set DNS host records.
+
+        Each record should have: name, type, address, ttl (optional), mx_pref (optional)
+        """
+        params = {"SLD": sld, "TLD": tld}
+
+        for i, record in enumerate(records, 1):
+            params[f"HostName{i}"] = record["name"]
+            params[f"RecordType{i}"] = record["type"]
+            params[f"Address{i}"] = record["address"]
+            params[f"TTL{i}"] = record.get("ttl", "1800")
+            if record["type"] == "MX":
+                params[f"MXPref{i}"] = record.get("mx_pref", "10")
+
+        root = self._request("namecheap.domains.dns.setHosts", **params)
+        result = root.find(".//nc:DomainDNSSetHostsResult", NS)
+
+        return result is not None and result.attrib.get("IsSuccess") == "true"
+
+    def dns_set_custom(self, sld: str, tld: str, nameservers: list[str]) -> bool:
+        """Set custom nameservers"""
+        ns_string = ",".join(nameservers)
+        root = self._request(
+            "namecheap.domains.dns.setCustom",
+            SLD=sld,
+            TLD=tld,
+            Nameservers=ns_string
+        )
+
+        result = root.find(".//nc:DomainDNSSetCustomResult", NS)
+        return result is not None and result.attrib.get("Updated") == "true"
+
+    def dns_set_default(self, sld: str, tld: str) -> bool:
+        """Set default Namecheap nameservers"""
+        root = self._request("namecheap.domains.dns.setDefault", SLD=sld, TLD=tld)
+
+        result = root.find(".//nc:DomainDNSSetDefaultResult", NS)
+        return result is not None and result.attrib.get("Updated") == "true"
+
+    # ===== Nameservers (Glue Records) =====
+
+    def ns_create(self, sld: str, tld: str, nameserver: str, ip: str) -> dict:
+        """
+        Create a child nameserver (glue record).
+
+        Args:
+            sld: Second-level domain (e.g., "example" for example.com)
+            tld: Top-level domain (e.g., "com")
+            nameserver: Nameserver hostname (e.g., "ns1.example.com")
+            ip: IP address for the nameserver
+
+        Returns:
+            dict with domain, nameserver, ip, success
+        """
+        root = self._request(
+            "namecheap.domains.ns.create",
+            SLD=sld,
+            TLD=tld,
+            Nameserver=nameserver,
+            IP=ip,
+        )
+
+        result = root.find(".//nc:DomainNSCreateResult", NS)
+        if result is None:
+            return {}
+
+        return {
+            "domain": result.attrib.get("Domain"),
+            "nameserver": result.attrib.get("Nameserver"),
+            "ip": result.attrib.get("IP"),
+            "success": result.attrib.get("IsSuccess") == "true",
+        }
+
+    def ns_delete(self, sld: str, tld: str, nameserver: str) -> dict:
+        """
+        Delete a child nameserver (glue record).
+
+        Args:
+            sld: Second-level domain (e.g., "example" for example.com)
+            tld: Top-level domain (e.g., "com")
+            nameserver: Nameserver hostname to delete (e.g., "ns1.example.com")
+
+        Returns:
+            dict with domain, nameserver, success
+        """
+        root = self._request(
+            "namecheap.domains.ns.delete",
+            SLD=sld,
+            TLD=tld,
+            Nameserver=nameserver,
+        )
+
+        result = root.find(".//nc:DomainNSDeleteResult", NS)
+        if result is None:
+            return {}
+
+        return {
+            "domain": result.attrib.get("Domain"),
+            "nameserver": result.attrib.get("Nameserver"),
+            "success": result.attrib.get("IsSuccess") == "true",
+        }
+
+    def ns_get_info(self, sld: str, tld: str, nameserver: str) -> dict:
+        """
+        Get info about a child nameserver (glue record).
+
+        Args:
+            sld: Second-level domain (e.g., "example" for example.com)
+            tld: Top-level domain (e.g., "com")
+            nameserver: Nameserver hostname (e.g., "ns1.example.com")
+
+        Returns:
+            dict with domain, nameserver, ip, statuses
+        """
+        root = self._request(
+            "namecheap.domains.ns.getInfo",
+            SLD=sld,
+            TLD=tld,
+            Nameserver=nameserver,
+        )
+
+        result = root.find(".//nc:DomainNSInfoResult", NS)
+        if result is None:
+            return {}
+
+        statuses = []
+        for status in result.findall("nc:NameserverStatuses/nc:Status", NS):
+            if status.text:
+                statuses.append(status.text)
+
+        return {
+            "domain": result.attrib.get("Domain"),
+            "nameserver": result.attrib.get("Nameserver"),
+            "ip": result.attrib.get("IP"),
+            "statuses": statuses,
+        }
+
+    def ns_update(self, sld: str, tld: str, nameserver: str, old_ip: str, ip: str) -> dict:
+        """
+        Update a child nameserver (glue record) IP address.
+
+        Args:
+            sld: Second-level domain (e.g., "example" for example.com)
+            tld: Top-level domain (e.g., "com")
+            nameserver: Nameserver hostname (e.g., "ns1.example.com")
+            old_ip: Current IP address
+            ip: New IP address
+
+        Returns:
+            dict with domain, nameserver, ip, success
+        """
+        root = self._request(
+            "namecheap.domains.ns.update",
+            SLD=sld,
+            TLD=tld,
+            Nameserver=nameserver,
+            OldIP=old_ip,
+            IP=ip,
+        )
+
+        result = root.find(".//nc:DomainNSUpdateResult", NS)
+        if result is None:
+            return {}
+
+        return {
+            "domain": result.attrib.get("Domain"),
+            "nameserver": result.attrib.get("Nameserver"),
+            "ip": result.attrib.get("IP"),
+            "success": result.attrib.get("IsSuccess") == "true",
+        }
+
+    # ===== Account =====
+
+    def users_get_balances(self) -> dict:
+        """Get account balance"""
+        root = self._request("namecheap.users.getBalances")
+
+        balance = root.find(".//nc:UserGetBalancesResult", NS)
+        if balance is None:
+            return {}
+
+        return {
+            "currency": balance.attrib.get("Currency"),
+            "available_balance": float(balance.attrib.get("AvailableBalance", 0)),
+            "account_balance": float(balance.attrib.get("AccountBalance", 0)),
+            "earned_amount": float(balance.attrib.get("EarnedAmount", 0)),
+        }
+
+    def users_get_pricing(self, product_type: str, product_category: str = "") -> list[dict]:
+        """Get pricing for products"""
+        params = {"ProductType": product_type}
+        if product_category:
+            params["ProductCategory"] = product_category
+
+        root = self._request("namecheap.users.getPricing", **params)
+
+        products = []
+        for product in root.findall(".//nc:Product", NS):
+            for price in product.findall(".//nc:Price", NS):
+                products.append({
+                    "name": product.attrib.get("Name"),
+                    "duration": price.attrib.get("Duration"),
+                    "duration_type": price.attrib.get("DurationType"),
+                    "price": float(price.attrib.get("Price", 0)),
+                    "currency": price.attrib.get("Currency"),
+                })
+
+        return products
diff --git a/prices.db b/prices.db
new file mode 100644
index 0000000..f16ee97
Binary files /dev/null and b/prices.db differ
diff --git a/prices.py b/prices.py
new file mode 100755
index 0000000..1665313
--- /dev/null
+++ b/prices.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+CLI to query TLD prices from database
+"""
+
+import sys
+from db import get_prices, get_exchange_rate, init_db
+
+
+def show_prices(filter_tld: str = None, limit: int = 30):
+    """Display TLD prices"""
+    init_db()
+    prices = get_prices()
+    rate = get_exchange_rate()
+
+    if not prices:
+        print("No prices in database. Run update_prices.py first.")
+        return
+
+    if filter_tld:
+        prices = [p for p in prices if filter_tld.lower() in p["tld"].lower()]
+
+    print(f"Exchange rate: $1 = ₩{rate:,.0f}")
+    print(f"{'TLD':12} {'USD':>8} {'KRW':>10}")
+    print("-" * 32)
+
+    for p in prices[:limit]:
+        print(f".{p['tld']:11} ${p['usd']:7.2f} {p['krw']:>9,}원")
+
+    if len(prices) > limit:
+        print(f"\n... and {len(prices) - limit} more")
+
+
+def main():
+    if len(sys.argv) > 1:
+        filter_tld = sys.argv[1]
+        show_prices(filter_tld, limit=100)
+    else:
+        show_prices()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..d4e77b6
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "namecheap-api"
+version = "0.1.0"
+description = "Namecheap API Python Wrapper"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "fastapi>=0.128.0",
+    "mcp>=1.25.0",
+    "python-dotenv>=1.2.1",
+    "requests>=2.32.5",
+]
diff --git a/update_prices.py b/update_prices.py
new file mode 100755
index 0000000..a5face0
--- /dev/null
+++ b/update_prices.py
@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Update TLD prices from Namecheap API with current exchange rate
+"""
+
+import os
+import math
+import requests
+import xml.etree.ElementTree as ET
+from datetime import datetime
+from dotenv import load_dotenv
+
+from db import get_connection, init_db
+
+load_dotenv()
+
+NS = {"nc": "http://api.namecheap.com/xml.response"}
+
+
+def get_exchange_rate() -> float:
+    """Fetch current USD to KRW exchange rate"""
+    resp = requests.get(
+        "https://api.exchangerate-api.com/v4/latest/USD",
+        timeout=30
+    )
+    resp.raise_for_status()
+    return resp.json()["rates"]["KRW"]
+
+
+def get_namecheap_prices() -> dict[str, float]:
+    """Fetch domain prices from Namecheap API"""
+    params = {
+        "ApiUser": os.getenv("NAMECHEAP_API_USER"),
+        "ApiKey": os.getenv("NAMECHEAP_API_KEY"),
+        "UserName": os.getenv("NAMECHEAP_USERNAME"),
+        "ClientIp": os.getenv("NAMECHEAP_CLIENT_IP"),
+        "Command": "namecheap.users.getPricing",
+        "ProductType": "DOMAIN",
+        "ProductCategory": "REGISTER",
+    }
+
+    resp = requests.get(
+        "https://api.namecheap.com/xml.response",
+        params=params,
+        timeout=120
+    )
+    resp.raise_for_status()
+
+    root = ET.fromstring(resp.text)
+    prices = {}
+
+    for product in root.findall(".//nc:Product", NS):
+        tld = product.attrib.get("Name")
+        for price in product.findall(".//nc:Price", NS):
+            if price.attrib.get("Duration") == "1":
+                prices[tld] = float(price.attrib.get("Price", 0))
+                break
+
+    return prices
+
+
+VAT = 1.10      # 부가세 10%
+MARGIN = 1.03   # 마진 3%
+
+
+def to_krw_1000(usd: float, rate: float) -> int:
+    """Convert USD to KRW with VAT + margin, rounded up to nearest 1000"""
+    krw = usd * rate * VAT * MARGIN
+    return math.ceil(krw / 1000) * 1000
+
+
+def update_database(prices: dict[str, float], rate: float):
+    """Update database with new prices"""
+    conn = get_connection()
+    now = datetime.now().isoformat()
+
+    # Update exchange rate
+    conn.execute(
+        """
+        INSERT OR REPLACE INTO exchange_rates (currency, rate, updated_at)
+        VALUES (?, ?, ?)
+        """,
+        ("KRW", rate, now)
+    )
+
+    # Update TLD prices
+    for tld, usd in prices.items():
+        krw = to_krw_1000(usd, rate)
+        conn.execute(
+            """
+            INSERT OR REPLACE INTO tld_prices (tld, usd, krw, updated_at)
+            VALUES (?, ?, ?, ?)
+            """,
+            (tld, usd, krw, now)
+        )
+
+    conn.commit()
+    conn.close()
+
+
+def main():
+    print(f"[{datetime.now()}] Starting price update...")
+
+    # Initialize DB if needed
+    init_db()
+
+    # Get exchange rate
+    print("Fetching exchange rate...")
+    rate = get_exchange_rate()
+    print(f"USD/KRW: {rate:.2f}")
+
+    # Get prices from Namecheap
+    print("Fetching Namecheap prices...")
+    prices = get_namecheap_prices()
+    print(f"Got {len(prices)} TLD prices")
+
+    # Update database
+    print("Updating database...")
+    update_database(prices, rate)
+
+    print("Done!")
+
+    # Show some popular TLDs
+    popular = ["com", "net", "org", "io", "dev", "app", "me", "xyz", "co", "in"]
+    print("\nPopular TLDs:")
+    for tld in popular:
+        if tld in prices:
+            krw = to_krw_1000(prices[tld], rate)
+            print(f"  .{tld:6} ${prices[tld]:6.2f} → {krw:,}원")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..49a28c5
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,653 @@
+version = 1
+revision = 3
+requires-python = ">=3.13"
+
+[[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.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[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 = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[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 = "cryptography"
+version = "46.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
+    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
+    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
+    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
+    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
+    { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" },
+    { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
+    { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
+    { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
+    { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload-time = "2025-10-15T23:17:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload-time = "2025-10-15T23:17:42.769Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload-time = "2025-10-15T23:17:44.468Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" },
+    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
+    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
+    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" },
+    { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.128.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/08/8c8508db6c7b9aae8f7175046af41baad690771c9bcde676419965e338c7/fastapi-0.128.0.tar.gz", hash = "sha256:1cc179e1cef10a6be60ffe429f79b829dce99d8de32d7acb7e6c8dfdf7f2645a", size = 365682, upload-time = "2025-12-27T15:21:13.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/05/5cbb59154b093548acd0f4c7c474a118eda06da25aa75c616b72d8fcd92a/fastapi-0.128.0-py3-none-any.whl", hash = "sha256:aebd93f9716ee3b4f4fcfe13ffb7cf308d99c9f3ab5622d8877441072561582d", size = 103094, upload-time = "2025-12-27T15:21:12.154Z" },
+]
+
+[[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 = "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 = "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 = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[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 = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "mcp"
+version = "1.25.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpx" },
+    { name = "httpx-sse" },
+    { name = "jsonschema" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "python-multipart" },
+    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d5/2d/649d80a0ecf6a1f82632ca44bec21c0461a9d9fc8934d38cb5b319f2db5e/mcp-1.25.0.tar.gz", hash = "sha256:56310361ebf0364e2d438e5b45f7668cbb124e158bb358333cd06e49e83a6802", size = 605387, upload-time = "2025-12-19T10:19:56.985Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/fc/6dc7659c2ae5ddf280477011f4213a74f806862856b796ef08f028e664bf/mcp-1.25.0-py3-none-any.whl", hash = "sha256:b37c38144a666add0862614cc79ec276e97d72aa8ca26d622818d4e278b9721a", size = 233076, upload-time = "2025-12-19T10:19:55.416Z" },
+]
+
+[[package]]
+name = "namecheap-api"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "fastapi" },
+    { name = "mcp" },
+    { name = "python-dotenv" },
+    { name = "requests" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi", specifier = ">=0.128.0" },
+    { name = "mcp", specifier = ">=1.25.0" },
+    { name = "python-dotenv", specifier = ">=1.2.1" },
+    { name = "requests", specifier = ">=2.32.5" },
+]
+
+[[package]]
+name = "pycparser"
+version = "2.23"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+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/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[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/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { 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 = "pydantic-settings"
+version = "2.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.10.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography" },
+]
+
+[[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 = "python-multipart"
+version = "0.0.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/96/804520d0850c7db98e5ccb70282e29208723f0964e88ffd9d0da2f52ea09/python_multipart-0.0.21.tar.gz", hash = "sha256:7137ebd4d3bbf70ea1622998f902b97a29434a9e8dc40eb203bbcf7c2a2cba92", size = 37196, upload-time = "2025-12-17T09:24:22.446Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/76/03af049af4dcee5d27442f71b6924f01f3efb5d2bd34f23fcd563f2cc5f5/python_multipart-0.0.21-py3-none-any.whl", hash = "sha256:cf7a6713e01c87aa35387f4774e812c4361150938d20d232800f75ffcf266090", size = 24541, upload-time = "2025-12-17T09:24:21.153Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "311"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" },
+    { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" },
+    { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" },
+    { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" },
+    { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" },
+    { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" },
+    { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" },
+    { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" },
+    { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" },
+    { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" },
+    { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" },
+    { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" },
+    { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" },
+    { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/34/f5df66cb383efdbf4f2db23cabb27f51b1dcb737efaf8a558f6f1d195134/sse_starlette-3.1.2.tar.gz", hash = "sha256:55eff034207a83a0eb86de9a68099bd0157838f0b8b999a1b742005c71e33618", size = 26303, upload-time = "2025-12-31T08:02:20.023Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/95/8c4b76eec9ae574474e5d2997557cebf764bcd3586458956c30631ae08f4/sse_starlette-3.1.2-py3-none-any.whl", hash = "sha256:cd800dd349f4521b317b9391d3796fa97b71748a4da9b9e00aafab32dda375c8", size = 12484, upload-time = "2025-12-31T08:02:18.894Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.50.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca", size = 2646985, upload-time = "2025-11-01T15:25:27.516Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload-time = "2025-11-01T15:25:25.461Z" },
+]
+
+[[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 = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/d8/2083a1daa7439a66f3a48589a57d576aa117726762618f6bb09fe3798796/uvicorn-0.40.0-py3-none-any.whl", hash = "sha256:c6c8f55bc8bf13eb6fa9ff87ad62308bbbc33d0b67f84293151efe87e0d5f2ee", size = 68502, upload-time = "2025-12-21T14:16:21.041Z" },
+]