icpc-api 0.3.0__tar.gz → 0.4.0__tar.gz

{icpc_api-0.3.0/icpc_api.egg-info → icpc_api-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icpc-api
-Version: 0.3.0
+Version: 0.4.0
 Summary: Unofficial Python client and CLI for the icpc.global API
 Author-email: Nikita Sychev <root@nsychev.ru>
 License-Expression: MIT

{icpc_api-0.3.0 → icpc_api-0.4.0}/icpc/__init__.py

@@ -14,7 +14,7 @@ from icpc.errors import ApiError, AuthError, IcpcError, SearchError
 from icpc.facade.client import AsyncIcpc, Icpc, Include
 from icpc.facade.domain import ContestView, Member, Team
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 __all__ = [
     "ApiError",

{icpc_api-0.3.0 → icpc_api-0.4.0}/icpc/cli/main.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import copy
 import os
-import re
 import sys
 from collections.abc import Sequence
 from dataclasses import dataclass
@@ -17,6 +16,7 @@ from pathlib import Path
 from typing import Annotated, Any
 
 import typer
+from pydantic import BaseModel, TypeAdapter, ValidationError
 
 from icpc import errors
 from icpc.api import common as common_api
@@ -46,6 +46,7 @@ from icpc.cli.render import OutputFormat, fail, note, render, warn
 from icpc.config import Settings
 from icpc.facade.client import Icpc, Include
 from icpc.models.countries import country
+from icpc.models.entities import SiteSettings
 from icpc.models.enums import ExportType, InstitutionUnitType, MemberRole, TeamStatus
 from icpc.search import _generated as endpoints
 from icpc.search.dsl import Filter, SortKey
@@ -739,9 +740,59 @@ def contest_set_site(
         contest_api.site_settings(site_id),
         lambda o: contest_api.update_site_settings(contest_id, o),
         changes,
+        SiteSettings,
     )
 
 
+_NEW_SITE_SETTINGS: dict[str, Any] = {
+    "details": "",
+    "allowRegistration": False,
+    "invitationOnly": False,
+    "homepage": "",
+    "additionalInfo": "",
+    "enforceCapacity": False,
+    "allowTeamChanges": False,
+}
+_NEW_SITE_REQUIRED = ("locationName", "capacity", "siteDelivery", "siteType")
+
+
+@contest_app.command("add-site")
+def contest_add_site(
+    ctx: typer.Context,
+    contest_id: int,
+    fields: Annotated[list[str], typer.Argument(help="KEY=VALUE; see below.")],
+) -> None:
+    """Add a site to a contest.
+
+        icpc contest add-site 1235 "name=World Finals" email=manager@icpc.global \
+            locationName=Dubai capacity=150 siteDelivery=ONSITE siteType=NORMAL \
+            allowRegistration=true enforceCapacity=true
+
+    Required: name, email, locationName, capacity, siteDelivery, siteType.
+    Optional: allowRegistration, invitationOnly, enforceCapacity, allowTeamChanges,
+    details, homepage, additionalInfo.
+    """
+    values = _assignments(fields)
+    body: dict[str, Any] = {"name": values.pop("name", None), "email": values.pop("email", None)}
+    missing = [k for k in ("name", "email") if not body[k]]
+    missing += [k for k in _NEW_SITE_REQUIRED if values.get(k) in (None, "")]
+    if missing:
+        raise typer.BadParameter(f"missing {', '.join(missing)}")
+    known = (*_NEW_SITE_REQUIRED, *_NEW_SITE_SETTINGS)
+    unknown = sorted(set(values) - set(known))
+    if unknown:
+        raise typer.BadParameter(
+            f"unknown {', '.join(unknown)}; known: name, email, {', '.join(known)}"
+        )
+    try:
+        settings = SiteSettings.model_validate({**_NEW_SITE_SETTINGS, **values})
+    except ValidationError as e:
+        raise typer.BadParameter(_validation_message(e)) from None
+    body["siteSettings"] = settings.model_dump(by_alias=True, exclude_unset=True)
+    with _client(ctx) as icpc:
+        render(icpc.send(contest_api.create_site(contest_id, body)), _ctx(ctx).output)
+
+
 @contest_app.command("summary")
 def contest_summary(ctx: typer.Context, contest_id: int) -> None:
     """Team counts by site and by status, from one joined fetch."""
@@ -869,58 +920,82 @@ def contest_load(
 
 
 def _assignments(pairs: list[str]) -> dict[str, Any]:
-    """Parse ``key=value`` arguments, coercing the obvious literals.
+    """Parse ``key=value`` arguments; ``null`` becomes None, the rest stay strings.
 
-    ``true``/``false``/``null`` and bare numbers become JSON values; everything
-    else stays a string. Wrap a value in quotes to force a string.
+    The caller types them by its model, so ``zip=010000`` keeps its zero while
+    ``capacity=50`` turns into a number.
     """
     out: dict[str, Any] = {}
     for pair in pairs:
         key, sep, raw = pair.partition("=")
         if not sep:
             raise typer.BadParameter(f"expected KEY=VALUE, got {pair!r}")
-        low = raw.lower()
-        if low in ("true", "false"):
-            out[key] = low == "true"
-        elif low in ("null", "none"):
-            out[key] = None
-        elif raw.lstrip("-").isdigit():
-            out[key] = int(raw)
-        elif re.fullmatch(r"-?\d+\.\d+", raw):
-            out[key] = float(raw)
-        else:
-            out[key] = raw.strip('"')
+        out[key] = None if raw.lower() in ("null", "none") else raw
     return out
 
 
-def _edit(ctx: typer.Context, label: str, read: Any, write: Any, pairs: list[str]) -> None:
+def _validation_message(e: ValidationError) -> str:
+    return "; ".join(f"{'.'.join(map(str, err['loc']))}: {err['msg']}" for err in e.errors())
+
+
+def _edit(
+    ctx: typer.Context,
+    label: str,
+    read: Any,
+    write: Any,
+    pairs: list[str],
+    model: type[BaseModel] | None = None,
+) -> None:
     """Read a settings object, apply ``key=value`` changes, write it back.
 
     These endpoints are full-object replaces, so the read is not optional: send
     only the changed keys and everything else is wiped. ``a.b=value`` sets a key
     of a nested object.
+
+    Values are typed by ``model``, by default the model ``read`` returns. A field
+    the model doesn't declare takes the type of its current value, or stays a
+    string if that is null.
     """
     changes = _assignments(pairs)
     with _client(ctx) as icpc:
         current = icpc.send(read)
-        obj = current if isinstance(current, dict) else current.model_dump(by_alias=True)
-        obj = copy.deepcopy(obj)
-        for path, value in changes.items():
-            *parents, key = path.split(".")
-            target = obj
-            for part in parents:
-                target = target.get(part) if isinstance(target, dict) else None
-            if not isinstance(target, dict) or key not in target:
-                known = sorted(target) if isinstance(target, dict) else []
-                fail(f"{label} has no field {path!r}; known here: {', '.join(known)}")
-                raise typer.Exit(1)
-            note(f"{path}: {target[key]!r} -> {value!r}")
-            target[key] = value
+        if isinstance(current, BaseModel):
+            model = model or type(current)
+            current = current.model_dump(by_alias=True)
+        obj = copy.deepcopy(current)
+        try:
+            for path, value in changes.items():
+                *parents, key = path.split(".")
+                target = obj
+                for part in parents:
+                    target = target.get(part) if isinstance(target, dict) else None
+                if not isinstance(target, dict) or key not in target:
+                    known = sorted(target) if isinstance(target, dict) else []
+                    fail(f"{label} has no field {path!r}; known here: {', '.join(known)}")
+                    raise typer.Exit(1)
+                old = target[key]
+                if value is not None and isinstance(old, bool | int | float):
+                    target[key] = TypeAdapter(type(old)).validate_python(value)
+                else:
+                    target[key] = value
+            if model is not None:
+                obj = model.model_validate(obj).model_dump(by_alias=True, exclude_unset=True)
+        except ValidationError as e:
+            fail(f"bad value for {label}: {_validation_message(e)}")
+            raise typer.Exit(1) from None
+        for path in changes:
+            note(f"{path}: {_at(current, path)!r} -> {_at(obj, path)!r}")
         icpc.send(write(obj))
         after = icpc.send(read)
     render(after, _ctx(ctx).output)
 
 
+def _at(obj: Any, path: str) -> Any:
+    for part in path.split("."):
+        obj = obj[part]
+    return obj
+
+
 def _grid(name: str, entity_id: int) -> SearchEndpoint[Any, Any]:
     factory = GRIDS.get(name)
     if factory is None:

{icpc_api-0.3.0 → icpc_api-0.4.0}/icpc/models/entities.py

@@ -48,6 +48,7 @@ __all__ = [
     "RegistrationInfo",
     "RegistrationStatus",
     "SiteRow",
+    "SiteSettings",
     "SiteTreeNode",
     "StandingRow",
     "SuggestedInstitution",
@@ -403,6 +404,24 @@ class SiteRow(Row):
     enforce_capacity: bool | None = None
 
 
+class SiteSettings(Row):
+    """``siteSettings`` of ``GET /contest/site/{id}``, as ``contest.site_settings`` reads it."""
+
+    id: int | None = None
+    version: int | None = None
+    location_name: str | None = None
+    capacity: int | None = None
+    site_delivery: str | None = None
+    site_type: str | None = None
+    details: str | None = None
+    homepage: str | None = None
+    additional_info: str | None = None
+    allow_registration: bool | None = None
+    invitation_only: bool | None = None
+    enforce_capacity: bool | None = None
+    allow_team_changes: bool | None = None
+
+
 class SiteTreeNode(Row):
     """``GET /contest/site/tree/...`` — the contest tree, recursively."""
 

{icpc_api-0.3.0 → icpc_api-0.4.0/icpc_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icpc-api
-Version: 0.3.0
+Version: 0.4.0
 Summary: Unofficial Python client and CLI for the icpc.global API
 Author-email: Nikita Sychev <root@nsychev.ru>
 License-Expression: MIT

{icpc_api-0.3.0 → icpc_api-0.4.0}/tests/unit/test_institutions.py

@@ -1,4 +1,4 @@
-"""Institutions: the unit's odd wire key, the grid's export path, and the CLI edit."""
+"""Institutions: the unit's odd wire key, the grid's export path, and the CLI edits."""
 
 from __future__ import annotations
 
@@ -75,8 +75,9 @@ def test_the_grid_exports_from_a_sibling_path():
 
 
 class _Fake:
-    def __init__(self) -> None:
+    def __init__(self, reply: Any = None) -> None:
         self.sent: list[Any] = []
+        self.reply = reply
 
     def __enter__(self) -> _Fake:
         return self
@@ -88,7 +89,7 @@ class _Fake:
         if op.request.method == "POST":
             self.sent.append(op.request.json)
             return None
-        return InstitutionUnit.model_validate(UNIT)
+        return self.reply if self.reply is not None else InstitutionUnit.model_validate(UNIT)
 
 
 def test_set_unit_edits_nested_keys_and_sends_the_whole_object(monkeypatch):
@@ -113,6 +114,43 @@ def test_set_unit_edits_nested_keys_and_sends_the_whole_object(monkeypatch):
     assert common.update_institution_unit({}).request.path == "/common/institutionunit"
 
 
+def test_set_unit_types_values_by_the_model_not_by_their_look(monkeypatch):
+    """`zip` is a string, so its leading zero survives; `latitude` is a float."""
+    fake = _Fake()
+    monkeypatch.setattr(main, "_client", lambda _ctx: fake)
+    result = CliRunner().invoke(
+        main.app, ["institution", "set-unit", "5695", "mailingAddress.zip=010000"]
+    )
+    assert result.exit_code == 0, result.output
+    assert fake.sent[0]["mailingAddress"]["zip"] == "010000"
+
+    result = CliRunner().invoke(main.app, ["institution", "set-unit", "5695", "latitude=north"])
+    assert result.exit_code == 1
+    assert len(fake.sent) == 1
+
+
+def test_set_site_types_a_plain_dict_by_site_settings(monkeypatch):
+    """The read is a dict: typed by SiteSettings, an unmodeled key by its current value."""
+    current = {"id": 1, "capacity": 10, "allowRegistration": False, "futureFlag": False}
+    fake = _Fake(reply=current)
+    monkeypatch.setattr(main, "_client", lambda _ctx: fake)
+    result = CliRunner().invoke(
+        main.app,
+        [
+            "contest",
+            "set-site",
+            "1235",
+            "--site",
+            "1",
+            "capacity=50",
+            "allowRegistration=true",
+            "futureFlag=true",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    assert fake.sent == [{"id": 1, "capacity": 50, "allowRegistration": True, "futureFlag": True}]
+
+
 def test_set_unit_refuses_an_unknown_nested_key(monkeypatch):
     fake = _Fake()
     monkeypatch.setattr(main, "_client", lambda _ctx: fake)