show_scoreboard.py

#!/usr/bin/env python3
"""Show one team's score on every graded ICFP Contest 2026 problem."""

from __future__ import annotations

import argparse
import json
import math
import re
import sys
from typing import Any
from urllib.error import HTTPError, URLError
from urllib.parse import quote
from urllib.request import Request, urlopen


DEFAULT_BASE_URL = "https://icfpcontest2026.com"
DEFAULT_TEAM = "TSG"
USER_AGENT = (
    "Mozilla/5.0 (compatible; show_scoreboard.py/1.0; "
    "+https://icfpcontest2026.com/problem-sets)"
)


class ScoreboardError(RuntimeError):
    """An expected error fetching or interpreting scoreboard data."""


def fetch_json(base_url: str, path: str, timeout: float) -> Any:
    request = Request(
        f"{base_url.rstrip('/')}{path}",
        headers={"Accept": "application/json", "User-Agent": USER_AGENT},
    )
    try:
        with urlopen(request, timeout=timeout) as response:
            return json.load(response)
    except HTTPError as error:
        detail = ""
        try:
            payload = json.loads(error.read())
            detail = payload.get("error", {}).get("message", "")
        except (json.JSONDecodeError, AttributeError, UnicodeDecodeError):
            pass
        suffix = f": {detail}" if detail else ""
        raise ScoreboardError(f"HTTP {error.code} for {path}{suffix}") from error
    except URLError as error:
        raise ScoreboardError(f"request failed for {path}: {error.reason}") from error
    except (json.JSONDecodeError, UnicodeDecodeError) as error:
        raise ScoreboardError(f"invalid JSON returned for {path}") from error


def find_team(standings: dict[str, Any], wanted: str) -> dict[str, Any]:
    teams = standings.get("teams")
    if not isinstance(teams, list):
        raise ScoreboardError("unexpected response from /api/v1/standings")

    by_id = [team for team in teams if team.get("teamId") == wanted]
    if by_id:
        return by_id[0]

    exact = [team for team in teams if team.get("teamName") == wanted]
    if len(exact) == 1:
        return exact[0]
    if len(exact) > 1:
        raise ScoreboardError(
            f"multiple teams are named {wanted!r}; pass a teamId with --team"
        )

    folded = [
        team
        for team in teams
        if str(team.get("teamName", "")).casefold() == wanted.casefold()
    ]
    if len(folded) == 1:
        return folded[0]
    if len(folded) > 1:
        raise ScoreboardError(
            f"multiple teams match {wanted!r}; pass a teamId with --team"
        )
    raise ScoreboardError(f"team {wanted!r} was not found in the standings")


def natural_key(value: str) -> tuple[tuple[int, Any], ...]:
    parts = re.split(r"(\d+)", value.casefold())
    return tuple(
        (0, int(part)) if part.isdigit() else (1, part)
        for part in parts
        if part
    )


def format_score(value: Any) -> str:
    if not isinstance(value, (int, float)) or not math.isfinite(value):
        return "—"
    if float(value).is_integer():
        return f"{int(value):,}"
    return f"{value:,.3f}".rstrip("0").rstrip(".")


def format_points(value: Any) -> str:
    if not isinstance(value, (int, float)) or not math.isfinite(value):
        return "—"
    return f"{value:.3f}"


def format_table(headers: list[str], rows: list[list[str]]) -> str:
    widths = [
        max(len(headers[index]), *(len(row[index]) for row in rows))
        for index in range(len(headers))
    ]
    numeric_columns = {2, 3, 4, 5}

    def render(row: list[str]) -> str:
        cells = []
        for index, cell in enumerate(row):
            cells.append(
                cell.rjust(widths[index])
                if index in numeric_columns
                else cell.ljust(widths[index])
            )
        return " | ".join(cells)

    separator = "-+-".join("-" * width for width in widths)
    return "\n".join([render(headers), separator, *(render(row) for row in rows)])


def collect_scores(
    base_url: str, team_name_or_id: str, timeout: float
) -> dict[str, Any]:
    standings = fetch_json(base_url, "/api/v1/standings", timeout)
    if not isinstance(standings, dict):
        raise ScoreboardError("unexpected response from /api/v1/standings")
    team = find_team(standings, team_name_or_id)
    team_id = team.get("teamId")
    if not isinstance(team_id, str):
        raise ScoreboardError("the selected team has no teamId")

    problems = fetch_json(base_url, "/api/v1/public/problems", timeout)
    team_data = fetch_json(
        base_url,
        f"/api/v1/standings/teams/{quote(team_id, safe='')}",
        timeout,
    )
    if not isinstance(problems, list) or not isinstance(team_data, dict):
        raise ScoreboardError("unexpected response from the public API")

    standing_by_problem = {
        row["problemId"]: row
        for row in team_data.get("rows", [])
        if isinstance(row, dict) and isinstance(row.get("problemId"), str)
    }
    graded = [
        problem
        for problem in problems
        if isinstance(problem, dict)
        and problem.get("status") == "graded"
        and problem.get("problemSetVisible")
    ]
    graded.sort(
        key=lambda problem: (
            natural_key(str(problem.get("problemSetName") or "Unassigned")),
            problem.get("orderInSet")
            if isinstance(problem.get("orderInSet"), (int, float))
            else math.inf,
            natural_key(str(problem.get("name") or problem.get("slug") or "")),
        )
    )

    rows = []
    for problem in graded:
        standing = standing_by_problem.get(problem.get("id"))
        rows.append(
            {
                "problemSet": problem.get("problemSetName") or "Unassigned",
                "problem": problem.get("name") or problem.get("slug") or problem["id"],
                "slug": problem.get("slug"),
                "problemId": problem.get("id"),
                "rank": standing.get("rank") if standing else None,
                "fieldSize": standing.get("fieldSize") if standing else None,
                "casesPassed": standing.get("casesPassed") if standing else None,
                "casesTotal": standing.get("casesTotal") if standing else None,
                "score": standing.get("score") if standing else None,
                "points": standing.get("points") if standing else None,
            }
        )

    return {
        "updatedAt": team_data.get("updatedAt") or standings.get("updatedAt"),
        "frozen": bool(team_data.get("frozen", standings.get("frozen", False))),
        "teamId": team_id,
        "teamName": team_data.get("teamName") or team.get("teamName") or team_id,
        "overallRank": team_data.get("rank", team.get("rank")),
        "overallPoints": team_data.get("points", team.get("points")),
        "fullPasses": team.get("fullPasses"),
        "problemCount": team_data.get(
            "problemCount", standings.get("problemCount", len(graded))
        ),
        "problems": rows,
    }


def sorted_problems(
    problems: list[dict[str, Any]], sort_order: str
) -> list[dict[str, Any]]:
    if sort_order == "points":
        return sorted(
            problems,
            key=lambda item: (
                item["points"] is None,
                -(item["points"] or 0),
                natural_key(str(item["problem"])),
            ),
        )
    return problems


def print_text(data: dict[str, Any], sort_order: str) -> None:
    headers = ["Set", "Problem", "Rank", "Passed", "Score", "Points"]
    rows = []
    for item in sorted_problems(data["problems"], sort_order):
        rank = (
            f"{item['rank']}/{item['fieldSize']}"
            if item["rank"] is not None and item["fieldSize"] is not None
            else "—"
        )
        passed = (
            f"{item['casesPassed']}/{item['casesTotal']}"
            if item["casesPassed"] is not None and item["casesTotal"] is not None
            else "—"
        )
        rows.append(
            [
                str(item["problemSet"]),
                str(item["problem"]),
                rank,
                passed,
                format_score(item["score"]),
                format_points(item["points"]),
            ]
        )

    solved = data.get("fullPasses")
    count = data.get("problemCount")
    solved_text = f", solved {solved}/{count}" if solved is not None else ""
    frozen_text = " [FROZEN]" if data["frozen"] else ""
    print(
        f"{data['teamName']}: overall rank {data['overallRank']}, "
        f"{format_points(data['overallPoints'])} points{solved_text}{frozen_text}"
    )
    print(f"Updated: {data['updatedAt'] or 'unknown'}")
    print()
    print(format_table(headers, rows))


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description=(
            "Display a team's score on every visible graded ICFP Contest 2026 "
            "problem."
        )
    )
    parser.add_argument(
        "--team",
        default=DEFAULT_TEAM,
        metavar="NAME_OR_ID",
        help=f"team name or teamId (default: {DEFAULT_TEAM})",
    )
    parser.add_argument(
        "--base-url",
        default=DEFAULT_BASE_URL,
        help=f"contest site base URL (default: {DEFAULT_BASE_URL})",
    )
    parser.add_argument(
        "--timeout",
        type=float,
        default=20.0,
        metavar="SECONDS",
        help="timeout for each HTTP request (default: 20)",
    )
    parser.add_argument(
        "--json",
        action="store_true",
        help="emit machine-readable JSON with unrounded scores",
    )
    parser.add_argument(
        "--sort",
        choices=("set", "points"),
        default="points",
        help="row order: Points descending or problem-set order (default: points)",
    )
    parser.add_argument(
        "--no-sort",
        dest="sort",
        action="store_const",
        const="set",
        help="disable Points sorting and use problem-set order",
    )
    args = parser.parse_args()
    if args.timeout <= 0:
        parser.error("--timeout must be greater than zero")
    return args


def main() -> int:
    args = parse_args()
    try:
        data = collect_scores(args.base_url, args.team, args.timeout)
    except ScoreboardError as error:
        print(f"error: {error}", file=sys.stderr)
        return 1

    if args.json:
        data["problems"] = sorted_problems(data["problems"], args.sort)
        json.dump(data, sys.stdout, ensure_ascii=False, indent=2)
        print()
    else:
        print_text(data, args.sort)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())