cmpnd 0.46.0__tar.gz → 0.47.0__tar.gz

{cmpnd-0.46.0 → cmpnd-0.47.0}/PKG-INFO

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

{cmpnd-0.46.0 → cmpnd-0.47.0}/cmpnd/deployment.py

@@ -2,9 +2,8 @@
 
 The deploy flow:
 1. Package the module into a source ZIP
-2. POST to the server to create a deployment (returns a presigned upload slot)
-3. PUT the ZIP to that slot (one path for both postures; bytes go direct to the
-   worker, raw body, no form)
+2. POST to the server to create a deployment (returns an upload slot on serve)
+3. PUT the ZIP to that slot as the raw body
 4. Poll until the parser finishes (status becomes "ready" or "failed")
 5. Return the deployment_id
 """
@@ -451,8 +450,8 @@ def deploy(module, metric=None, timeout=300, metadata=None, *, program_id=None):
 
     deploy_body: dict[str, Any] = {
         "program_signature_hash": identity.format_signature_hash(program_signature_hash),
-        # Declare the ZIP's exact length so the server can size-bound the upload
-        # slot and reject an oversized deploy before signing it (Slice E).
+        # Declare the ZIP's exact length so the server can reject an oversized
+        # deploy before the upload.
         "declared_content_length": len(zip_bytes),
     }
     # Left off when undeclared, so a serve from before program ids reads the body it

{cmpnd-0.46.0 → cmpnd-0.47.0}/cmpnd/optimization.py

@@ -11,8 +11,8 @@ Flow per :func:`optimize` call:
 1. Build the optimization bundle (``trainset.ndjson`` + ``valset.ndjson`` +
    ``metric.py``) and, if no ``deployment_id`` was given, :func:`deploy` the
    program to materialize the starting deployment A.
-2. Step 0 — ``data:"upload"``: POST to ``/optimize/{optimizer}`` to get a
-   presigned upload, PUT the bundle, then poll until the step completes. The
+2. Step 0 — ``data:"upload"``: POST to ``/optimize/{optimizer}`` to get an
+   upload slot, PUT the bundle, then poll until the step completes. The
    result becomes a first-class child deployment B.
 3. Steps 1..n — ``data:"reuse"`` on the latest result deployment, advancing the
    seed each step (the key quality lever). Track the best score; stop after
@@ -1417,14 +1417,12 @@ def _initiate_step(
 def _upload_bundle(
     client: httpx.Client, initiated: dict[str, Any], bundle: bytes, *, endpoint: str, api_key: str
 ) -> None:
-    """Upload the optimization bundle to the slot the initiate step returned.
+    """PUT the optimization bundle, raw, to the slot the initiate step returned.
 
-    Serve answers an ``awaiting_data`` initiate with ``upload_url``, ``upload_method:
-    "PUT"`` and empty ``upload_fields``, and the bundle goes out as the raw PUT body.
-    Serve authenticates that route with the API key, which rides the PUT only when
-    ``upload_url`` is on ``endpoint``'s origin (``_http.upload_auth_headers``). A
-    non-empty ``upload_fields`` is a presigned form, which no current server sends.
-    The bundle then rides as the ``file`` part of a multipart POST.
+    Serve answers an ``awaiting_data`` initiate with an ``upload_url`` on its own
+    bundle route, and authenticates that route with the API key. The key rides
+    the PUT only when ``upload_url`` is on ``endpoint``'s origin
+    (``_http.upload_auth_headers``).
 
     The slot pins its destination, so re-sending the same bytes writes the same
     object. That makes this call idempotent, so it rides through a transient answer
@@ -1433,31 +1431,9 @@ def _upload_bundle(
     upload_url = initiated.get("upload_url")
     if not upload_url:
         raise OptimizeError("upload step did not return an upload_url")
-    upload_fields = initiated.get("upload_fields")
-    method = (initiated.get("upload_method") or ("POST" if upload_fields else "PUT")).upper()
     what = "upload optimization bundle"
-    auth = _http.upload_auth_headers(upload_url, endpoint, api_key)
-
-    if upload_fields:
-        resp = _request(
-            lambda: client.post(
-                upload_url,
-                data=dict(upload_fields),
-                files={"file": ("data.zip", bundle, "application/zip")},
-                headers=auth,
-            ),
-            what,
-        )
-    else:
-        resp = _request(
-            lambda: client.request(
-                method,
-                upload_url,
-                content=bundle,
-                headers={"Content-Type": "application/zip", **auth},
-            ),
-            what,
-        )
+    headers = {"Content-Type": "application/zip", **_http.upload_auth_headers(upload_url, endpoint, api_key)}
+    resp = _request(lambda: client.put(upload_url, content=bundle, headers=headers), what)
     if not resp.is_success:
         body = (resp.text or "").strip()[:400]
         raise OptimizeError(f"failed to {what}: HTTP {resp.status_code}: {body}")

{cmpnd-0.46.0 → cmpnd-0.47.0}/cmpnd/packaging.py

@@ -1428,7 +1428,7 @@ def generate_source_zip(
 ) -> bytes:
     """Build a ZIP archive with program source, optional metric, and manifest.
 
-    The ZIP is suitable for upload to the deploy API via presigned S3 POST.
+    The ZIP is the body the deploy API's source upload takes.
     """
     import dspy
 

{cmpnd-0.46.0 → cmpnd-0.47.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.46.0"
+version = "0.47.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.46.0 → cmpnd-0.47.0}/tests/e2e/test_deploy_programs.py

@@ -212,11 +212,8 @@ class TestDeployBadImportRejected:
         headers = {"X-API-Key": config.api_key, "Content-Type": "application/json"}
 
         with httpx.Client(timeout=30.0) as client:
-            # Step 1: create deployment. declared_content_length is required
-            # (Slice E): the hosted presigned PUT is signed with the exact ZIP
-            # length, so it must be declared up front — exactly as cmpnd/deploy.py
-            # does, and a deployment names its program. This hand-crafted client
-            # mirrors that contract.
+            # Step 1: create the deployment, declaring the ZIP's length and
+            # naming its program as cmpnd.deploy does.
             create_resp = client.post(
                 f"{config.endpoint}/api/v1/deployments",
                 json={
@@ -232,11 +229,12 @@ class TestDeployBadImportRejected:
             deployment_id = data["deployment_id"]
             upload_url = data["upload_url"]
 
-            # Step 2: PUT the bad ZIP to the single upload slot (Slice E).
+            # Step 2: PUT the bad ZIP to the upload slot, which serve
+            # authenticates with the API key.
             upload_resp = client.put(
                 upload_url,
                 content=zip_bytes,
-                headers={"Content-Type": "application/zip"},
+                headers={"X-API-Key": config.api_key, "Content-Type": "application/zip"},
             )
             upload_resp.raise_for_status()
 

{cmpnd-0.46.0 → cmpnd-0.47.0}/tests/e2e/test_optimize_server_owned_completion.py

@@ -106,18 +106,13 @@ def _initiate_and_abandon(deployment_id: str, trainset, valset, metric) -> str:
         resp.raise_for_status()
         initiated = resp.json()
 
-        # serve normalizes the awaiting_data slot so upload_fields is always
-        # present: a non-empty form means presigned POST, empty means raw PUT.
-        upload_url = initiated["upload_url"]
-        upload_fields = initiated.get("upload_fields") or {}
-        if upload_fields:
-            up = client.post(
-                upload_url,
-                data=dict(upload_fields),
-                files={"file": ("data.zip", bundle, "application/zip")},
-            )
-        else:
-            up = client.put(upload_url, content=bundle, headers={"Content-Type": "application/zip"})
+        # The slot is serve's bundle route, which takes the raw bundle as a PUT
+        # and authenticates it with the API key.
+        up = client.put(
+            initiated["upload_url"],
+            content=bundle,
+            headers={"X-API-Key": cfg.api_key, "Content-Type": "application/zip"},
+        )
         up.raise_for_status()
 
     # Deliberately NO status poll — the server-owned watcher must finish it.

{cmpnd-0.46.0 → cmpnd-0.47.0}/tests/integration/test_logs_renders_traces.py

@@ -64,8 +64,7 @@ def _create_and_upload_real_module(rails: httpx.Client, stub_url: str) -> str:
     created = resp.json()
     deployment_id = created["deployment_id"]
 
-    # Upload the real source ZIP using whichever transport Rails returned
-    # — POST presigned (Lambda) or PUT (cmpnd-serve).
+    # PUT the real source ZIP to the slot the create response names.
     zip_bytes = generate_source_zip(module, None)
     upload_deploy_zip(created, zip_bytes)
 

{cmpnd-0.46.0 → cmpnd-0.47.0}/tests/integration/test_unhappy_path.py

@@ -59,7 +59,7 @@ def _create_deployment(rails: httpx.Client, *, signature_hash: int) -> dict:
 
 def _upload_to_stub(stub_url: str, create_resp: dict, zip_bytes: bytes) -> None:
     """Mirror the SDK's deploy upload step — a single PUT to the upload slot
-    (Slice E) via the shared conftest helper. ``stub_url`` is unused — kept in
+    via the shared conftest helper. ``stub_url`` is unused — kept in
     the signature so existing call-sites don't need editing."""
     del stub_url  # historical; the helper reads upload_url from create_resp
     upload_deploy_zip(create_resp, zip_bytes)

{cmpnd-0.46.0 → cmpnd-0.47.0}/tests/test_deploy.py

@@ -59,7 +59,7 @@ class TestDeploy:
         }
         create_response.raise_for_status = mock.MagicMock()
 
-        # S3 upload response (presigned PUT, Slice E)
+        # Upload slot response
         upload_response = mock.MagicMock()
         upload_response.status_code = 200
         upload_response.raise_for_status = mock.MagicMock()
@@ -88,7 +88,7 @@ class TestDeploy:
         signature.json.return_value = signature_response
         signature.raise_for_status = mock.MagicMock()
 
-        # Wire up: POST = create; PUT = upload slot (Slice E); GET = polls.
+        # Wire up: POST = create; PUT = upload slot; GET = polls.
         client.post.side_effect = [create_response]
         client.put.side_effect = [upload_response]
         client.get.side_effect = [*poll_responses, signature]
@@ -178,7 +178,7 @@ class TestDeploy:
 
             deployment.deploy(dspy.Predict("question -> answer"))
 
-        # Slice E: one PUT of the raw ZIP to the presigned upload slot.
+        # One PUT of the raw ZIP to the upload slot.
         client.post.assert_called_once()
         upload_call = client.put.call_args
         assert "s3.amazonaws.com" in upload_call.args[0]
@@ -194,7 +194,7 @@ class TestDeploy:
 
             deployment.deploy(dspy.Predict("question -> answer"))
 
-        # The create body declares the ZIP length for the size cap (Slice E).
+        # The create body declares the ZIP length for the size cap.
         create_call = client.post.call_args_list[0]
         body = create_call.kwargs["json"]
         assert isinstance(body["declared_content_length"], int)

{cmpnd-0.46.0 → cmpnd-0.47.0}/tests/test_optimize.py

@@ -127,14 +127,13 @@ def _one_completed_step(mock_httpx):
             {
                 "optimization_id": "opt-0",
                 "status": "awaiting_data",
-                "upload_url": "https://s3/b",
-                "upload_method": "POST",
-                "upload_fields": {"key": "k"},
+                "upload_url": "https://serve.example/api/v1/optimizations/opt-0/bundle",
+                "upload_method": "PUT",
             },
             status_code=201,
         ),
-        _resp(status_code=204),
     ]
+    client.put.side_effect = [_resp(status_code=204)]
     client.get.side_effect = [
         _resp({"status": "completed", "best_score": 0.5, "result_deployment_id": "dep-B"}),
     ]
@@ -348,14 +347,14 @@ class TestLoop:
                 {
                     "optimization_id": "opt-0",
                     "status": "awaiting_data",
-                    "upload_url": "https://s3/bucket",
-                    "upload_fields": {"key": "k"},
+                    "upload_url": "https://serve.example/api/v1/optimizations/opt-0/bundle",
+                    "upload_method": "PUT",
                 },
                 status_code=201,
             ),
-            _resp(is_success=True, status_code=204),  # S3 upload
             _resp({"optimization_id": "opt-1", "status": "running"}, status_code=201),
         ]
+        client.put.side_effect = [_resp(status_code=204)]
         client.get.side_effect = [
             _resp({"status": "completed", "best_score": 0.5, "result_deployment_id": "dep-B"}),
             _resp({"status": "completed", "best_score": 0.6, "result_deployment_id": "dep-C"}),
@@ -379,13 +378,13 @@ class TestLoop:
         assert init0.kwargs["json"]["data"] == "upload"
         assert init0.kwargs["json"]["config"]["seed"] == 0
 
-        # The bundle is uploaded exactly once (to the presigned URL).
-        upload = client.post.call_args_list[1]
-        assert upload.args[0] == "https://s3/bucket"
-        assert "file" in upload.kwargs["files"]
+        # The bundle is PUT exactly once, raw, to the slot serve answered.
+        (upload,) = client.put.call_args_list
+        assert upload.args[0] == "https://serve.example/api/v1/optimizations/opt-0/bundle"
+        assert upload.kwargs["content"]
 
         # Step 1 REUSEs the result deployment (dep-B) with seed advanced to 1.
-        init1 = client.post.call_args_list[2]
+        init1 = client.post.call_args_list[1]
         assert "/deployments/dep-B/optimize/gepa" in init1.args[0]
         assert init1.kwargs["json"]["data"] == "reuse"
         assert init1.kwargs["json"]["config"]["seed"] == 1
@@ -395,17 +394,14 @@ class TestLoop:
         assert result.score == 0.6
         assert callable(result)
 
-    def test_upload_uses_raw_put_for_worker_posture(self, mock_httpx):
-        """On-prem (worker-sandbox) posture: serve normalizes the awaiting_data
-        response to upload_method=PUT with empty upload_fields. The bundle must
-        go out as a raw PUT to the slot URL — not a multipart POST — so the one
-        SDK upload path serves both the worker (PUT) and the Lambda (presigned
-        POST) workers (the CMP-250 × CMP-254 reconciliation)."""
+    def test_upload_is_a_raw_put_to_the_slot(self, mock_httpx):
+        """Serve answers awaiting_data with one PUT slot. The bundle goes out
+        as the raw PUT body to that URL, never as a multipart form."""
         client = _client(mock_httpx)
         train, val = _examples()
 
         # Only the two initiate calls go through client.post; the bundle upload
-        # is a PUT, so it lands on client.request and must not consume a post.
+        # is a PUT, so it lands on client.put and must not consume a post.
         client.post.side_effect = [
             _resp(
                 {
@@ -413,13 +409,12 @@ class TestLoop:
                     "status": "awaiting_data",
                     "upload_url": "http://worker:8082/uploads/opt-0",
                     "upload_method": "PUT",
-                    "upload_fields": {},
                 },
                 status_code=201,
             ),
             _resp({"optimization_id": "opt-1", "status": "running"}, status_code=201),
         ]
-        client.request.side_effect = [_resp(is_success=True, status_code=202)]
+        client.put.side_effect = [_resp(is_success=True, status_code=202)]
         client.get.side_effect = [
             _resp({"status": "completed", "best_score": 0.5, "result_deployment_id": "dep-B"}),
             _resp({"status": "completed", "best_score": 0.5, "result_deployment_id": "dep-C"}),
@@ -439,8 +434,8 @@ class TestLoop:
             )
 
         # The bundle was PUT (raw bytes) to the worker's slot, never POSTed.
-        put = client.request.call_args
-        assert put.args == ("PUT", "http://worker:8082/uploads/opt-0")
+        put = client.put.call_args
+        assert put.args == ("http://worker:8082/uploads/opt-0",)
         assert put.kwargs["content"]  # raw zip bytes, not a multipart `files=`
         assert put.kwargs["headers"]["Content-Type"] == "application/zip"
         # The two client.post calls are both initiate calls (no upload among them).
@@ -456,15 +451,14 @@ class TestLoop:
                 {
                     "optimization_id": "opt-0",
                     "status": "awaiting_data",
-                    "upload_url": "https://s3/b",
-                    "upload_method": "POST",
-                    "upload_fields": {"key": "k"},
+                    "upload_url": "https://serve.example/api/v1/optimizations/opt-0/bundle",
+                    "upload_method": "PUT",
                 },
                 status_code=201,
             ),
-            _resp(status_code=204),
             _resp({"optimization_id": "opt-1", "status": "running"}, status_code=201),
         ]
+        client.put.side_effect = [_resp(status_code=204)]
         # Both steps score the same → no improvement on step 1.
         client.get.side_effect = [
             _resp({"status": "completed", "best_score": 0.5, "result_deployment_id": "dep-B"}),
@@ -499,14 +493,13 @@ class TestLoop:
                 {
                     "optimization_id": "opt-0",
                     "status": "awaiting_data",
-                    "upload_url": "https://s3/b",
-                    "upload_method": "POST",
-                    "upload_fields": {"key": "k"},
+                    "upload_url": "https://serve.example/api/v1/optimizations/opt-0/bundle",
+                    "upload_method": "PUT",
                 },
                 status_code=201,
             ),
-            _resp(status_code=204),
         ]
+        client.put.side_effect = [_resp(status_code=204)]
         client.get.side_effect = [
             _resp({"status": "completed", "best_score": 0.7, "result_deployment_id": "dep-B"}),
         ]
@@ -545,14 +538,13 @@ class TestFailures:
                 {
                     "optimization_id": "opt-0",
                     "status": "awaiting_data",
-                    "upload_url": "https://s3/b",
-                    "upload_method": "POST",
-                    "upload_fields": {"key": "k"},
+                    "upload_url": "https://serve.example/api/v1/optimizations/opt-0/bundle",
+                    "upload_method": "PUT",
                 },
                 status_code=201,
             ),
-            _resp(status_code=204),
         ]
+        client.put.side_effect = [_resp(status_code=204)]
         client.get.side_effect = [
             _resp({"status": "failed", "error": "trainset row 1 missing label field(s): ['answer']"}),
         ]
@@ -633,8 +625,8 @@ class TestNetworkErrorsWrapped:
 
     def test_upload_bundle_wraps_network_error(self):
         client = mock.MagicMock()
-        client.post.side_effect = httpx.WriteTimeout("slow upload")
-        initiated = {"upload_url": "https://s3.example/bucket", "upload_fields": {"key": "programs/x/data.zip"}}
+        client.put.side_effect = httpx.WriteTimeout("slow upload")
+        initiated = {"upload_url": "http://x/api/v1/optimizations/opt-0/bundle", "upload_method": "PUT"}
         # The upload re-sends the same bytes to the same pinned slot, so a
         # transport blip is retried; the wrapped error surfaces once the budget
         # is spent.
@@ -951,13 +943,13 @@ class TestInitiateAndUploadTolerance:
 
     def test_upload_retries_a_retryable_response(self):
         client = mock.MagicMock()
-        client.request.side_effect = [_transient(), _resp(status_code=204)]
-        initiated = {"upload_url": "http://worker:8082/uploads/opt-0", "upload_fields": {}}
+        client.put.side_effect = [_transient(), _resp(status_code=204)]
+        initiated = {"upload_url": "http://worker:8082/uploads/opt-0"}
 
         with _fake_clock():
             optimization._upload_bundle(client, initiated, b"zip-bytes", endpoint="http://x", api_key="k")
 
-        assert client.request.call_count == 2
+        assert client.put.call_count == 2
 
 
 class TestUploadAuthentication:
@@ -982,7 +974,7 @@ class TestUploadAuthentication:
         return sent
 
     def test_upload_to_the_endpoint_carries_the_api_key(self):
-        (upload,) = self._upload({"upload_url": self._OWN_SLOT, "upload_method": "PUT", "upload_fields": {}})
+        (upload,) = self._upload({"upload_url": self._OWN_SLOT, "upload_method": "PUT"})
 
         assert upload.method == "PUT"
         assert str(upload.url) == self._OWN_SLOT
@@ -991,20 +983,19 @@ class TestUploadAuthentication:
         assert upload.content == b"zip-bytes"
 
     def test_upload_to_another_origin_carries_no_api_key(self):
-        (upload,) = self._upload(
-            {"upload_url": "http://worker:8082/uploads/opt-0", "upload_method": "PUT", "upload_fields": {}}
-        )
+        (upload,) = self._upload({"upload_url": "http://worker:8082/uploads/opt-0", "upload_method": "PUT"})
 
         assert "X-API-Key" not in upload.headers
         assert upload.headers["Content-Type"] == "application/zip"
 
-    def test_presigned_form_upload_carries_no_api_key(self):
+    def test_upload_is_a_raw_put_whatever_form_the_answer_names(self):
         (upload,) = self._upload(
-            {"upload_url": "https://s3.example/bucket", "upload_fields": {"key": "programs/x/data.zip"}}
+            {"upload_url": self._OWN_SLOT, "upload_method": "POST", "upload_fields": {"key": "programs/x/data.zip"}}
         )
 
-        assert upload.method == "POST"
-        assert "X-API-Key" not in upload.headers
+        assert upload.method == "PUT"
+        assert upload.headers["Content-Type"] == "application/zip"
+        assert upload.content == b"zip-bytes"
 
     def test_optimize_hands_the_configured_endpoint_and_key_to_the_upload(self, mock_httpx):
         client = _client(mock_httpx)
@@ -1016,12 +1007,11 @@ class TestUploadAuthentication:
                     "status": "awaiting_data",
                     "upload_url": self._OWN_SLOT,
                     "upload_method": "PUT",
-                    "upload_fields": {},
                 },
                 status_code=201,
             ),
         ]
-        client.request.side_effect = [_resp(status_code=200)]
+        client.put.side_effect = [_resp(status_code=200)]
         client.get.side_effect = [_resp({"status": "completed", "best_score": 0.5, "result_deployment_id": "dep-B"})]
 
         with _no_sleep():
@@ -1036,7 +1026,7 @@ class TestUploadAuthentication:
                 max_steps=1,
             )
 
-        put = client.request.call_args
-        assert put.args == ("PUT", self._OWN_SLOT)
+        put = client.put.call_args
+        assert put.args == (self._OWN_SLOT,)
         assert put.kwargs["headers"]["X-API-Key"] == "ct_test_key"
         assert put.kwargs["headers"]["Content-Type"] == "application/zip"

{cmpnd-0.46.0 → cmpnd-0.47.0}/tests/test_upload_auth_headers.py

@@ -27,7 +27,7 @@ _KEY = "ct_test_key"
         ("http://localhost/api/v1/optimizations/op_abc/bundle", "http://localhost:80"),
         # Scheme and host compare case-insensitively.
         ("HTTPS://App.Cmpnd.AI/api/v1/deployments/d_abc/source", _ENDPOINT),
-        ("http://localhost:3000/api/v1/uploads/source/p_abc", "http://localhost:3000"),
+        ("http://localhost:3000/api/v1/deployments/d_abc/source", "http://localhost:3000"),
     ],
 )
 def test_sends_the_key_to_the_endpoint_origin(upload_url: str, endpoint: str) -> None:

{cmpnd-0.46.0 → cmpnd-0.47.0}/uv.lock

@@ -496,7 +496,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.46.0"
+version = "0.47.0"
 source = { editable = "." }
 dependencies = [
     { name = "dspy" },