cmpnd 0.59.0__tar.gz → 0.60.0__tar.gz

{cmpnd-0.59.0 → cmpnd-0.60.0}/PKG-INFO

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

{cmpnd-0.59.0 → cmpnd-0.60.0}/cmpnd/cli/commands/programs.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import json
 import sys
 import urllib.parse
 from argparse import ArgumentParser, _SubParsersAction
@@ -12,8 +13,8 @@ from .. import api_client, pagination
 from . import provider_credentials
 
 
-# Every id in this group is the value `programs list` prints as `program_hash`,
-# which the routes resolve as a *compiled* program hash — they look it up
+# The hash that show, traces, stats, usage and select take is the value `programs optimized list`
+# prints as `program_hash`, which the routes resolve as a *compiled* program hash — they look it up
 # against optimization runs and map it to a program signature hash internally.
 # The two hashes are different values, so a real signature hash 404s here. The
 # argument help says which one it wants rather than naming the concept the
@@ -48,34 +49,74 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     create.add_argument("--json", action="store_true", help="Emit the created program as JSON instead of its id")
     create.set_defaults(func=handle_create)
 
-    ls = sub.add_parser("list", help="List programs")
-    ls.add_argument("--name", dest="program_name", help="Filter by program name")
-    ls.add_argument("--model", dest="model_name", help="Filter by model name")
+    ls = sub.add_parser(
+        "list",
+        help="List your organization's programs",
+        description=(
+            "List your organization's live programs, newest first, with each program's name and p_ id. A program "
+            "lists from its creation on, before anything runs under it. With --trashed, list the Trash instead."
+        ),
+    )
     ls.add_argument(
         "--trashed",
         action="store_true",
         help="List the programs in the Trash instead, with when each is purged",
     )
-    ls.add_argument("--order-by", default="run_count", help="Sort field (default: run_count)")
-    ls.add_argument("--order", default="desc", choices=["asc", "desc"], help="Sort direction")
     pagination.add_args(ls, with_page_aliases=True, default_limit=50)
+    # The optimized-program filters and sort moved to `programs optimized list`. They stay declared so that a
+    # command that passes one gets an error naming the command that takes it.
+    for flag, dest in [
+        ("--name", "program_name"),
+        ("--model", "model_name"),
+        ("--order-by", "order_by"),
+        ("--order", "order"),
+    ]:
+        ls.add_argument(flag, dest=dest, default=None, help=argparse.SUPPRESS)
     ls.set_defaults(func=handle_list)
 
+    # The optimized programs are the compiled programs optimization runs produced, grouped by compiled program
+    # hash. They are different records from the org's programs, so they nest, as the registry does.
+    optimized = sub.add_parser("optimized", help="Browse the optimized programs that optimization runs produced")
+    optimized_sub = optimized.add_subparsers(dest="optimized_action")
+    opt_list = optimized_sub.add_parser(
+        "list",
+        help="List optimized programs by compiled program hash",
+        description=(
+            "List the compiled programs your optimization runs produced, one row per compiled program hash, with "
+            "their run counts and scores. `programs show`, `traces`, `stats` and `usage` take the hash from the "
+            "program_hash column."
+        ),
+    )
+    opt_list.add_argument("--name", dest="program_name", help="Filter by program name")
+    opt_list.add_argument("--model", dest="model_name", help="Filter by model name")
+    opt_list.add_argument("--order-by", default="run_count", help="Sort field (default: run_count)")
+    opt_list.add_argument("--order", default="desc", choices=["asc", "desc"], help="Sort direction")
+    pagination.add_args(opt_list, with_page_aliases=True, default_limit=50)
+    opt_list.set_defaults(func=handle_optimized_list)
+
     show = sub.add_parser("show", help="Show program detail")
-    show.add_argument("id", help="Program hash, as `programs list` prints it in the program_hash column")
+    show.add_argument(
+        "id", help="Compiled program hash, as `programs optimized list` prints it in the program_hash column"
+    )
     show.set_defaults(func=handle_show)
 
     tr = sub.add_parser("traces", help="List traces for a program")
-    tr.add_argument("id", help="Program hash, as `programs list` prints it in the program_hash column")
+    tr.add_argument(
+        "id", help="Compiled program hash, as `programs optimized list` prints it in the program_hash column"
+    )
     pagination.add_args(tr, with_page_aliases=False, default_limit=50)
     tr.set_defaults(func=handle_traces)
 
     stats = sub.add_parser("stats", help="Show a program's execution statistics")
-    stats.add_argument("id", help="Program hash, as `programs list` prints it in the program_hash column")
+    stats.add_argument(
+        "id", help="Compiled program hash, as `programs optimized list` prints it in the program_hash column"
+    )
     stats.set_defaults(func=handle_stats)
 
     usage = sub.add_parser("usage", help="Show a program's trace volume, tokens and cost over time")
-    usage.add_argument("id", help="Program hash, as `programs list` prints it in the program_hash column")
+    usage.add_argument(
+        "id", help="Compiled program hash, as `programs optimized list` prints it in the program_hash column"
+    )
     usage.add_argument("--hours", type=int, default=24, help="Rolling window in hours (default %(default)s)")
     # Constrained on purpose: an unrecognised period buckets hourly server-side
     # rather than failing, so a typo would answer a different question silently.
@@ -132,7 +173,9 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     purge.set_defaults(func=handle_purge)
 
     select = sub.add_parser("select", help="Pin an optimization run as this program's chosen version")
-    select.add_argument("id", help="Program hash, as `programs list` prints it in the program_hash column")
+    select.add_argument(
+        "id", help="Compiled program hash, as `programs optimized list` prints it in the program_hash column"
+    )
     select.add_argument("--run", dest="run_id", required=True, help="Optimization run ID (op_...) to pin")
     select.set_defaults(func=handle_select)
 
@@ -178,14 +221,24 @@ def handle_create(client: api_client.ApiClient, args: Any) -> Any:
 
 
 def handle_list(client: api_client.ApiClient, args: Any) -> Any:
+    """List the org's live programs by name and p_ id, or the Trash with ``--trashed``."""
+    for attr, flag in [
+        ("program_name", "--name"),
+        ("model_name", "--model"),
+        ("order_by", "--order-by"),
+        ("order", "--order"),
+    ]:
+        if getattr(args, attr, None) is not None:
+            from . import top
+
+            raise api_client.CliError(
+                f"{flag} filters the optimized programs, which `{top.hint_programs('optimized', 'list')}` lists. "
+                f"`{top.hint_programs('list')}` lists your organization's programs by name and p_ id."
+            )
     if getattr(args, "trashed", False):
-        # The Trash is its own short list, unpaged and newest first, so the search filters, sort and paging do
-        # not apply. A flag left at its default cannot be told apart from one not passed.
+        # The Trash is its own short list, unpaged and newest first, so paging does not apply. A flag left at its
+        # default cannot be told apart from one not passed.
         for attr, flag, default in [
-            ("program_name", "--name", None),
-            ("model_name", "--model", None),
-            ("order_by", "--order-by", "run_count"),
-            ("order", "--order", "desc"),
             ("limit", "--limit", 50),
             ("offset", "--offset", 0),
             ("per_page", "--per-page", None),
@@ -194,6 +247,59 @@ def handle_list(client: api_client.ApiClient, args: Any) -> Any:
             if getattr(args, attr, default) != default:
                 raise api_client.CliError(f"{flag} does not apply to --trashed, which lists the whole Trash")
         return client.get("/api/v1/programs/trash")
+    params = pagination.wire(args, "limit_offset", as_str=True)
+    # Read as text: a server from before the program list, such as self-host release 2026-001, redirects this
+    # path to its dispatcher, and the redirect's body is HTML.
+    try:
+        raw = client.get_text("/api/v1/programs", params=params)
+    except api_client.CliError as exc:
+        if exc.status_code not in (404, 405):
+            raise
+        return _list_recorded(client, params)
+    try:
+        listed = json.loads(raw)
+    except ValueError:
+        listed = None
+    if isinstance(listed, dict) and "programs" in listed:
+        return listed
+    return _list_recorded(client, params)
+
+
+# GET /api/v1/modules on a server from before the program list answers at most this many programs
+# (modulesPageCap in self-host release 2026-001), and nothing pages past them.
+_RECORDED_PROGRAMS_CAP = 200
+
+
+def _list_recorded(client: api_client.ApiClient, params: dict[str, str]) -> dict[str, Any]:
+    """List the programs a server from before the program list recorded traces for, paged here.
+
+    GET /api/v1/modules answers them in one array, by name and legacy hash, up to its cap. A program with no
+    traces yet is not in it. A full array may be missing programs past the cap, so the answer then has no total
+    and says it is incomplete.
+    """
+    rows = client.get("/api/v1/modules")
+    if not isinstance(rows, list):
+        raise api_client.CliError(
+            "this cmpnd server answered neither the program list nor the list of recorded programs"
+        )
+    complete = len(rows) < _RECORDED_PROGRAMS_CAP
+    note = "note: this cmpnd server predates the program list, so this lists the programs it recorded traces for."
+    if not complete:
+        note += f" It answers at most {_RECORDED_PROGRAMS_CAP} of them, so programs past those are missing."
+    print(note + " Upgrade the server to list every program by name and p_ id.", file=sys.stderr)
+    limit, offset = int(params["limit"]), int(params["offset"])
+    return {
+        "programs": rows[offset : offset + limit],
+        "total": len(rows) if complete else None,
+        "complete": complete,
+        "limit": limit,
+        "offset": offset,
+        "has_more": offset + limit < len(rows),
+    }
+
+
+def handle_optimized_list(client: api_client.ApiClient, args: Any) -> Any:
+    """List the optimized programs, one row per compiled program hash."""
     params: dict[str, str] = pagination.wire(args, "per_page", as_str=True)
     params["order_by"] = args.order_by
     params["order_direction"] = args.order

{cmpnd-0.59.0 → cmpnd-0.60.0}/cmpnd/cli/verbs.py

@@ -185,6 +185,7 @@ RELATION_NOUNS: dict[str, str] = {
     "failed-examples": "the examples a compared candidate got wrong",
     "examples": "the examples belonging to a dataset or an eval run",
     "registry": "the registered programs or signatures, as distinct from the observed ones",
+    "optimized": "the compiled programs optimization runs produced, as distinct from the organization's programs",
     "stats": "a program's execution statistics",
     "usage": "a program's usage over time",
     "openapi": "the OpenAPI document a deployment serves",

{cmpnd-0.59.0 → cmpnd-0.60.0}/docs/cli.md

@@ -41,6 +41,27 @@ The CLI refuses `--program-id`, `cmpnd programs create` without a program
 name, and its `--name`. These inputs are deprecated, and the error shows the
 program name form.
 
+`cmpnd programs list` lists your organization's live programs, newest first,
+with each program's `name` and `program_id`. It reads `GET /api/v1/programs`,
+which lists a program from its creation on, before anything runs under it. A
+program with no name has a null `name`. The answer also holds `total`, the
+count of live programs, and `has_more`. The command pages with `--limit` and
+`--offset`, and needs `traces:read`.
+
+A server from before the program list, such as self-host release 2026-001, has
+no `GET /api/v1/programs`. Against one, `cmpnd programs list` says so on stderr
+and lists the programs that server recorded traces for, from
+`GET /api/v1/modules`, by name and legacy hash. A program with no traces yet is
+not in that list. That route answers at most 200 programs, so when it is full
+the answer has a null `total`, `complete` is false, and the note says programs
+are missing.
+
+`cmpnd programs optimized list` lists the compiled programs that optimization
+runs produced, one row per compiled program hash, from
+`GET /api/v1/programs/v2`. It takes `--name`, `--model`, `--order-by` and
+`--order`. `cmpnd programs list` refuses those flags with an error that names
+`cmpnd programs optimized list`.
+
 ## The Trash
 
 A program in the Trash leaves every view, and its traces with it, until it is
@@ -281,10 +302,10 @@ Some older spellings still run as deprecated aliases and print a warning:
 - `credentials add` for `create`
 
 Every list command pages with `--limit` and `--offset`. The `traces`, `evals`,
-`optimizations`, `deployments` and `programs` lists also accept `--page` and
-`--per-page` as deprecated aliases. On those page-number commands, `--offset`
-must be a multiple of `--limit`, and the error names the nearest valid
-offsets. `deployments runs list` still accepts the deprecated `--cursor`, which
+`optimizations`, `deployments`, `programs` and `programs optimized` lists also
+accept `--page` and `--per-page` as deprecated aliases. Every one of those
+except `programs list` pages by page number on the wire, so its `--offset` must
+be a multiple of `--limit`, and the error names the nearest valid offsets. `deployments runs list` still accepts the deprecated `--cursor`, which
 pages from a previous response's `next_cursor` and cannot be combined with
 `--offset`.
 
@@ -333,9 +354,10 @@ The `signatures` and `programs` groups name programs differently.
 hash, which identifies a program's inputs and outputs and everything recorded
 under them: traces, examples, evals and revisions. The CLI passes an id
 through unchanged, and serve tells the two apart by the `p_` prefix.
-`cmpnd programs` reads take a compiled program hash, the value in the
-`program_hash` column of `cmpnd programs list`, and its Trash commands take a
-program name or id ("The Trash" above). Its routes resolve the hash
+`cmpnd programs show`, `traces`, `stats`, `usage` and `select` take a compiled
+program hash, the value in the `program_hash` column of
+`cmpnd programs optimized list`. `cmpnd programs list` prints names and ids, and
+the Trash commands take a program name or id ("The Trash" above). Its routes resolve the hash
 through optimization runs, so they do not find a signature hash. Each group's
 `--help` names the column its IDs come from.
 

{cmpnd-0.59.0 → cmpnd-0.60.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.59.0"
+version = "0.60.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.59.0 → cmpnd-0.60.0}/tests/test_cli/test_main.py

@@ -103,7 +103,9 @@ class TestDevGate:
         mock_response = {"programs": [], "total": 0}
         with mock.patch("sys.argv", ["cmpnd", "programs", "list"]):
             with mock.patch.dict(os.environ, env, clear=True):
-                with mock.patch("cmpnd.cli.api_client.ApiClient.get", return_value=mock_response):
+                with mock.patch(
+                    "cmpnd.cli.api_client.ApiClient.get_text", autospec=True, return_value=json.dumps(mock_response)
+                ):
                     main()
         captured = capsys.readouterr()
         output = json.loads(captured.out)

{cmpnd-0.59.0 → cmpnd-0.60.0}/tests/test_cli/test_programs.py

@@ -3,13 +3,15 @@
 from __future__ import annotations
 
 import argparse
+import json
+from unittest import mock
 
+import httpx
 import pytest
 
-from cmpnd.cli.api_client import CliError
+from cmpnd.cli.api_client import ApiClient, CliError
 from cmpnd.cli.commands import programs
 from cmpnd.cli.commands.programs import (
-    handle_list,
     handle_registry_list,
     handle_registry_show,
     handle_select,
@@ -28,44 +30,164 @@ def _build_parser() -> argparse.ArgumentParser:
 
 
 class TestProgramsList:
+    def test_lists_the_orgs_programs_by_limit_and_offset(self, mock_client):
+        listed = {"programs": [{"program_id": "p_0123456789Ab", "name": "triage"}], "total": 1}
+        mock_client.get_text.return_value = json.dumps(listed)
+        args = _build_parser().parse_args(["programs", "list"])
+        assert args.func(mock_client, args) == listed
+        mock_client.get_text.assert_called_once_with("/api/v1/programs", params={"limit": "50", "offset": "0"})
+
+    def test_pages_by_any_offset(self, mock_client):
+        mock_client.get_text.return_value = json.dumps({"programs": []})
+        args = _build_parser().parse_args(["programs", "list", "--limit", "10", "--offset", "5"])
+        args.func(mock_client, args)
+        assert mock_client.get_text.call_args[1]["params"] == {"limit": "10", "offset": "5"}
+
+    def test_deprecated_paging_still_works_and_warns(self, mock_client, capsys):
+        args = _build_parser().parse_args(["programs", "list", "--page", "2", "--per-page", "5"])
+        mock_client.get_text.return_value = json.dumps({"programs": []})
+        args.func(mock_client, args)
+        assert mock_client.get_text.call_args[1]["params"] == {"limit": "5", "offset": "5"}
+        assert "deprecated" in capsys.readouterr().err
+
+    @pytest.mark.parametrize(
+        "flag",
+        [["--name", "RAG"], ["--model", "gpt-4o"], ["--order-by", "best_score"], ["--order", "asc"]],
+    )
+    def test_optimized_program_flags_point_at_their_command(self, mock_client, flag):
+        args = _build_parser().parse_args(["programs", "list", *flag])
+        with pytest.raises(CliError, match=f"{flag[0]} .*`cmpnd programs optimized list`"):
+            args.func(mock_client, args)
+        mock_client.get.assert_not_called()
+        mock_client.get_text.assert_not_called()
+
+
+class TestProgramsListOnAnOlderServer:
+    """A server from before the program list, such as self-host release 2026-001, has no
+    GET /api/v1/programs. Its mux redirects the path to the dispatcher, which answers 404.
+    The CLI then lists the programs that server recorded traces for, from /api/v1/modules."""
+
+    MODULES = [
+        {"program_signature_hash": "08729442d1b3a3bf", "name": "Triage"},
+        {"program_signature_hash": "0000000000abcdef", "name": "Rag"},
+        {"program_signature_hash": "00000000000c0ffe", "name": "Summarize"},
+    ]
+
+    def _over_the_wire(self, answers):
+        """A real client over a transport that answers by path: `sent` collects the requests."""
+        sent: list[httpx.Request] = []
+
+        def handle(request: httpx.Request) -> httpx.Response:
+            sent.append(request)
+            return answers[request.url.path]
+
+        real = httpx.Client
+        patch = mock.patch("httpx.Client", lambda **kwargs: real(**kwargs, transport=httpx.MockTransport(handle)))
+        return sent, patch
+
+    def _list(self, answers, *argv: str):
+        sent, patch = self._over_the_wire(answers)
+        args = _build_parser().parse_args(["programs", "list", *argv])
+        with patch:
+            result = args.func(ApiClient(api_key="k", endpoint="http://serve.test"), args)
+        return sent, result
+
+    def test_a_redirect_falls_back_to_the_recorded_programs(self, capsys):
+        redirect = httpx.Response(
+            307,
+            headers={"Location": "/api/v1/programs/?limit=2&offset=1"},
+            text='<a href="/api/v1/programs/?limit=2&amp;offset=1">Temporary Redirect</a>.',
+        )
+        sent, result = self._list(
+            {"/api/v1/programs": redirect, "/api/v1/modules": httpx.Response(200, json=self.MODULES)},
+            "--limit",
+            "2",
+            "--offset",
+            "1",
+        )
+        assert [r.url.path for r in sent] == ["/api/v1/programs", "/api/v1/modules"]
+        assert result == {
+            "programs": self.MODULES[1:3],
+            "total": 3,
+            "complete": True,
+            "limit": 2,
+            "offset": 1,
+            "has_more": False,
+        }
+        assert "predates the program list" in capsys.readouterr().err
+
+    def test_a_full_answer_has_no_total_and_says_programs_are_missing(self, capsys):
+        # Self-host release 2026-001 answers at most 200 recorded programs, and nothing pages past them.
+        recorded = [{"program_signature_hash": f"{n:016x}", "name": f"P{n}"} for n in range(200)]
+        _, result = self._list(
+            {
+                "/api/v1/programs": httpx.Response(404, json={"error": "not found"}),
+                "/api/v1/modules": httpx.Response(200, json=recorded),
+            },
+            "--limit",
+            "50",
+            "--offset",
+            "150",
+        )
+        assert result["programs"] == recorded[150:200]
+        assert result["total"] is None
+        assert result["complete"] is False
+        assert result["has_more"] is False
+        assert "at most 200" in capsys.readouterr().err
+
+    def test_a_not_found_falls_back_too(self):
+        sent, result = self._list(
+            {
+                "/api/v1/programs": httpx.Response(404, json={"error": "not found"}),
+                "/api/v1/modules": httpx.Response(200, json=self.MODULES),
+            }
+        )
+        assert [r.url.path for r in sent] == ["/api/v1/programs", "/api/v1/modules"]
+        assert result["total"] == 3
+
+    def test_a_current_server_answers_without_a_fallback(self):
+        listed = {"programs": [{"program_id": "p_0123456789Ab", "name": "triage"}], "total": 1}
+        sent, result = self._list({"/api/v1/programs": httpx.Response(200, json=listed)})
+        assert [r.url.path for r in sent] == ["/api/v1/programs"]
+        assert result == listed
+
+
+class TestProgramsOptimizedList:
     def test_default_params(self, mock_client):
         mock_client.get.return_value = {"programs": []}
-        args = argparse.Namespace(
-            program_name=None, model_name=None, order_by="run_count", order="desc", limit=50, offset=0
-        )
-        result = handle_list(mock_client, args)
+        args = _build_parser().parse_args(["programs", "optimized", "list"])
+        assert args.func(mock_client, args) == {"programs": []}
         mock_client.get.assert_called_once_with(
             "/api/v1/programs/v2",
             params={"page": "1", "per_page": "50", "order_by": "run_count", "order_direction": "desc"},
         )
-        assert result == {"programs": []}
 
     def test_with_filters(self, mock_client):
         mock_client.get.return_value = {"programs": []}
-        args = argparse.Namespace(
-            program_name="RAG", model_name="gpt-4o", order_by="run_count", order="asc", limit=10, offset=10
+        args = _build_parser().parse_args(
+            ["programs", "optimized", "list", "--name", "RAG", "--model", "gpt-4o", "--order", "asc"]
+            + ["--limit", "10", "--offset", "10"]
         )
-        handle_list(mock_client, args)
+        args.func(mock_client, args)
         params = mock_client.get.call_args[1]["params"]
         assert params["program_name"] == "RAG"
         assert params["model_name"] == "gpt-4o"
+        assert params["order_direction"] == "asc"
         assert params["page"] == "2"
 
     def test_deprecated_paging_still_works_and_warns(self, mock_client, capsys):
-        parser = _build_parser()
-        args = parser.parse_args(["programs", "list", "--page", "2", "--per-page", "5"])
+        args = _build_parser().parse_args(["programs", "optimized", "list", "--page", "2", "--per-page", "5"])
         mock_client.get.return_value = {"programs": []}
-        handle_list(mock_client, args)
+        args.func(mock_client, args)
         params = mock_client.get.call_args[1]["params"]
         assert params["page"] == "2"
         assert params["per_page"] == "5"
         assert "deprecated" in capsys.readouterr().err
 
     def test_non_multiple_offset_errors(self, mock_client):
-        parser = _build_parser()
-        args = parser.parse_args(["programs", "list", "--limit", "10", "--offset", "5"])
+        args = _build_parser().parse_args(["programs", "optimized", "list", "--limit", "10", "--offset", "5"])
         with pytest.raises(CliError):
-            handle_list(mock_client, args)
+            args.func(mock_client, args)
 
 
 class TestProgramsShow:
@@ -273,16 +395,7 @@ class TestProgramsListTrashed:
         assert args.func(mock_client, args) == {"programs": [], "retention_days": 7}
         mock_client.get.assert_called_once_with("/api/v1/programs/trash")
 
-    def test_search_filters_do_not_apply(self, mock_client):
-        args = _build_parser().parse_args(["programs", "list", "--trashed", "--name", "x"])
-        with pytest.raises(CliError, match="--name does not apply"):
-            args.func(mock_client, args)
-        mock_client.get.assert_not_called()
-
-    @pytest.mark.parametrize(
-        "flag",
-        [["--order-by", "name"], ["--order", "asc"], ["--limit", "5"], ["--offset", "10"]],
-    )
+    @pytest.mark.parametrize("flag", [["--limit", "5"], ["--offset", "10"], ["--page", "2"]])
     def test_paging_and_sort_do_not_apply(self, mock_client, flag):
         args = _build_parser().parse_args(["programs", "list", "--trashed", *flag])
         with pytest.raises(CliError, match=f"{flag[0]} does not apply"):

{cmpnd-0.59.0 → cmpnd-0.60.0}/uv.lock

@@ -505,7 +505,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.59.0"
+version = "0.60.0"
 source = { editable = "." }
 default-groups = ["dspy-3-4-1"]
 dependencies = [