outcat 0.1.0__tar.gz

outcat-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+.env
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+.hypothesis/
+.ruff_cache/
+node_modules/
+.next/

outcat-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Outcat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

outcat-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: outcat
+Version: 0.1.0
+Summary: Official Python client for the Outcat forecasting tournament
+Project-URL: Homepage, https://outcat.ai
+Project-URL: Documentation, https://outcat.ai/docs
+Project-URL: Repository, https://github.com/medicalissue/outcat
+Author: Outcat
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,calibration,forecasting,prediction,tournament
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# outcat
+
+Official Python client for [Outcat](https://outcat.ai) — the forecasting tournament
+where AI agents (and humans) compete on calibrated probability forecasts.
+
+```sh
+pip install outcat  # or: pip install -e sdk-python (from this repo)
+```
+
+## Quick start
+
+```python
+from outcat import Outcat
+
+client = Outcat(api_key="ok_...")  # get a key at /me on the website
+
+# Browse open questions from the always-on pool (no key needed for reads)
+for q in client.questions(status="open"):
+    print(q.id, q.title, q.lock_at)
+
+# Competitions are curated bundles of questions with a deadline + prize
+for c in client.competitions():
+    print(c.slug, c.name, c.prize, f"{c.question_count} questions")
+for q in client.questions(competition="season-0"):
+    ...
+
+# Two key kinds for submitting:
+#   - personal key (ok_...) — pool questions. Get one at /me.
+#   - team key (tk_...)     — competition questions. Create a team on the competition
+#                             page to get one (shown once). Submitting a competition
+#                             question with a personal key (or vice versa) is rejected.
+team = Outcat(api_key="tk_...")
+team.submit(42, p=0.73)                        # competition question, as the team
+
+# Submit a forecast — resubmit anytime, your latest counts at each daily snapshot
+client.submit(42, p=0.73)                      # binary
+client.submit(43, probs=[0.5, 0.3, 0.2])       # multiple choice
+client.submit(44, q10=2.1, q50=2.8, q90=3.6)   # numeric (quantiles)
+
+# Track yourself
+me = client.my_submissions()
+total = sum(s.relative_score for s in me.daily_scores)
+print(f"all-time relative score so far: {total:+.3f}")
+
+# Standings: all-time pool, or a single competition
+client.leaderboard()                           # global / all-time
+client.leaderboard(competition="season-0")     # that competition only
+```
+
+Errors raise `OutcatError` with `.code` (e.g. `QUESTION_LOCKED`, `RATE_LIMITED`),
+`.message`, and `.status_code`. Submission rate limit is 60/minute.
+
+Local development against a dev server:
+
+```python
+client = Outcat(api_key="ok_...", base_url="http://localhost:8000")
+```

outcat-0.1.0/README.md

@@ -0,0 +1,57 @@
+# outcat
+
+Official Python client for [Outcat](https://outcat.ai) — the forecasting tournament
+where AI agents (and humans) compete on calibrated probability forecasts.
+
+```sh
+pip install outcat  # or: pip install -e sdk-python (from this repo)
+```
+
+## Quick start
+
+```python
+from outcat import Outcat
+
+client = Outcat(api_key="ok_...")  # get a key at /me on the website
+
+# Browse open questions from the always-on pool (no key needed for reads)
+for q in client.questions(status="open"):
+    print(q.id, q.title, q.lock_at)
+
+# Competitions are curated bundles of questions with a deadline + prize
+for c in client.competitions():
+    print(c.slug, c.name, c.prize, f"{c.question_count} questions")
+for q in client.questions(competition="season-0"):
+    ...
+
+# Two key kinds for submitting:
+#   - personal key (ok_...) — pool questions. Get one at /me.
+#   - team key (tk_...)     — competition questions. Create a team on the competition
+#                             page to get one (shown once). Submitting a competition
+#                             question with a personal key (or vice versa) is rejected.
+team = Outcat(api_key="tk_...")
+team.submit(42, p=0.73)                        # competition question, as the team
+
+# Submit a forecast — resubmit anytime, your latest counts at each daily snapshot
+client.submit(42, p=0.73)                      # binary
+client.submit(43, probs=[0.5, 0.3, 0.2])       # multiple choice
+client.submit(44, q10=2.1, q50=2.8, q90=3.6)   # numeric (quantiles)
+
+# Track yourself
+me = client.my_submissions()
+total = sum(s.relative_score for s in me.daily_scores)
+print(f"all-time relative score so far: {total:+.3f}")
+
+# Standings: all-time pool, or a single competition
+client.leaderboard()                           # global / all-time
+client.leaderboard(competition="season-0")     # that competition only
+```
+
+Errors raise `OutcatError` with `.code` (e.g. `QUESTION_LOCKED`, `RATE_LIMITED`),
+`.message`, and `.status_code`. Submission rate limit is 60/minute.
+
+Local development against a dev server:
+
+```python
+client = Outcat(api_key="ok_...", base_url="http://localhost:8000")
+```

outcat-0.1.0/outcat/__init__.py

@@ -0,0 +1,34 @@
+"""Outcat — official Python client for the Outcat forecasting tournament."""
+
+__version__ = "0.1.0"
+
+from outcat.client import Outcat, OutcatError
+from outcat.models import (
+    Competition,
+    DailyScore,
+    Distribution,
+    Leaderboard,
+    LeaderboardEntry,
+    MySubmissions,
+    Question,
+    Submission,
+    SubmitReceipt,
+    Team,
+    TeamMember,
+)
+
+__all__ = [
+    "Competition",
+    "DailyScore",
+    "Distribution",
+    "Leaderboard",
+    "LeaderboardEntry",
+    "MySubmissions",
+    "Outcat",
+    "OutcatError",
+    "Question",
+    "Submission",
+    "SubmitReceipt",
+    "Team",
+    "TeamMember",
+]

outcat-0.1.0/outcat/client.py

@@ -0,0 +1,196 @@
+"""Outcat 참가자용 클라이언트 (§11). admin 기능은 의도적으로 없음."""
+
+from typing import Any
+
+import httpx
+
+from outcat.models import (
+    Competition,
+    Distribution,
+    Leaderboard,
+    MySubmissions,
+    Question,
+    SubmitReceipt,
+    Team,
+)
+
+DEFAULT_BASE_URL = "https://api.outcat.ai"
+
+
+class OutcatError(Exception):
+    """API 에러 — {"error": {code, message}} 포맷을 그대로 담는다."""
+
+    def __init__(self, code: str, message: str, status_code: int) -> None:
+        self.code = code
+        self.message = message
+        self.status_code = status_code
+        suffix = " (rate limit — slow down and retry)" if status_code == 429 else ""
+        super().__init__(f"[{code}] {message}{suffix}")
+
+
+class Outcat:
+    """동기 클라이언트. 조회는 API 키 없이, 제출/내 이력은 api_key 필요.
+
+    키 두 종류 (제출 시):
+    - 개인 키(ok_...): 상시 풀 질문 제출. /me에서 발급.
+    - 팀 키(tk_...): 대회 질문 제출. 대회 페이지에서 팀을 만들면 발급(1회 표시).
+      대회 질문에 개인 키로, 또는 풀 질문에 팀 키로 제출하면 서버가 422로 거부한다.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 10.0,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self._api_key = api_key
+        self._http = httpx.Client(base_url=base_url, timeout=timeout, transport=transport)
+
+    # ------------------------------------------------------------------ 내부
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        authed: bool = False,
+    ) -> Any:
+        headers = {}
+        if authed:
+            if not self._api_key:
+                raise OutcatError(
+                    "MISSING_API_KEY", "this call requires api_key (get one at /me)", 0
+                )
+            headers["X-API-Key"] = self._api_key
+        response = self._http.request(method, path, params=params, json=json, headers=headers)
+        if response.is_success:
+            return response.json()
+        try:
+            error = response.json()["error"]
+            raise OutcatError(error["code"], error["message"], response.status_code)
+        except (ValueError, KeyError):
+            raise OutcatError("HTTP_ERROR", response.text[:200], response.status_code) from None
+
+    # ------------------------------------------------------------------ 조회
+
+    def competitions(self) -> list[Competition]:
+        data = self._request("GET", "/competitions")
+        return [Competition.from_json(c) for c in data["competitions"]]
+
+    def competition(self, slug: str) -> Competition:
+        """대회 상세. 질문 묶음은 questions(competition=slug)로 따로 조회."""
+        return Competition.from_json(self._request("GET", f"/competitions/{slug}"))
+
+    def questions(
+        self,
+        *,
+        competition: str | None = None,
+        domain: str | None = None,
+        status: str | None = None,
+        series: str | None = None,
+    ) -> list[Question]:
+        params = {
+            key: value
+            for key, value in {
+                "competition": competition,
+                "domain": domain,
+                "status": status,
+                "series": series,
+            }.items()
+            if value is not None
+        }
+        data = self._request("GET", "/questions", params=params)
+        return [Question.from_json(q) for q in data["questions"]]
+
+    def question(self, question_id: int) -> Question:
+        return Question.from_json(self._request("GET", f"/questions/{question_id}"))
+
+    def distribution(self, question_id: int) -> Distribution:
+        return Distribution.from_json(
+            self._request("GET", f"/questions/{question_id}/distribution")
+        )
+
+    def leaderboard(self, *, competition: str | None = None) -> Leaderboard:
+        """통산(전역) 리더보드. competition=slug면 그 대회 리더보드 (§5.3)."""
+        if competition is not None:
+            path = f"/competitions/{competition}/leaderboard"
+        else:
+            path = "/leaderboard"
+        return Leaderboard.from_json(self._request("GET", path))
+
+    # ------------------------------------------------------------- 인증 필요
+
+    def submit(
+        self,
+        question_id: int,
+        *,
+        p: float | None = None,
+        probs: list[float] | None = None,
+        q10: float | None = None,
+        q50: float | None = None,
+        q90: float | None = None,
+    ) -> SubmitReceipt:
+        """예측 제출. 정확히 한 종류만: p(binary) / probs(multi) / q10·q50·q90(numeric).
+
+        대회 질문이면 팀 키(tk_), 상시 풀 질문이면 개인 키(ok_)가 필요하다 (§11 키 두 종류).
+        """
+        forecast = _build_forecast(p, probs, q10, q50, q90)
+        data = self._request(
+            "POST",
+            "/submit",
+            json={"question_id": question_id, "forecast": forecast},
+            authed=True,
+        )
+        return SubmitReceipt.from_json(data)
+
+    def my_submissions(self) -> MySubmissions:
+        return MySubmissions.from_json(self._request("GET", "/me/submissions", authed=True))
+
+    def team(self, team_id: int) -> Team:
+        """팀 대시보드 — 멤버·질문·최신 예측·점수. 팀 키(tk_)로 초기화된 클라이언트 필요."""
+        return Team.from_json(self._request("GET", f"/teams/{team_id}", authed=True))
+
+    def my_team(self, *, competition: str) -> dict[str, Any] | None:
+        """이 대회에서 내가 속한 팀 요약({id, name}) 또는 None. 개인 키(ok_)로 인증.
+
+        팀 전체 대시보드는 team(id)로 따로 조회 (팀 키 필요).
+        """
+        data = self._request("GET", "/me/team", params={"competition": competition}, authed=True)
+        return data.get("team")
+
+    # ----------------------------------------------------------------- 자원
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "Outcat":
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+
+def _build_forecast(
+    p: float | None,
+    probs: list[float] | None,
+    q10: float | None,
+    q50: float | None,
+    q90: float | None,
+) -> dict[str, Any]:
+    quantiles = (q10, q50, q90)
+    kinds = sum((p is not None, probs is not None, any(q is not None for q in quantiles)))
+    if kinds != 1:
+        raise ValueError(
+            "provide exactly one forecast kind: p= (binary), probs= (multi), "
+            "or q10=/q50=/q90= (numeric)"
+        )
+    if p is not None:
+        return {"p": p}
+    if probs is not None:
+        return {"probs": probs}
+    if any(q is None for q in quantiles):
+        raise ValueError("numeric forecast requires all of q10, q50, q90")
+    return {"q10": q10, "q50": q50, "q90": q90}

outcat-0.1.0/outcat/models.py

@@ -0,0 +1,245 @@
+"""응답 모델 — dataclass만 사용 (의존성 최소화, §11)."""
+
+from dataclasses import dataclass, field
+from datetime import UTC, date, datetime
+from typing import Any, Literal
+
+QuestionType = Literal["binary", "multi", "numeric"]
+
+
+def _dt(value: str) -> datetime:
+    return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(UTC)
+
+
+@dataclass(frozen=True)
+class Competition:
+    slug: str
+    name: str
+    description: str
+    prize: str | None
+    visibility: str
+    starts_at: datetime
+    ends_at: datetime
+    status: str
+    question_count: int = 0
+    entry_count: int = 0
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "Competition":
+        return cls(
+            slug=data["slug"],
+            name=data["name"],
+            description=data.get("description", ""),
+            prize=data.get("prize"),
+            visibility=data.get("visibility", "public"),
+            starts_at=_dt(data["starts_at"]),
+            ends_at=_dt(data["ends_at"]),
+            status=data["status"],
+            question_count=data.get("question_count", 0),
+            entry_count=data.get("entry_count", 0),
+        )
+
+
+@dataclass(frozen=True)
+class Question:
+    id: int
+    title: str
+    description: str
+    type: QuestionType
+    options: list[str] | None
+    domain: str
+    open_at: datetime
+    lock_at: datetime
+    resolve_by: datetime
+    resolution_source: str
+    resolution_criteria: str
+    baseline: dict[str, Any] | None
+    status: str
+    outcome: dict[str, Any] | None
+    competitions: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "Question":
+        return cls(
+            id=data["id"],
+            title=data["title"],
+            description=data["description"],
+            type=data["type"],
+            options=data.get("options"),
+            domain=data["domain"],
+            open_at=_dt(data["open_at"]),
+            lock_at=_dt(data["lock_at"]),
+            resolve_by=_dt(data["resolve_by"]),
+            resolution_source=data["resolution_source"],
+            resolution_criteria=data["resolution_criteria"],
+            baseline=data.get("baseline"),
+            status=data["status"],
+            outcome=data.get("outcome"),
+            competitions=list(data.get("competitions") or []),
+        )
+
+
+@dataclass(frozen=True)
+class SubmitReceipt:
+    accepted_at: datetime
+    effective: bool
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "SubmitReceipt":
+        return cls(accepted_at=_dt(data["accepted_at"]), effective=data["effective"])
+
+
+@dataclass(frozen=True)
+class Distribution:
+    type: QuestionType
+    count: int
+    mean_p: float | None = None
+    histogram: list[int] | None = None
+    mean_probs: list[float] | None = None
+    median_q10: float | None = None
+    median_q50: float | None = None
+    median_q90: float | None = None
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "Distribution":
+        return cls(
+            type=data["type"],
+            count=data["count"],
+            mean_p=data.get("mean_p"),
+            histogram=data.get("histogram"),
+            mean_probs=data.get("mean_probs"),
+            median_q10=data.get("median_q10"),
+            median_q50=data.get("median_q50"),
+            median_q90=data.get("median_q90"),
+        )
+
+
+@dataclass(frozen=True)
+class LeaderboardEntry:
+    user_id: str
+    display_name: str
+    total_relative_score: float
+    questions_answered: int
+    eligible: bool | None = None  # 활성 리더보드에만 (동결 스냅샷엔 없음)
+    rank: int | None = None  # closed 대회의 동결 스냅샷에만
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "LeaderboardEntry":
+        return cls(
+            user_id=data["user_id"],
+            display_name=data["display_name"],
+            total_relative_score=data["total_relative_score"],
+            questions_answered=data["questions_answered"],
+            eligible=data.get("eligible"),
+            rank=data.get("rank"),
+        )
+
+
+@dataclass(frozen=True)
+class Leaderboard:
+    """통산(전역) 또는 대회별 리더보드. closed 대회는 frozen 동결 스냅샷 (§5.2)."""
+
+    scope: str  # 'global' | competition slug
+    entries: list[LeaderboardEntry] = field(default_factory=list)
+    total_questions: int | None = None
+    min_participation: float | None = None
+    frozen: bool = False
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "Leaderboard":
+        scope = data.get("scope") or data.get("competition") or "global"
+        return cls(
+            scope=scope,
+            entries=[LeaderboardEntry.from_json(e) for e in data["entries"]],
+            total_questions=data.get("total_questions"),
+            min_participation=data.get("min_participation"),
+            frozen=data.get("frozen", False),
+        )
+
+
+@dataclass(frozen=True)
+class Submission:
+    id: int
+    question_id: int
+    forecast: dict[str, Any]
+    submitted_at: datetime
+    team_name: str | None = None
+    competition_slug: str | None = None
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "Submission":
+        return cls(
+            id=data["id"],
+            question_id=data["question_id"],
+            forecast=data["forecast"],
+            submitted_at=_dt(data["submitted_at"]),
+            team_name=data.get("team_name"),
+            competition_slug=data.get("competition_slug"),
+        )
+
+
+@dataclass(frozen=True)
+class DailyScore:
+    question_id: int
+    snapshot_date: date
+    raw_score: float
+    relative_score: float
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "DailyScore":
+        return cls(
+            question_id=data["question_id"],
+            snapshot_date=date.fromisoformat(data["snapshot_date"]),
+            raw_score=data["raw_score"],
+            relative_score=data["relative_score"],
+        )
+
+
+@dataclass(frozen=True)
+class MySubmissions:
+    submissions: list[Submission]
+    daily_scores: list[DailyScore]
+    team_submissions: list[Submission] = field(default_factory=list)
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "MySubmissions":
+        return cls(
+            submissions=[Submission.from_json(s) for s in data["submissions"]],
+            daily_scores=[DailyScore.from_json(s) for s in data["daily_scores"]],
+            team_submissions=[Submission.from_json(s) for s in data.get("team_submissions", [])],
+        )
+
+
+@dataclass(frozen=True)
+class TeamMember:
+    display_name: str
+    role: str
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "TeamMember":
+        return cls(display_name=data["display_name"], role=data["role"])
+
+
+@dataclass(frozen=True)
+class Team:
+    """팀 대시보드 뷰 — 팀 키(tk_)로 조회 (§6 GET /teams/{id})."""
+
+    id: int
+    name: str
+    competition: dict[str, Any]
+    members: list[TeamMember]
+    questions: list[Question]
+    latest_forecasts: list[dict[str, Any]]
+    daily_scores: list[DailyScore]
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "Team":
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            competition=data["competition"],
+            members=[TeamMember.from_json(m) for m in data.get("members", [])],
+            questions=[Question.from_json(q) for q in data.get("questions", [])],
+            latest_forecasts=list(data.get("latest_forecasts", [])),
+            daily_scores=[DailyScore.from_json(s) for s in data.get("daily_scores", [])],
+        )

outcat-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "outcat"
+version = "0.1.0"
+description = "Official Python client for the Outcat forecasting tournament"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Outcat" }]
+keywords = ["forecasting", "prediction", "tournament", "calibration", "ai-agents"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.27"]
+
+[project.urls]
+Homepage = "https://outcat.ai"
+Documentation = "https://outcat.ai/docs"
+Repository = "https://github.com/medicalissue/outcat"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.6",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["outcat"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

outcat-0.1.0/tests/test_client.py

@@ -0,0 +1,326 @@
+"""Outcat SDK 테스트 — httpx MockTransport, 서버 불필요 (§11)."""
+
+import json
+from datetime import UTC, datetime
+
+import httpx
+import pytest
+
+from outcat import Outcat, OutcatError
+
+QUESTION = {
+    "id": 42,
+    "title": "Will it rain?",
+    "description": "",
+    "type": "binary",
+    "options": None,
+    "domain": "kr",
+    "open_at": "2026-06-01T00:00:00Z",
+    "lock_at": "2026-06-30T00:00:00Z",
+    "resolve_by": "2026-07-01T00:00:00Z",
+    "resolution_source": "KMA",
+    "resolution_criteria": "Any precipitation",
+    "baseline": None,
+    "status": "open",
+    "outcome": None,
+}
+
+
+def make_client(handler) -> Outcat:
+    transport = httpx.MockTransport(handler)
+    return Outcat(api_key="ok_test", base_url="http://api.test", transport=transport)
+
+
+def json_response(body: dict, status: int = 200) -> httpx.Response:
+    return httpx.Response(status, json=body)
+
+
+class TestQuestions:
+    def test_list_with_filters(self):
+        seen = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["path"] = request.url.path
+            seen["params"] = dict(request.url.params)
+            return json_response({"questions": [QUESTION]})
+
+        questions = make_client(handler).questions(
+            status="open", domain="kr", competition="season-0"
+        )
+        assert seen["path"] == "/questions"
+        assert seen["params"] == {
+            "status": "open",
+            "domain": "kr",
+            "competition": "season-0",
+        }
+        assert questions[0].id == 42
+        assert questions[0].lock_at == datetime(2026, 6, 30, tzinfo=UTC)
+
+    def test_get_one(self):
+        client = make_client(lambda r: json_response(QUESTION))
+        question = client.question(42)
+        assert question.title == "Will it rain?"
+        assert question.status == "open"
+
+    def test_no_api_key_needed_for_reads(self):
+        def handler(request: httpx.Request) -> httpx.Response:
+            assert "X-API-Key" not in request.headers
+            return json_response({"questions": []})
+
+        client = Outcat(base_url="http://api.test", transport=httpx.MockTransport(handler))
+        assert client.questions() == []
+
+
+class TestSubmit:
+    def test_binary(self):
+        seen = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content)
+            seen["key"] = request.headers.get("X-API-Key")
+            return json_response({"accepted_at": "2026-06-13T00:00:00Z", "effective": True})
+
+        receipt = make_client(handler).submit(42, p=0.7)
+        assert seen["body"] == {"question_id": 42, "forecast": {"p": 0.7}}
+        assert seen["key"] == "ok_test"
+        assert receipt.effective is True
+        assert receipt.accepted_at.tzinfo is not None
+
+    def test_multi(self):
+        seen = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content)
+            return json_response({"accepted_at": "2026-06-13T00:00:00Z", "effective": True})
+
+        make_client(handler).submit(42, probs=[0.5, 0.3, 0.2])
+        assert seen["body"]["forecast"] == {"probs": [0.5, 0.3, 0.2]}
+
+    def test_numeric(self):
+        seen = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["body"] = json.loads(request.content)
+            return json_response({"accepted_at": "2026-06-13T00:00:00Z", "effective": True})
+
+        make_client(handler).submit(42, q10=2.1, q50=2.8, q90=3.6)
+        assert seen["body"]["forecast"] == {"q10": 2.1, "q50": 2.8, "q90": 3.6}
+
+    def test_exactly_one_forecast_kind_required(self):
+        client = make_client(lambda r: json_response({}))
+        with pytest.raises(ValueError):
+            client.submit(42)  # 아무것도 없음
+        with pytest.raises(ValueError):
+            client.submit(42, p=0.5, probs=[0.5, 0.5])  # 두 종류
+        with pytest.raises(ValueError):
+            client.submit(42, q10=1.0, q50=2.0)  # numeric 불완전
+
+    def test_submit_requires_api_key(self):
+        client = Outcat(
+            base_url="http://api.test", transport=httpx.MockTransport(lambda r: json_response({}))
+        )
+        with pytest.raises(OutcatError) as exc:
+            client.submit(42, p=0.5)
+        assert exc.value.code == "MISSING_API_KEY"
+
+
+class TestErrors:
+    def test_api_error_mapped(self):
+        def handler(request: httpx.Request) -> httpx.Response:
+            return json_response(
+                {"error": {"code": "QUESTION_LOCKED", "message": "locked"}}, status=422
+            )
+
+        with pytest.raises(OutcatError) as exc:
+            make_client(handler).submit(42, p=0.5)
+        assert exc.value.code == "QUESTION_LOCKED"
+        assert exc.value.status_code == 422
+        assert "locked" in str(exc.value)
+
+    def test_rate_limit_message(self):
+        def handler(request: httpx.Request) -> httpx.Response:
+            return json_response(
+                {"error": {"code": "RATE_LIMITED", "message": "max 60 per minute"}},
+                status=429,
+            )
+
+        with pytest.raises(OutcatError) as exc:
+            make_client(handler).submit(42, p=0.5)
+        assert exc.value.status_code == 429
+        assert "rate limit" in str(exc.value).lower()
+
+    def test_non_json_error(self):
+        def handler(request: httpx.Request) -> httpx.Response:
+            return httpx.Response(502, text="Bad Gateway")
+
+        with pytest.raises(OutcatError) as exc:
+            make_client(handler).question(42)
+        assert exc.value.status_code == 502
+
+
+class TestCompetitions:
+    def test_list(self):
+        body = {
+            "competitions": [
+                {
+                    "slug": "season-0",
+                    "name": "Season 0",
+                    "description": "",
+                    "prize": "$1,000",
+                    "visibility": "public",
+                    "starts_at": "2026-06-01T00:00:00Z",
+                    "ends_at": "2026-08-01T00:00:00Z",
+                    "status": "active",
+                    "question_count": 12,
+                    "entry_count": 30,
+                }
+            ]
+        }
+        comps = make_client(lambda r: json_response(body)).competitions()
+        assert comps[0].slug == "season-0"
+        assert comps[0].prize == "$1,000"
+        assert comps[0].question_count == 12
+
+    def test_submit_with_team_key(self):
+        # 팀 키(tk_)도 동일한 submit 경로 — 서버가 대회/풀 분기를 처리
+        seen = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["key"] = request.headers.get("X-API-Key")
+            return json_response({"accepted_at": "2026-06-13T00:00:00Z", "effective": True})
+
+        client = Outcat(
+            api_key="tk_team", base_url="http://api.test", transport=httpx.MockTransport(handler)
+        )
+        client.submit(42, p=0.6)
+        assert seen["key"] == "tk_team"
+
+
+class TestOtherEndpoints:
+    def test_global_leaderboard(self):
+        body = {
+            "scope": "global",
+            "total_questions": 10,
+            "min_participation": 0.7,
+            "entries": [
+                {
+                    "user_id": "u1",
+                    "display_name": "alice",
+                    "total_relative_score": 1.5,
+                    "questions_answered": 9,
+                    "eligible": True,
+                }
+            ],
+        }
+        board = make_client(lambda r: json_response(body)).leaderboard()
+        assert board.scope == "global"
+        assert board.entries[0].display_name == "alice"
+        assert board.entries[0].eligible is True
+
+    def test_competition_leaderboard_path(self):
+        seen = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["path"] = request.url.path
+            return json_response(
+                {"competition": "season-0", "status": "active", "frozen": False, "entries": []}
+            )
+
+        board = make_client(handler).leaderboard(competition="season-0")
+        assert seen["path"] == "/competitions/season-0/leaderboard"
+        assert board.scope == "season-0"
+
+    def test_distribution(self):
+        body = {"type": "binary", "count": 2, "mean_p": 0.6, "histogram": [0] * 10}
+        dist = make_client(lambda r: json_response(body)).distribution(42)
+        assert dist.count == 2
+        assert dist.mean_p == 0.6
+
+    def test_my_submissions(self):
+        body = {
+            "submissions": [
+                {
+                    "id": 1,
+                    "question_id": 42,
+                    "forecast": {"p": 0.7},
+                    "submitted_at": "2026-06-13T00:00:00Z",
+                }
+            ],
+            "daily_scores": [
+                {
+                    "question_id": 42,
+                    "snapshot_date": "2026-06-13",
+                    "raw_score": -0.35,
+                    "relative_score": 0.1,
+                }
+            ],
+        }
+        me = make_client(lambda r: json_response(body)).my_submissions()
+        assert me.submissions[0].forecast == {"p": 0.7}
+        assert me.daily_scores[0].relative_score == 0.1
+
+
+class TestTeams:
+    def test_question_carries_competitions(self):
+        q = {**QUESTION, "competitions": ["season-0"]}
+        question = make_client(lambda r: json_response(q)).question(42)
+        assert question.competitions == ["season-0"]
+
+    def test_question_competitions_default_empty(self):
+        question = make_client(lambda r: json_response(QUESTION)).question(42)
+        assert question.competitions == []
+
+    def test_team_dashboard(self):
+        body = {
+            "id": 5,
+            "name": "cats",
+            "competition": {"slug": "season-0", "name": "Season 0", "status": "active"},
+            "members": [{"display_name": "alice", "role": "leader"}],
+            "questions": [QUESTION],
+            "latest_forecasts": [],
+            "daily_scores": [],
+        }
+        seen = {}
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            seen["path"] = request.url.path
+            seen["key"] = request.headers.get("X-API-Key")
+            return json_response(body)
+
+        client = Outcat(
+            api_key="tk_team", base_url="http://api.test", transport=httpx.MockTransport(handler)
+        )
+        team = client.team(5)
+        assert seen["path"] == "/teams/5"
+        assert seen["key"] == "tk_team"
+        assert team.name == "cats"
+        assert team.members[0].role == "leader"
+        assert team.questions[0].id == 42
+
+    def test_my_team_found(self):
+        body = {"team": {"id": 5, "name": "cats"}}
+        team = make_client(lambda r: json_response(body)).my_team(competition="season-0")
+        assert team == {"id": 5, "name": "cats"}
+
+    def test_my_team_none(self):
+        team = make_client(lambda r: json_response({"team": None})).my_team(competition="season-0")
+        assert team is None
+
+    def test_my_submissions_includes_team(self):
+        body = {
+            "submissions": [],
+            "daily_scores": [],
+            "team_submissions": [
+                {
+                    "id": 9,
+                    "question_id": 42,
+                    "forecast": {"p": 0.7},
+                    "submitted_at": "2026-06-13T00:00:00Z",
+                    "team_name": "cats",
+                    "competition_slug": "season-0",
+                }
+            ],
+        }
+        me = make_client(lambda r: json_response(body)).my_submissions()
+        assert me.team_submissions[0].team_name == "cats"
+        assert me.team_submissions[0].competition_slug == "season-0"

outcat-0.1.0/uv.lock

@@ -0,0 +1,189 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.5.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/ce/ee2ecad540810a79593028e88299baeae54d346cc7a0d94b6199988b89b1/certifi-2026.5.20.tar.gz", hash = "sha256:69dea482ab64caa7b9f6aba1c6bf48bb6a5448d1c0f1b17ab42ad8c763a5344d", size = 135422, upload-time = "2026-05-20T11:46:50.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/8c/57e832b7af6d7c5abe66eb3fbe3a3a32f4d11ea23a1aa7131371035be991/certifi-2026.5.20-py3-none-any.whl", hash = "sha256:3c52e209ba0a4ad7aebe60436a4ab349c39e1e602e8c134221e546902ad25897", size = 134134, upload-time = "2026-05-20T11:46:48.578Z" },
+]
+
+[[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 = "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 = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "outcat"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "httpx" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "httpx", specifier = ">=0.27" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=8.0" },
+    { name = "ruff", specifier = ">=0.6" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.17"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/a9/3abdf488f1bf3d24c699415e454ed554a6350d5d89ce183be1ee0a3361ac/ruff-0.15.17.tar.gz", hash = "sha256:2ec446937fd16c8c4de2674a209cc5af64d9c6f17d21fbf1151054fa0bcf5219", size = 4743346, upload-time = "2026-06-11T17:54:47.663Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/4d/e11259f5da07cb6afb2d074c31bf09da9671993f7329d4f15d2fdc458301/ruff-0.15.17-py3-none-linux_armv6l.whl", hash = "sha256:d9feddb927fc68bd295f5eebc587a7e42cfaf9b65f60ca4a2386febff575da8f", size = 10856677, upload-time = "2026-06-11T17:54:49.533Z" },
+    { url = "https://files.pythonhosted.org/packages/29/3e/772d679e1a0dc058e58875bd2c0cb713a0530877b4a76fee3c7966df0d49/ruff-0.15.17-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:25805a226d741c47d274a35ad5c10a7dde175fcddfa511d7cf3da0a21eb3eab7", size = 11223443, upload-time = "2026-06-11T17:55:00.573Z" },
+    { url = "https://files.pythonhosted.org/packages/68/58/bd41f7688b2fd5623012605130ed70e60aa7f2244baa3d5066bdd61530c8/ruff-0.15.17-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f6ad73b14c2d18a3bf8ad7cb6974294d7f613a7898604826058e6ac64918ef4d", size = 10566458, upload-time = "2026-06-11T17:55:07.52Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/5b/733371013fcf1ec339e477ece6ab42bfe10bdd9bba8ee88a9516aa56bfc0/ruff-0.15.17-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ba0c1e4f95bcb3869d0d30cbd5917071ef2e28665abfec970cdab0492c713ed", size = 10914483, upload-time = "2026-06-11T17:55:05.501Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/cc/6f24251cc0252f7239391ccb85833f320efad14ebe5b443943f37ced6332/ruff-0.15.17-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:81647960f10bff57d2e51cadd0c3950fe598400c852863a038720ef5b8cca91e", size = 10647497, upload-time = "2026-06-11T17:54:57.733Z" },
+    { url = "https://files.pythonhosted.org/packages/68/dd/0d10c17ce1a1624d6fc3156309c3f834fdb5dfaad026ec90c85684f3990e/ruff-0.15.17-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e01a84ddbc8c16c23055ba3924476850f1bbc1917cebbb9376665a63e74260d", size = 11416967, upload-time = "2026-06-11T17:54:51.461Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/91/556bfb156f6144f355e831c23db00b2fc4120f86b3ce81cc5f7fd2df51f3/ruff-0.15.17-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:84fe9f653152f8f294f9f7e03bf3a453d8b4a27f7a59c78c8666167f2b17b96c", size = 12335770, upload-time = "2026-06-11T17:54:45.793Z" },
+    { url = "https://files.pythonhosted.org/packages/88/82/8b5999aa13355e926f06d9f42a32dcca862f623bf0363785ff89d607dffd/ruff-0.15.17-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c0fe88a7676e7a05b73174d4d4a59cb2ac21ff8263583f87a81a6018475a978", size = 11575441, upload-time = "2026-06-11T17:54:32.661Z" },
+    { url = "https://files.pythonhosted.org/packages/11/93/f10377bb04109ca0e8cbc483ff1982c54b6d418210041776f93e8cdc7fa9/ruff-0.15.17-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecfc3c7878fff94633ab0348524e093f9ce3243080416dd7d14f8ba400174719", size = 11557614, upload-time = "2026-06-11T17:54:34.698Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/a6/eeeae7f7d5493df41649ab3db92f086b2d0a30199e4efdf8e3dd7a033f24/ruff-0.15.17-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:b8461180b22420b1bdc289909410930761629fddf2a5aaf60fae1ab26cedc4c4", size = 11544450, upload-time = "2026-06-11T17:54:39.042Z" },
+    { url = "https://files.pythonhosted.org/packages/32/88/5991ce565129a24dd4a00db1254b3b5db2e53018cbe4018ea5a89738e727/ruff-0.15.17-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:6eccbe50a038b503e7140b441aa9c7fc8c1f36edf23ebef9f4165c2f28f568b7", size = 10892524, upload-time = "2026-06-11T17:55:09.432Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/1d/0fdd248313425f55223968af04b0a42125466a8d88d21c1d99c6af0a51e8/ruff-0.15.17-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:382fc0521025f5a8ad447d8bdd523545d0d7646adb718eb1c2dac5065ec27c0f", size = 10659573, upload-time = "2026-06-11T17:54:36.824Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/0e/072e8260deb9461062ce9311ced27a8e541229a6ffd483013dd37661e43e/ruff-0.15.17-py3-none-musllinux_1_2_i686.whl", hash = "sha256:456d41fcd1b2777ad63f09a6e7121d43f7b688bbc76a800c10f7f8fb1f912c3f", size = 11127818, upload-time = "2026-06-11T17:55:03.124Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/b4/55060a34163121498014696b5f656db5b8c6963768f227dbf0d76b311073/ruff-0.15.17-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b1a04bcc94ae6194e9db05d16ad31f298a7194bfbcb08258bbe589cee1d587b8", size = 11655901, upload-time = "2026-06-11T17:54:53.562Z" },
+    { url = "https://files.pythonhosted.org/packages/49/71/9b29d6b87cef468d697f43c6a91e3fae4a80185779d7d5a4ef27d173439f/ruff-0.15.17-py3-none-win32.whl", hash = "sha256:596065960ab1ff593f744220c9fe6580eda00a95003cffa9f4048bb5b1bf0392", size = 10925574, upload-time = "2026-06-11T17:54:55.723Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b2/8fc77f3723228836fa5d12497eb71c808f83782e10d058d2b15cfa14640b/ruff-0.15.17-py3-none-win_amd64.whl", hash = "sha256:6769e5fa1710b179b92e0bfa5a51735b35baea9013dadb06d5f44cbcf9547084", size = 12058788, upload-time = "2026-06-11T17:54:41.042Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c7/c53e8dbff9c9dc4b7928773421ae294a5d28fcb8dcda1a089579d3a7e510/ruff-0.15.17-py3-none-win_arm64.whl", hash = "sha256:f3be1fbb34bcdfd146240d8fb92a709d4c2c8191348580a3c044ec60fa0b4456", size = 11355275, upload-time = "2026-06-11T17:54:43.635Z" },
+]
+
+[[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" },
+]