cmpnd 0.53.0__tar.gz → 0.54.0__tar.gz

{cmpnd-0.53.0 → cmpnd-0.54.0}/AGENTS.md

@@ -145,6 +145,8 @@ Before you touch either `pyproject.toml`:
 
 - `ingest/cmpnd_ingest/exporter_http.py`: the ingest transport (`cmpnd.exporter_http`)
 - `ingest/cmpnd_ingest/retry.py`: the client half of the retryable-error contract (`cmpnd.retry`)
+- `ingest/cmpnd_ingest/client_floor.py`: warns once when serve's `X-Cmpnd-Minimum-Client-Version` header names a floor above the installed release
+- `ingest/cmpnd_ingest/program_names.py`: keeps the program ids serve gave for the program names a process declared
 - `cmpnd/identity.py`: hash computations (xxhash, SHA256). See the `cmpnd-hash-handling` skill.
 - `cmpnd/ir/`: the structural program-identity IR (algebra, encoder, hash, reflector)
 - `cmpnd/callback.py`: DSPy instrumentation and signature extraction
@@ -195,8 +197,8 @@ its `add_parser` call in `top.register()`, and add the entity method or the
 When you touch a handler:
 
 - **Write user-facing hints with the `_hint_*` helpers** in
-  `cli/commands/top.py` (`_hint_ps`, `_hint_run`, `_hint_status`,
-  `_hint_inspect`, `_hint_traces_list`). They check `_SHELL_MODE` and emit
+  `cli/commands/top.py` (`_hint_ps`, `_hint_run`, `_hint_program_name`,
+  `_hint_status`, `_hint_inspect`, `_hint_traces_list`). They check `_SHELL_MODE` and emit
   `deps.d_xxx.run({...})` in the shell or `cmpnd run d_xxx '{...}'` outside
   it. Never hardcode a `cmpnd <verb>` string in handler output.
 - **Add a shell entity** by subclassing `Entity` in `cli/shell.py`. Add a

{cmpnd-0.53.0 → cmpnd-0.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.53.0
+Version: 0.54.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>

{cmpnd-0.53.0 → cmpnd-0.54.0}/cmpnd/cli/commands/admin.py

@@ -8,7 +8,11 @@ adjust its member cap or GitHub link, and grant ownership from the election
 queue. `cmpnd admin user …` is the operator's user-lifecycle surface (list,
 inspect, create, approve/reject the pending-signup queue, promote/demote admin,
 disable/enable, reset a password, and manage a user's API-key scopes). `cmpnd
-admin feature-flags …` reads and toggles the server's runtime flags. These hit
+admin org plan …` and `cmpnd admin org overrides …` move an org between plans
+and override one of its limits, `cmpnd admin plans …` edits each plan's
+default limits and feature flags, and `cmpnd admin signup …` sets who may sign up
+and the plan a new account's org lands on. `cmpnd admin feature-flags …` reads and
+toggles the server's runtime flags. These hit
 /api/v1/admin/* and require an API key carrying the admin:* scopes — the server
 is the real authority. The CMPND_CLI_ADMIN env gate (mirroring CMPND_CLI_DEV)
 only keeps these out of customers' --help; it grants nothing.
@@ -16,7 +20,7 @@ only keeps these out of customers' --help; it grants nothing.
 
 from __future__ import annotations
 
-from argparse import ArgumentParser, _SubParsersAction
+from argparse import ArgumentParser, ArgumentTypeError, _SubParsersAction
 from typing import Any
 
 from .. import api_client, deprecation
@@ -28,9 +32,29 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
     _register_org(sub)
     _register_user(sub)
+    _register_plans(sub)
+    _register_signup(sub)
     _register_feature_flags(sub)
 
 
+# The signup modes, as serve names them. argparse refuses a typo before the request,
+# and the server still validates it. Plan names are serve's alone: the CLI sends the
+# name as typed, and serve's refusal lists the plans it has, so a new plan needs no
+# CLI release.
+SIGNUP_MODES = ("closed", "invite", "open")
+PLAN_HELP = "The plan, as `cmpnd admin plans list` names it"
+
+
+def _limit_value(raw: str) -> int | None:
+    """A limit is a whole number, or ``none`` for no limit, which sends null."""
+    if raw.lower() == "none":
+        return None
+    try:
+        return int(raw)
+    except ValueError:
+        raise ArgumentTypeError(f"{raw!r} is not a whole number or 'none'") from None
+
+
 def _register_org(sub: _SubParsersAction[ArgumentParser]) -> None:
     org = sub.add_parser("org", help="Organization bootstrap")
     osub = org.add_subparsers(dest="org_action")
@@ -71,6 +95,7 @@ def _register_org(sub: _SubParsersAction[ArgumentParser]) -> None:
     set_owner.set_defaults(func=handle_org_set_owner)
 
     ls = osub.add_parser("list", help="List organizations")
+    ls.add_argument("--plan", help="Only the organizations on this plan")
     ls.set_defaults(func=handle_org_list)
 
     def _org_id_arg(p: ArgumentParser) -> None:
@@ -97,6 +122,32 @@ def _register_org(sub: _SubParsersAction[ArgumentParser]) -> None:
     elect_owner.add_argument("user_id", help="User id to make owner")
     elect_owner.set_defaults(func=handle_org_elect_owner)
 
+    plan = osub.add_parser("plan", help="An org's plan and its limits")
+    plsub = plan.add_subparsers(dest="org_plan_action")
+    plan_show = plsub.add_parser("show", help="Show the org's plan and every limit as it resolves for the org")
+    _org_id_arg(plan_show)
+    plan_show.set_defaults(func=handle_org_plan_show)
+    plan_update = plsub.add_parser("update", help="Move the org to a plan")
+    _org_id_arg(plan_update)
+    plan_update.add_argument("plan", help=PLAN_HELP)
+    plan_update.set_defaults(func=handle_org_plan_update)
+
+    overrides = osub.add_parser("overrides", help="An org's overrides of its plan's limits")
+    ovsub = overrides.add_subparsers(dest="org_overrides_action")
+    override_update = ovsub.add_parser(
+        "update", help="Override one of the org's limits; 'none' lifts the plan's limit for the org"
+    )
+    _org_id_arg(override_update)
+    override_update.add_argument("name", help="Limit name, such as optimizations.concurrent")
+    override_update.add_argument("value", type=_limit_value, help="A whole number, or 'none' for no limit")
+    override_update.set_defaults(func=handle_org_overrides_update)
+    override_delete = ovsub.add_parser(
+        "delete", help="Delete the org's override so it follows its plan for the limit again"
+    )
+    _org_id_arg(override_delete)
+    override_delete.add_argument("name", help="Limit name")
+    override_delete.set_defaults(func=handle_org_overrides_delete)
+
 
 def _register_user(sub: _SubParsersAction[ArgumentParser]) -> None:
     user = sub.add_parser("user", help="User lifecycle management")
@@ -173,6 +224,57 @@ def _register_user(sub: _SubParsersAction[ArgumentParser]) -> None:
     set_scopes.set_defaults(func=handle_user_set_scopes)
 
 
+def _register_plans(sub: _SubParsersAction[ArgumentParser]) -> None:
+    plans = sub.add_parser("plans", help="Each plan's default limits and feature flags")
+    psub = plans.add_subparsers(dest="plans_action")
+
+    ls = psub.add_parser("list", help="List every plan's limits and feature flags")
+    ls.set_defaults(func=handle_plans_list)
+
+    limits = psub.add_parser("limits", help="A plan's default limits")
+    lsub = limits.add_subparsers(dest="plans_limits_action")
+    limit_update = lsub.add_parser("update", help="Set a plan's default for a limit; 'none' means no limit")
+    limit_update.add_argument("plan", help=PLAN_HELP)
+    limit_update.add_argument("name", help="Limit name, such as optimizations.concurrent")
+    limit_update.add_argument("value", type=_limit_value, help="A whole number, or 'none' for no limit")
+    limit_update.set_defaults(func=handle_plans_limits_update)
+    limit_delete = lsub.add_parser("delete", help="Delete a plan's default for a limit")
+    limit_delete.add_argument("plan", help=PLAN_HELP)
+    limit_delete.add_argument("name", help="Limit name")
+    limit_delete.set_defaults(func=handle_plans_limits_delete)
+
+    flags = psub.add_parser("flags", help="A plan's feature flags")
+    fsub = flags.add_subparsers(dest="plans_flags_action")
+    flag_update = fsub.add_parser(
+        "update", help="Pin a feature flag on (or, with --disabled, off) for every org on a plan"
+    )
+    flag_update.add_argument("plan", help=PLAN_HELP)
+    flag_update.add_argument("name", help="Flag name; the flag must already exist")
+    flag_update.add_argument("--disabled", action="store_true", help="Pin the flag off (default is on)")
+    flag_update.set_defaults(func=handle_plans_flags_update)
+    flag_delete = fsub.add_parser("delete", help="Delete a plan's row for a flag so its orgs follow the global default")
+    flag_delete.add_argument("plan", help=PLAN_HELP)
+    flag_delete.add_argument("name", help="Flag name")
+    flag_delete.set_defaults(func=handle_plans_flags_delete)
+
+
+def _register_signup(sub: _SubParsersAction[ArgumentParser]) -> None:
+    signup = sub.add_parser("signup", help="Who may sign up, and the plan a new account's org lands on")
+    ssub = signup.add_subparsers(dest="signup_action")
+
+    show = ssub.add_parser("show", help="Show the signup mode in force and the plan for new orgs")
+    show.set_defaults(func=handle_signup_show)
+
+    set_signup = ssub.add_parser("update", help="Change the signup mode, the plan for new orgs, or both")
+    set_signup.add_argument(
+        "--mode",
+        choices=(*SIGNUP_MODES, "installation"),
+        help="closed, invite or open; 'installation' follows CMPND_SERVE_SIGNUP_MODE again",
+    )
+    set_signup.add_argument("--default-plan", dest="default_plan", help="The plan for new orgs")
+    set_signup.set_defaults(func=handle_signup_update)
+
+
 def _register_feature_flags(sub: _SubParsersAction[ArgumentParser]) -> None:
     ff = sub.add_parser("feature-flags", help="Runtime feature flags")
     ffsub = ff.add_subparsers(dest="ff_action")
@@ -218,7 +320,10 @@ def handle_org_set_owner(client: api_client.ApiClient, args: Any) -> Any:
     return {"org_id": args.org_id, "owner": args.email}
 
 
-def handle_org_list(client: api_client.ApiClient, _args: Any) -> Any:
+def handle_org_list(client: api_client.ApiClient, args: Any) -> Any:
+    plan = getattr(args, "plan", None)
+    if plan:
+        return client.get("/api/v1/admin/organizations", params={"plan": plan})
     return client.get("/api/v1/admin/organizations")
 
 
@@ -245,6 +350,70 @@ def handle_org_elect_owner(client: api_client.ApiClient, args: Any) -> Any:
     return {"elected": args.user_id, "github_login": args.github_login}
 
 
+def handle_org_plan_show(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get(f"/api/v1/admin/organizations/{args.org_id}/plan")
+
+
+def handle_org_plan_update(client: api_client.ApiClient, args: Any) -> Any:
+    return client.put(f"/api/v1/admin/organizations/{args.org_id}/plan", json={"plan": args.plan})
+
+
+def handle_org_overrides_update(client: api_client.ApiClient, args: Any) -> Any:
+    return client.put(
+        f"/api/v1/admin/organizations/{args.org_id}/limits/{args.name}",
+        json={"value": args.value},
+    )
+
+
+def handle_org_overrides_delete(client: api_client.ApiClient, args: Any) -> Any:
+    return client.delete(f"/api/v1/admin/organizations/{args.org_id}/limits/{args.name}")
+
+
+# --- plan handlers --------------------------------------------------------
+
+
+def handle_plans_list(client: api_client.ApiClient, _args: Any) -> Any:
+    return client.get("/api/v1/admin/plans")
+
+
+def handle_plans_limits_update(client: api_client.ApiClient, args: Any) -> Any:
+    return client.put(f"/api/v1/admin/plans/{args.plan}/limits/{args.name}", json={"value": args.value})
+
+
+def handle_plans_limits_delete(client: api_client.ApiClient, args: Any) -> Any:
+    return client.delete(f"/api/v1/admin/plans/{args.plan}/limits/{args.name}")
+
+
+def handle_plans_flags_update(client: api_client.ApiClient, args: Any) -> Any:
+    return client.put(
+        f"/api/v1/admin/plans/{args.plan}/feature-flags/{args.name}",
+        json={"enabled": not args.disabled},
+    )
+
+
+def handle_plans_flags_delete(client: api_client.ApiClient, args: Any) -> Any:
+    return client.delete(f"/api/v1/admin/plans/{args.plan}/feature-flags/{args.name}")
+
+
+# --- signup handlers ------------------------------------------------------
+
+
+def handle_signup_show(client: api_client.ApiClient, _args: Any) -> Any:
+    return client.get("/api/v1/admin/signup")
+
+
+def handle_signup_update(client: api_client.ApiClient, args: Any) -> Any:
+    # Send only what was given, so changing one setting leaves the other alone.
+    body: dict[str, Any] = {}
+    if args.mode is not None:
+        body["mode"] = None if args.mode == "installation" else args.mode
+    if args.default_plan is not None:
+        body["default_plan"] = args.default_plan
+    if not body:
+        raise SystemExit("cmpnd admin signup update: give --mode, --default-plan, or both")
+    return client.patch("/api/v1/admin/signup", json=body)
+
+
 # --- user handlers --------------------------------------------------------
 
 

{cmpnd-0.53.0 → cmpnd-0.54.0}/cmpnd/cli/commands/optimizations.py

@@ -9,7 +9,11 @@ from .. import api_client, deprecation, pagination
 
 
 def _add_list_args(p: ArgumentParser) -> None:
-    p.add_argument("--status", help="Filter by status (running, completed, failed, cancelled)")
+    p.add_argument(
+        "--status",
+        help="Filter by status (queued, running, completed, failed, cancelled). "
+        "queued lists every run waiting for a slot, in the order they will start, without paging",
+    )
     p.add_argument("--program", dest="program_name", help="Filter by program name")
     p.add_argument("--optimizer-type", help="Filter by optimizer type")
     p.add_argument("--min-score", type=float, help="Minimum best score")
@@ -77,6 +81,13 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     show.add_argument("id", help="Optimization run ID (UUID)")
     show.set_defaults(func=handle_show)
 
+    cancel = sub.add_parser(
+        "cancel",
+        help="Cancel an open optimization run. A hosted run stops searching within seconds",
+    )
+    cancel.add_argument("id", help="Optimization run ID (op_...)")
+    cancel.set_defaults(func=handle_cancel)
+
     delete = sub.add_parser("delete", help="Delete an optimization run and everything recorded under it")
     delete.add_argument("id", help="Optimization run ID (op_...)")
     delete.set_defaults(func=handle_delete)
@@ -160,6 +171,8 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
 
 def handle_list(client: api_client.ApiClient, args: Any) -> Any:
+    if getattr(args, "status", None) == "queued":
+        return _list_queued(client, args)
     # This route paginates by page/per_page; the shared helper maps the
     # user-facing --limit/--offset onto that pair.
     body: dict[str, Any] = pagination.wire(args, "per_page")
@@ -175,10 +188,31 @@ def handle_list(client: api_client.ApiClient, args: Any) -> Any:
     return client.post("/api/v1/optimizations/search", json=body)
 
 
+def _list_queued(client: api_client.ApiClient, args: Any) -> Any:
+    # A queued run waits for a slot and has no run record until it starts, so the run
+    # search cannot find it. Its own route lists the org's waiting runs in line order.
+    # The list is short and unfiltered, so the search filters do not apply.
+    search_only = [("program_name", "--program"), ("optimizer_type", "--optimizer-type"), ("min_score", "--min-score")]
+    for attr, flag in search_only:
+        if getattr(args, attr, None) is not None:
+            raise api_client.CliError(f"{flag} does not apply to --status queued, which lists every waiting run")
+    return client.get("/api/v1/optimizations/queued")
+
+
 def handle_show(client: api_client.ApiClient, args: Any) -> Any:
     return client.get(f"/api/v1/optimizations/{args.id}")
 
 
+def handle_cancel(client: api_client.ApiClient, args: Any) -> Any:
+    """Cancel an open run and return its id and status.
+
+    The run's record stays, marked cancelled. Serve stops a hosted run's search
+    on its next watcher tick, which also frees the run's place among its org's
+    running optimizations. A run that already ended answers 409 with its status.
+    """
+    return client.post(f"/api/v1/optimizations/{args.id}/cancel")
+
+
 def handle_delete(client: api_client.ApiClient, args: Any) -> Any:
     # 204 No Content → delete() returns None; synthesize a confirmation.
     client.delete(f"/api/v1/optimizations/{args.id}")

{cmpnd-0.53.0 → cmpnd-0.54.0}/cmpnd/optimization.py

@@ -1467,6 +1467,11 @@ def _upload_bundle(
         raise OptimizeError(f"failed to {what}: HTTP {resp.status_code}: {body}")
 
 
+# The `queued_reason` serve gives a run it holds because the run's org already runs as
+# many hosted optimizations as its plan allows.
+_QUEUED_FOR_ORG_LIMIT = "org_concurrency_limit"
+
+
 def _poll_until_terminal(
     client: httpx.Client,
     endpoint: str,
@@ -1495,6 +1500,9 @@ def _poll_until_terminal(
     # The last status the worker reported, so a timeout discovered at the wire can
     # say what the run was doing when the clock ran out.
     last_status: object = None
+    # Whether the caller has been told the run waits on its org's cap. Once is enough,
+    # because the poll repeats the same answer until a place frees.
+    warned_org_limit = False
 
     def _tolerate(resp: httpx.Response) -> bool:
         nonlocal first_missing
@@ -1556,6 +1564,16 @@ def _poll_until_terminal(
             return status_data
         if status == "failed":
             raise OptimizeFailed(status_data.get("error"), optimization_id=optimization_id)
+        if status == "queued" and status_data.get("queued_reason") == _QUEUED_FOR_ORG_LIMIT and not warned_org_limit:
+            warned_org_limit = True
+            logger.warning(
+                "optimization %s is waiting: your org's plan allows %s hosted optimization(s) at once "
+                "and %s are running. It starts when one finishes. To free a place now, run "
+                "`cmpnd optimizations list --status running` and `cmpnd optimizations cancel <id>`.",
+                optimization_id,
+                status_data.get("concurrency_limit"),
+                status_data.get("running_optimizations"),
+            )
         if time.monotonic() - start > timeout:
             raise _ran_out_of_time(status)
         # Clipped like a backoff, for the same reason: this wait is inside the

{cmpnd-0.53.0 → cmpnd-0.54.0}/docs/cli.md

@@ -526,6 +526,30 @@ takes named models through its `lms` argument. An authored file's `lms`
 binding cannot be combined with `lms` in the parent call or `config["lms"]`.
 The CLI has no named-model flag.
 
+### Cancel a run
+
+`cmpnd optimizations cancel RUN_ID` stops an open run and keeps its record,
+marked `cancelled`. A hosted run stops searching within a few seconds, and its
+place among the org's running optimizations frees at the same moment. The web
+app's Cancel run button does the same thing. A run that already ended answers
+with its status and changes nothing. A poll of a cancelled run reports
+`status: failed` with `settlement: cancelled`, so a released SDK's wait loop
+ends.
+
+An org's plan may cap how many hosted optimizations run at once. A run started
+over the cap waits in serve's queue and starts when one of the org's runs
+finishes. Its poll answers `status: queued` with `queued_reason:
+org_concurrency_limit`, and the SDK logs one warning that names the cap and
+the commands that list and cancel running runs. A plan may also limit how many
+runs wait. A run that would wait past it is refused with a 409 that names the
+limit and the queued runs' ids.
+
+`cmpnd optimizations list --status queued` lists the org's queued runs in the
+order they will start, and `cmpnd optimizations cancel <id>` cancels one. A
+queued run has no run record until it starts, so the other statuses never show
+it. The web app shows the same list on its queued optimizations page, which the
+optimizations page links to while runs wait.
+
 ## Platform administration
 
 Platform-operator commands (`cmpnd admin …`) appear only when
@@ -556,6 +580,33 @@ EMAIL` withdraws the open owner invites sent to that address, and the links
 stop working. `cmpnd admin org show` lists pending addresses under
 `seed.pending_owner_emails`.
 
+### Plans, limits and signups
+
+Every org has a plan, `free`, `pro` or `enterprise`, and each plan sets
+default limits and feature flags. An org's own override beats its plan.
+`cmpnd admin org list` shows each org's plan, and `--plan free` keeps only the
+orgs on Free. `cmpnd admin org plan show ORG_ID` shows the org's plan and every
+limit, with the layer that set it. `cmpnd admin org plan update ORG_ID PLAN` moves the
+org. `cmpnd admin org overrides update ORG_ID NAME VALUE` overrides one limit,
+and a value of `none` lifts the plan's limit for that org.
+`cmpnd admin org overrides delete ORG_ID NAME` deletes the override, so the org
+follows its plan again.
+
+`cmpnd admin plans list` shows every plan's limits and feature flags.
+`cmpnd admin plans limits update PLAN NAME VALUE` and `limits delete PLAN NAME`
+change a plan's default for every org on it. `cmpnd admin plans flags update
+PLAN NAME [--disabled]` pins a flag for the plan, and `flags delete` hands the
+plan back to the global default. A plan's flag must already exist, so create
+it first with `cmpnd admin feature-flags set`.
+
+`cmpnd admin signup show` reports who may sign up and the plan a new account's
+org lands on. `cmpnd admin signup update --mode closed|invite|open` overrides
+the installation's `CMPND_SERVE_SIGNUP_MODE`, and `--mode installation` follows
+it again. `--default-plan PLAN` sets the plan for new orgs. Changing the mode
+needs a key with `admin:users:provision`, and changing the plan one with
+`admin:orgs:write`. The operator pages at `/ui/admin/plans`,
+`/ui/admin/feature_flags` and `/ui/admin/signup` write the same settings.
+
 ### Preparing an org for a customer
 
 This procedure keeps every write under the operator's own identity. The

{cmpnd-0.53.0 → cmpnd-0.54.0}/docs/sdk-instrumentation.md

@@ -786,7 +786,7 @@ The id rides every body that can declare a program, beside `program_signature_ha
 | Body | Where | Built by |
 |---|---|---|
 | trace start, single and batch | top-level `program_id`, and `started_fact.program_id` | `TraceBuilder.to_start_dict()` / `to_api_dict()` |
-| deployment create | top-level `program_id`, always | `deployment.deploy()` / `deploy_bundle()` |
+| deployment create | top-level `program_id`, when the deployment resolves one | `deployment.deploy()` / `deploy_bundle()` |
 | optimize step | top-level `program_id`, on the steps that optimize the caller's deployment | `optimization._initiate_step()` |
 | optimization-run upsert | top-level `program_id` | `OptimizationTracker.to_api_dict()` |
 

{cmpnd-0.53.0 → cmpnd-0.54.0}/pyproject.toml

@@ -5,7 +5,7 @@ name = "cmpnd"
 # it's new) — no git tags. Bump with `uv version --bump {minor,patch}` or by
 # hand. Runtime `cmpnd.__version__` reads installed metadata, so it tracks
 # this automatically. See docs/plans/2026-07-02-sdk-pypi-tag-free-publish.md.
-version = "0.53.0"
+version = "0.54.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.53.0 → cmpnd-0.54.0}/tests/test_cli/test_admin.py

@@ -85,6 +85,19 @@ class TestAdminOrg:
         mock_client.get.assert_called_once_with("/api/v1/admin/organizations")
         assert result == {"organizations": []}
 
+    def test_list_filters_by_plan(self, mock_client):
+        mock_client.get.return_value = {"organizations": [{"id": "o_1", "plan": "free"}]}
+        args = _parse("org", "list", "--plan", "free")
+        result = args.func(mock_client, args)
+        mock_client.get.assert_called_once_with("/api/v1/admin/organizations", params={"plan": "free"})
+        assert result["organizations"][0]["plan"] == "free"
+
+    def test_list_sends_any_plan_name_for_serve_to_check(self, mock_client):
+        mock_client.get.return_value = {"organizations": []}
+        args = _parse("org", "list", "--plan", "platinum")
+        args.func(mock_client, args)
+        mock_client.get.assert_called_once_with("/api/v1/admin/organizations", params={"plan": "platinum"})
+
     def test_get_calls_endpoint(self, mock_client):
         mock_client.get.return_value = {"id": "o_1", "name": "Acme"}
         result = admin.handle_org_show(mock_client, Namespace(org_id="o_1"))
@@ -260,3 +273,125 @@ class TestAdminFeatureFlags:
         result = admin.handle_feature_flags_set(mock_client, Namespace(name="beta", disabled=True))
         mock_client.put.assert_called_once_with("/api/v1/admin/feature-flags/beta", json={"enabled": False})
         assert result["enabled"] is False
+
+
+def _parse(*argv: str) -> Namespace:
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser()
+    admin.register(parser.add_subparsers())
+    return parser.parse_args(["admin", *argv])
+
+
+class TestAdminOrgPlan:
+    def test_plan_shows_the_orgs_plan(self, mock_client):
+        mock_client.get.return_value = {"org_id": "o_1", "plan": "free", "limits": []}
+        args = _parse("org", "plan", "show", "o_1")
+        result = args.func(mock_client, args)
+        mock_client.get.assert_called_once_with("/api/v1/admin/organizations/o_1/plan")
+        assert result["plan"] == "free"
+
+    def test_set_plan_puts_the_plan(self, mock_client):
+        args = _parse("org", "plan", "update", "o_1", "pro")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_once_with("/api/v1/admin/organizations/o_1/plan", json={"plan": "pro"})
+
+    def test_override_limit_sends_a_number(self, mock_client):
+        args = _parse("org", "overrides", "update", "o_1", "optimizations.concurrent", "3")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_once_with(
+            "/api/v1/admin/organizations/o_1/limits/optimizations.concurrent", json={"value": 3}
+        )
+
+    def test_override_limit_none_lifts_the_limit(self, mock_client):
+        # "none" sends null, which lifts the plan's limit for this org. That is a
+        # different state from clearing the override.
+        args = _parse("org", "overrides", "update", "o_1", "optimizations.concurrent", "none")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_once_with(
+            "/api/v1/admin/organizations/o_1/limits/optimizations.concurrent", json={"value": None}
+        )
+
+    def test_override_limit_rejects_a_word_that_is_not_none(self):
+        import pytest
+
+        with pytest.raises(SystemExit):
+            _parse("org", "overrides", "update", "o_1", "optimizations.concurrent", "lots")
+
+    def test_clear_limit_override_deletes_it(self, mock_client):
+        args = _parse("org", "overrides", "delete", "o_1", "optimizations.concurrent")
+        args.func(mock_client, args)
+        mock_client.delete.assert_called_once_with("/api/v1/admin/organizations/o_1/limits/optimizations.concurrent")
+
+
+class TestAdminPlans:
+    def test_list(self, mock_client):
+        mock_client.get.return_value = {"plans": []}
+        args = _parse("plans", "list")
+        assert args.func(mock_client, args) == {"plans": []}
+        mock_client.get.assert_called_once_with("/api/v1/admin/plans")
+
+    def test_set_limit_and_none(self, mock_client):
+        args = _parse("plans", "limits", "update", "pro", "optimizations.concurrent", "5")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_with("/api/v1/admin/plans/pro/limits/optimizations.concurrent", json={"value": 5})
+        args = _parse("plans", "limits", "update", "free", "optimizations.concurrent", "none")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_with(
+            "/api/v1/admin/plans/free/limits/optimizations.concurrent", json={"value": None}
+        )
+
+    def test_clear_limit(self, mock_client):
+        args = _parse("plans", "limits", "delete", "pro", "optimizations.concurrent")
+        args.func(mock_client, args)
+        mock_client.delete.assert_called_once_with("/api/v1/admin/plans/pro/limits/optimizations.concurrent")
+
+    def test_set_flag_enables_by_default_and_disables_with_the_flag(self, mock_client):
+        args = _parse("plans", "flags", "update", "free", "beta")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_with("/api/v1/admin/plans/free/feature-flags/beta", json={"enabled": True})
+        args = _parse("plans", "flags", "update", "free", "beta", "--disabled")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_with("/api/v1/admin/plans/free/feature-flags/beta", json={"enabled": False})
+
+    def test_clear_flag(self, mock_client):
+        args = _parse("plans", "flags", "delete", "free", "beta")
+        args.func(mock_client, args)
+        mock_client.delete.assert_called_once_with("/api/v1/admin/plans/free/feature-flags/beta")
+
+    def test_plan_names_are_serves_to_check(self, mock_client):
+        args = _parse("plans", "limits", "update", "platinum", "optimizations.concurrent", "5")
+        args.func(mock_client, args)
+        mock_client.put.assert_called_once_with(
+            "/api/v1/admin/plans/platinum/limits/optimizations.concurrent", json={"value": 5}
+        )
+
+
+class TestAdminSignup:
+    def test_show(self, mock_client):
+        mock_client.get.return_value = {"mode": "invite", "mode_source": "installation"}
+        args = _parse("signup", "show")
+        assert args.func(mock_client, args)["mode"] == "invite"
+        mock_client.get.assert_called_once_with("/api/v1/admin/signup")
+
+    def test_set_sends_only_what_was_given(self, mock_client):
+        args = _parse("signup", "update", "--mode", "closed")
+        args.func(mock_client, args)
+        mock_client.patch.assert_called_with("/api/v1/admin/signup", json={"mode": "closed"})
+        args = _parse("signup", "update", "--default-plan", "free")
+        args.func(mock_client, args)
+        mock_client.patch.assert_called_with("/api/v1/admin/signup", json={"default_plan": "free"})
+
+    def test_installation_mode_sends_null(self, mock_client):
+        # null hands signups back to the installation's CMPND_SERVE_SIGNUP_MODE.
+        args = _parse("signup", "update", "--mode", "installation", "--default-plan", "pro")
+        args.func(mock_client, args)
+        mock_client.patch.assert_called_once_with("/api/v1/admin/signup", json={"mode": None, "default_plan": "pro"})
+
+    def test_set_with_nothing_to_change_exits(self, mock_client):
+        import pytest
+
+        args = _parse("signup", "update")
+        with pytest.raises(SystemExit):
+            args.func(mock_client, args)
+        mock_client.patch.assert_not_called()

{cmpnd-0.53.0 → cmpnd-0.54.0}/tests/test_cli/test_optimizations.py

@@ -9,6 +9,7 @@ import pytest
 from cmpnd.cli.api_client import CliError
 from cmpnd.cli.commands import optimizations
 from cmpnd.cli.commands.optimizations import (
+    handle_cancel,
     handle_candidates,
     handle_compare,
     handle_compare_failed_examples,
@@ -58,6 +59,26 @@ class TestOptimizationsList:
         assert body["status"] == "completed"
         assert body["min_score"] == 0.8
 
+    def test_queued_lists_the_waiting_runs(self, mock_client):
+        # A queued run has no run record yet, so the run search cannot find it. The
+        # queued status reads the org's waiting runs from their own route.
+        mock_client.get.return_value = {"optimizations": [{"optimization_id": "op_1", "position": 1}]}
+        args = argparse.Namespace(
+            status="queued", program_name=None, optimizer_type=None, min_score=None, limit=50, offset=0
+        )
+        result = handle_list(mock_client, args)
+        mock_client.get.assert_called_once_with("/api/v1/optimizations/queued")
+        mock_client.post.assert_not_called()
+        assert result["optimizations"][0]["optimization_id"] == "op_1"
+
+    def test_queued_refuses_filters_it_cannot_apply(self, mock_client):
+        args = argparse.Namespace(
+            status="queued", program_name="RAG", optimizer_type=None, min_score=None, limit=50, offset=0
+        )
+        with pytest.raises(CliError, match="--status queued"):
+            handle_list(mock_client, args)
+        mock_client.get.assert_not_called()
+
     def test_deprecated_search_verb_dispatches_and_is_marked(self, mock_client):
         # The warning is the dispatcher's job (see test_main.py); the wiring is this one's.
         parser = _build_parser()
@@ -152,6 +173,20 @@ class TestOptimizationsDatasetAnalysis:
         mock_client.get.assert_called_once_with("/api/v1/optimizations/op_abc/dataset-analysis")
 
 
+class TestOptimizationsCancel:
+    def test_posts_to_the_cancel_route(self, mock_client):
+        mock_client.post.return_value = {"optimization_id": "op_abc", "status": "cancelled"}
+        args = argparse.Namespace(id="op_abc")
+        result = handle_cancel(mock_client, args)
+        mock_client.post.assert_called_once_with("/api/v1/optimizations/op_abc/cancel")
+        assert result == {"optimization_id": "op_abc", "status": "cancelled"}
+
+    def test_parses_from_the_command_line(self):
+        args = _build_parser().parse_args(["optimizations", "cancel", "op_abc"])
+        assert args.func is handle_cancel
+        assert args.id == "op_abc"
+
+
 class TestOptimizationsDelete:
     def test_calls_correct_endpoint(self, mock_client):
         mock_client.delete.return_value = None