gridlinegpu 0.1.3__tar.gz → 0.1.4__tar.gz

{gridlinegpu-0.1.3 → gridlinegpu-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridlinegpu
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python client for Gridline YAML workload routing
 Author: Gridline GPU
 License: Proprietary
@@ -23,7 +23,7 @@ the `gridline` command in the same Python environment on macOS and Linux.
 ## Install
 
 ```sh
-python -m pip install 'gridlinegpu>=0.1.3,<0.2'
+python -m pip install 'gridlinegpu>=0.1.4,<0.2'
 ```
 
 Run browser setup once. It creates a 30-day scoped token in a private file, attempts to
@@ -36,7 +36,9 @@ gridline setup --apply
 
 Use a YAML file beside its referenced inputs. Task, model, engine, providers, output,
 budget, and deadline belong in YAML rather than Python arguments.
-Current hosted artifact limits are 40 MiB per local input and 8 MiB per output.
+Server-advertised artifact limits govern each submission. Newer Gridline deployments
+use direct, signed resumable Storage uploads for large local inputs; older deployments
+may still cap inputs at 40 MiB and outputs at 8 MiB.
 
 ```python
 from gridlinegpu import GridlineClient
@@ -86,3 +88,22 @@ new key. `outputs()` verifies byte count and SHA-256 before creating private fil
 Cancellation requests stop; cleanup and final provider billing can remain pending.
 For finite jobs, `wait()` returns when outputs are complete, even if cleanup and billing
 leave `outcome` pending. Check `status()` later for final settlement.
+
+When worker progress is enabled on the hosted API/control service and supported by the
+deployed worker image, `status()` also returns optional `progress`:
+
+```python
+status = client.status(job_id)
+progress = status.get("progress")
+if progress:
+    for event in progress["events"]:
+        print(event["stage"], event["observedAt"])
+```
+
+Events are bounded, ordered worker reports for `progress["attemptId"]` and its fence.
+Stages include input staging, model preparation/loading, inference start/completion,
+and output upload. `observedAt` is the server's receipt time. Poll no faster than every
+five seconds; deduplicate by attempt/fence/stage. Missing progress or skipped stages
+mean unavailable evidence, not failure or an inferred stage. Inference completion
+does not imply stored outputs, job success, cleanup, or settled billing. `wait()` keeps
+its existing completion behavior and does not stream progress callbacks.

{gridlinegpu-0.1.3 → gridlinegpu-0.1.4}/README.md

@@ -8,7 +8,7 @@ the `gridline` command in the same Python environment on macOS and Linux.
 ## Install
 
 ```sh
-python -m pip install 'gridlinegpu>=0.1.3,<0.2'
+python -m pip install 'gridlinegpu>=0.1.4,<0.2'
 ```
 
 Run browser setup once. It creates a 30-day scoped token in a private file, attempts to
@@ -21,7 +21,9 @@ gridline setup --apply
 
 Use a YAML file beside its referenced inputs. Task, model, engine, providers, output,
 budget, and deadline belong in YAML rather than Python arguments.
-Current hosted artifact limits are 40 MiB per local input and 8 MiB per output.
+Server-advertised artifact limits govern each submission. Newer Gridline deployments
+use direct, signed resumable Storage uploads for large local inputs; older deployments
+may still cap inputs at 40 MiB and outputs at 8 MiB.
 
 ```python
 from gridlinegpu import GridlineClient
@@ -71,3 +73,22 @@ new key. `outputs()` verifies byte count and SHA-256 before creating private fil
 Cancellation requests stop; cleanup and final provider billing can remain pending.
 For finite jobs, `wait()` returns when outputs are complete, even if cleanup and billing
 leave `outcome` pending. Check `status()` later for final settlement.
+
+When worker progress is enabled on the hosted API/control service and supported by the
+deployed worker image, `status()` also returns optional `progress`:
+
+```python
+status = client.status(job_id)
+progress = status.get("progress")
+if progress:
+    for event in progress["events"]:
+        print(event["stage"], event["observedAt"])
+```
+
+Events are bounded, ordered worker reports for `progress["attemptId"]` and its fence.
+Stages include input staging, model preparation/loading, inference start/completion,
+and output upload. `observedAt` is the server's receipt time. Poll no faster than every
+five seconds; deduplicate by attempt/fence/stage. Missing progress or skipped stages
+mean unavailable evidence, not failure or an inferred stage. Inference completion
+does not imply stored outputs, job success, cleanup, or settled billing. `wait()` keeps
+its existing completion behavior and does not stream progress callbacks.

{gridlinegpu-0.1.3 → gridlinegpu-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gridlinegpu"
-version = "0.1.3"
+version = "0.1.4"
 description = "Python client for Gridline YAML workload routing"
 readme = "README.md"
 requires-python = ">=3.10"

{gridlinegpu-0.1.3 → gridlinegpu-0.1.4}/src/gridlinegpu/cli.py

@@ -85,6 +85,15 @@ def _emit(value: Any, output: TextIO) -> None:
     print(json.dumps(value, indent=2, sort_keys=True, default=str), file=output)
 
 
+def _warn_unmeasured_duration(review: dict[str, Any], errors: TextIO) -> None:
+    quote = review.get("result", {}).get("quote", {})
+    selected = quote.get("selected", {}) if isinstance(quote, dict) else {}
+    duration = selected.get("expectedDurationMs", {}) if isinstance(selected, dict) else {}
+    if isinstance(duration, dict) and duration.get("source") == "customer_declared":
+        print("Gridline: task-cost ranking uses customer-declared duration, not measured "
+              "GPU-specific performance; estimate is not guaranteed.", file=errors)
+
+
 def _confirm(message: str, *, yes: bool, input_stream: TextIO,
              output: TextIO) -> None:
     if yes:
@@ -140,6 +149,7 @@ def main(argv: Sequence[str] | None = None, *, input_stream: TextIO = sys.stdin,
             result = client.validate(args.file)
         elif action == "plan":
             result = client.plan(args.file).review
+            _warn_unmeasured_duration(result, errors)
         elif action == "run":
             if not args.apply:
                 raise GridlineError("Paid launch requires --apply", code="apply_required")
@@ -151,6 +161,7 @@ def main(argv: Sequence[str] | None = None, *, input_stream: TextIO = sys.stdin,
                 raise ValueError("--idempotency-key must contain 1–128 safe characters")
             planned = client.plan(args.file)
             _emit(planned.review, output)
+            _warn_unmeasured_duration(planned.review, errors)
             if planned.quote is None:
                 raise GridlineError("Router abstained; inspect plan coverage", code="plan_abstained")
             _confirm(f"Launch with approved ceiling ${amount}?", yes=args.yes,

{gridlinegpu-0.1.3 → gridlinegpu-0.1.4}/src/gridlinegpu/client.py

@@ -5,6 +5,7 @@ All task settings live in YAML. Methods never select a GPU or retry a paid launc
 
 from __future__ import annotations
 
+import base64
 import hashlib
 import json
 import os
@@ -15,9 +16,9 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from decimal import Decimal
 from pathlib import Path
-from typing import Any
+from typing import Any, Iterable
 from urllib.error import HTTPError, URLError
-from urllib.parse import quote, urlparse
+from urllib.parse import quote, urljoin, urlparse
 from urllib.request import HTTPRedirectHandler, Request, build_opener
 
 import yaml
@@ -29,7 +30,9 @@ _ID = re.compile(r"^[A-Za-z0-9_-]{1,80}$")
 _KEY = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$")
 _SHA = re.compile(r"^[0-9a-f]{64}$")
 _MAX_YAML = 65_536
-_MAX_DOWNLOAD = 8 * 1024 * 1024
+_MAX_DOWNLOAD = 128 * 1024 * 1024
+_TUS_CHUNK = 6 * 1024 * 1024
+_TUS_PATH = "/storage/v1/upload/resumable/sign"
 _USER_AGENT = "GridlinePythonSDK/1"
 
 
@@ -113,12 +116,18 @@ class GridlineClient:
         if not available.get("planningAvailable"):
             raise GridlineError("YAML planning is unavailable for this account", code="planning_unavailable")
         inputs = _local_inputs(document)
-        if validated.get("requiredAttachments") != [name for name, _ in inputs]:
+        required = validated.get("requiredAttachments")
+        names = [name for name, _ in inputs]
+        if (not isinstance(required, list)
+                or any(not isinstance(name, str) for name in required + names)
+                or len(required) != len(set(required))
+                or len(names) != len(set(names))
+                or sorted(required) != sorted(names)):
             raise GridlineError("Input names differ from server validation", code="remote_contract_invalid")
         if inputs and not available.get("artifactStagingAvailable"):
             raise GridlineError("Input staging is unavailable for this account", code="staging_unavailable")
         ceiling = available.get("maximumAttachmentBytes")
-        if not isinstance(ceiling, int) or ceiling < 1:
+        if type(ceiling) is not int or not 1 <= ceiling <= 512 * 1024 * 1024:
             raise GridlineError("Invalid server attachment limit", code="remote_contract_invalid")
         bindings = [self._stage(path.parent, name, item, ceiling) for name, item in inputs]
         body = {"schemaVersion": 1, "yaml": source, "attachmentBindings": bindings}
@@ -249,7 +258,8 @@ class GridlineClient:
             if not isinstance(name, str) or name in ("", ".", "..") or Path(name).name != name:
                 raise GridlineError("Unsafe output name", code="remote_contract_invalid")
             digest, size = item.get("sha256"), item.get("bytes")
-            if not isinstance(digest, str) or not _SHA.fullmatch(digest) or not isinstance(size, int) or size > _MAX_DOWNLOAD:
+            if (not isinstance(digest, str) or not _SHA.fullmatch(digest)
+                    or not isinstance(size, int) or size < 0 or size > _MAX_DOWNLOAD):
                 raise GridlineError("Invalid output digest or size", code="remote_contract_invalid")
             grant = self._json("GET", f"{_API}/jobs/{quote(job_id)}/output/{quote(artifact_id)}/grant")
             if (grant.get("jobId"), grant.get("artifactId"), grant.get("sha256"), grant.get("byteLength")) != (job_id, artifact_id, digest, size):
@@ -257,17 +267,41 @@ class GridlineClient:
             access = grant.get("download", {})
             if not _future(access.get("expiresAt")):
                 raise GridlineError("Output grant expired", code="grant_expired")
-            data = self._bytes("GET", access.get("url"), maximum=_MAX_DOWNLOAD)
-            if len(data) != size or _sha(data) != digest:
-                raise GridlineError("Output checksum mismatch", code="output_hash_mismatch")
             destination = target / name
-            with destination.open("xb") as handle:
-                os.chmod(destination, 0o600)
-                handle.write(data)
+            self._download_verified(access.get("url"), destination, size, digest)
             downloaded.append({"name": name, "path": str(destination), "sha256": digest})
         return {"jobId": job_id, "state": result.get("state"), "downloaded": downloaded,
                 "missingRequiredOutputs": manifest.get("missingRequiredOutputs", [])}
 
+    def _download_verified(self, url: str | None, destination: Path, size: int, digest: str) -> None:
+        """Stream to private temp file; expose destination only after digest matches."""
+        if not isinstance(url, str) or urlparse(url).scheme != "https":
+            raise GridlineError("Grant URL must use HTTPS", code="remote_contract_invalid")
+        temporary = destination.with_name(f".{destination.name}.{uuid.uuid4().hex}.partial")
+        request = Request(url, headers={"User-Agent": _USER_AGENT}, method="GET")
+        count = 0
+        checksum = hashlib.sha256()
+        try:
+            with temporary.open("xb") as handle:
+                os.chmod(temporary, 0o600)
+                with self._opener.open(request, timeout=self._timeout) as response:
+                    while chunk := response.read(65_536):
+                        count += len(chunk)
+                        if count > size:
+                            raise GridlineError("Output exceeded declared size", code="output_hash_mismatch")
+                        checksum.update(chunk)
+                        handle.write(chunk)
+            if count != size or checksum.hexdigest() != digest:
+                raise GridlineError("Output checksum mismatch", code="output_hash_mismatch")
+            os.link(temporary, destination)
+        except HTTPError as error:
+            raise GridlineError(f"Output download failed: HTTP {error.code}",
+                                code="http_error", status=error.code) from error
+        except URLError as error:
+            raise GridlineError("Output download failed", code="network_error") from error
+        finally:
+            temporary.unlink(missing_ok=True)
+
     def cancel(self, job_id: str) -> dict[str, Any]:
         job_id = _id(job_id, "jobId")
         result = self._json("POST", f"{_API}/jobs/{quote(job_id)}/cancel")
@@ -277,28 +311,165 @@ class GridlineClient:
 
     def _stage(self, base: Path, name: str, item: dict[str, Any], ceiling: int) -> dict[str, Any]:
         path = _local_path(base, item["path"])
-        data = _bounded_file(path, min(ceiling, 40 * 1024 * 1024))
-        digest = _sha(data)
-        if item.get("sha256") not in (None, digest) or item.get("bytes") not in (None, len(data)):
+        size, digest = _bounded_file_identity(path, ceiling)
+        if item.get("sha256") not in (None, digest) or item.get("bytes") not in (None, size):
             raise GridlineError(f"Input {name} differs from YAML digest or size", code="input_changed")
         format_name = item["format"]
         reserved = self._json(
             "POST", f"{_API}/attachments",
-            {"schemaVersion": 1, "format": format_name, "sha256": digest, "byteLength": len(data)},
+            {"schemaVersion": 1, "format": format_name, "sha256": digest, "byteLength": size},
             key=f"sdk-attachment-{_sha((format_name + digest).encode())}",
         )
         artifact_id = _id(reserved.get("artifactId"), "artifactId")
-        if (reserved.get("sha256"), reserved.get("byteLength"), reserved.get("format")) != (digest, len(data), format_name):
+        if (reserved.get("sha256"), reserved.get("byteLength"), reserved.get("format")) != (digest, size, format_name):
             raise GridlineError("Attachment reservation mismatch", code="remote_contract_invalid")
         if reserved.get("state") != "ready":
             upload = reserved.get("upload", {})
-            if upload.get("method") != "PUT" or not isinstance(upload.get("headers", {}).get("Authorization"), str):
+            if not isinstance(upload, dict):
+                raise GridlineError("Invalid attachment upload grant", code="remote_contract_invalid")
+            uncertain_tus_upload = None
+            if upload.get("method") == "TUS":
+                try:
+                    self._upload_tus(path, size, upload)
+                except GridlineError as error:
+                    if not _tus_retryable(error):
+                        raise
+                    # Final PATCH may have committed while its reply and HEAD were lost.
+                    uncertain_tus_upload = error
+                if _bounded_file_identity(path, size) != (size, digest):
+                    raise GridlineError("Input changed during upload", code="input_changed")
+            elif upload.get("method") == "PUT":
+                if not isinstance(upload.get("headers"), dict) or not isinstance(upload["headers"].get("Authorization"), str):
+                    raise GridlineError("Invalid attachment upload grant", code="remote_contract_invalid")
+                sent = 0
+                sent_hash = hashlib.sha256()
+
+                def chunks() -> Iterable[bytes]:
+                    nonlocal sent
+                    with path.open("rb") as handle:
+                        while chunk := handle.read(65_536):
+                            sent += len(chunk)
+                            if sent > size:
+                                raise GridlineError("Input changed during upload", code="input_changed")
+                            sent_hash.update(chunk)
+                            yield chunk
+
+                self._bytes(
+                    "PUT", upload.get("url"), data=chunks(),
+                    headers={"Authorization": upload["headers"]["Authorization"],
+                             "Content-Length": str(size)}, maximum=16_384,
+                )
+                if sent != size or sent_hash.hexdigest() != digest:
+                    raise GridlineError("Input changed during upload", code="input_changed")
+            else:
                 raise GridlineError("Invalid attachment upload grant", code="remote_contract_invalid")
-            self._bytes("PUT", upload.get("url"), data=data, headers={"Authorization": upload["headers"]["Authorization"]}, maximum=16_384)
-            confirmed = self._json("POST", f"{_API}/attachments/{quote(artifact_id)}/confirm")
-            if (confirmed.get("state"), confirmed.get("artifactId"), confirmed.get("sha256")) != ("ready", artifact_id, digest):
+            try:
+                confirmed = self._json("POST", f"{_API}/attachments/{quote(artifact_id)}/confirm")
+            except GridlineError:
+                if uncertain_tus_upload is not None:
+                    raise uncertain_tus_upload
+                raise
+            if (confirmed.get("state"), confirmed.get("artifactId"), confirmed.get("sha256"),
+                    confirmed.get("byteLength")) != ("ready", artifact_id, digest, size):
+                if uncertain_tus_upload is not None:
+                    raise uncertain_tus_upload
                 raise GridlineError("Attachment confirmation mismatch", code="remote_contract_invalid")
-        return {"logicalName": name, "artifactId": artifact_id, "sha256": digest, "bytes": len(data)}
+        return {"logicalName": name, "artifactId": artifact_id, "sha256": digest, "bytes": size}
+
+    def _upload_tus(self, path: Path, size: int, upload: dict[str, Any]) -> None:
+        endpoint = _tus_endpoint(upload.get("url"))
+        headers = upload.get("headers")
+        metadata = upload.get("metadata")
+        if (not isinstance(headers, dict) or not isinstance(headers.get("x-signature"), str)
+                or not re.fullmatch(r"\S{1,8192}", headers["x-signature"]) or not isinstance(metadata, dict)
+                or not all(isinstance(metadata.get(key), str) and metadata[key]
+                           for key in ("bucketName", "objectName", "contentType"))
+                or upload.get("chunkBytes") != _TUS_CHUNK or not _future(upload.get("expiresAt"))):
+            raise GridlineError("Invalid signed TUS grant", code="remote_contract_invalid")
+        signed = {"Tus-Resumable": "1.0.0", "x-signature": headers["x-signature"]}
+        encoded = ",".join(
+            f"{key} {base64.b64encode(metadata[key].encode('utf-8')).decode('ascii')}"
+            for key in ("bucketName", "objectName", "contentType")
+        )
+        creation = {**signed, "Upload-Length": str(size), "Upload-Metadata": encoded}
+        location = None
+        for attempt in range(3):
+            try:
+                status, response_headers = self._tus_request("POST", endpoint, creation)
+                if status != 201:
+                    raise GridlineError("TUS creation returned unexpected status", code="attachment_upload_failed", status=status)
+                location = _tus_location(endpoint, response_headers.get("Location"))
+                break
+            except GridlineError as error:
+                if attempt == 2 or not _tus_retryable(error):
+                    raise
+                time.sleep(0.25 * (2 ** attempt))
+        if location is None:
+            raise GridlineError("TUS creation failed", code="attachment_upload_failed")
+
+        offset = 0
+        failures = 0
+        with path.open("rb") as handle:
+            while offset < size:
+                handle.seek(offset)
+                chunk = handle.read(min(_TUS_CHUNK, size - offset))
+                if not chunk:
+                    raise GridlineError("Input changed during upload", code="input_changed")
+                try:
+                    status, response_headers = self._tus_request(
+                        "PATCH", location,
+                        {**signed, "Upload-Offset": str(offset),
+                         "Content-Type": "application/offset+octet-stream",
+                         "Content-Length": str(len(chunk))}, chunk,
+                    )
+                    if status != 204:
+                        raise GridlineError("TUS chunk returned unexpected status", code="attachment_upload_failed", status=status)
+                    reported = response_headers.get("Upload-Offset")
+                    next_offset = _tus_offset(reported, size) if reported is not None else self._tus_head(location, signed, size)
+                    if next_offset != offset + len(chunk):
+                        raise GridlineError("TUS chunk offset mismatch", code="remote_contract_invalid")
+                    offset = next_offset
+                    failures = 0
+                except GridlineError as error:
+                    if not _tus_retryable(error) or failures >= 4:
+                        raise
+                    failures += 1
+                    time.sleep(0.25 * (2 ** (failures - 1)))
+                    recovered = self._tus_head(location, signed, size)
+                    if recovered < offset:
+                        raise GridlineError("TUS offset moved backwards", code="remote_contract_invalid")
+                    offset = recovered
+
+    def _tus_head(self, location: str, signed: dict[str, str], size: int) -> int:
+        for attempt in range(3):
+            try:
+                status, headers = self._tus_request("HEAD", location, signed)
+                if status != 200:
+                    raise GridlineError("TUS status returned unexpected status", code="attachment_upload_failed", status=status)
+                reported_length = headers.get("Upload-Length")
+                if reported_length is not None and reported_length != str(size):
+                    raise GridlineError("TUS length mismatch", code="remote_contract_invalid")
+                return _tus_offset(headers.get("Upload-Offset"), size)
+            except GridlineError as error:
+                if attempt == 2 or not _tus_retryable(error):
+                    raise
+                time.sleep(0.25 * (2 ** attempt))
+        raise GridlineError("TUS status failed", code="attachment_upload_failed")
+
+    def _tus_request(self, method: str, url: str, headers: dict[str, str], data: bytes | None = None) -> tuple[int, Any]:
+        request = Request(url, data=data, headers={"User-Agent": _USER_AGENT, **headers}, method=method)
+        try:
+            with self._opener.open(request, timeout=max(self._timeout, 120)) as response:
+                if len(response.read(16_385)) > 16_384:
+                    raise GridlineError("TUS response exceeded size limit", code="remote_contract_invalid")
+                return response.status, response.headers
+        except HTTPError as error:
+            raise GridlineError(f"Attachment upload failed: HTTP {error.code}",
+                                code="attachment_upload_failed", status=error.code) from error
+        except URLError as error:
+            raise GridlineError("Attachment upload network failure", code="network_error") from error
+        except OSError as error:
+            raise GridlineError("Attachment upload network failure", code="network_error") from error
 
     def _json(self, method: str, path: str, body: dict[str, Any] | None = None, *, key: str | None = None) -> dict[str, Any]:
         headers = {"Authorization": f"Bearer {self._read_token()}", "Accept": "application/json"}
@@ -316,7 +487,7 @@ class GridlineClient:
             raise GridlineError("Invalid response shape", code="remote_contract_invalid")
         return value
 
-    def _bytes(self, method: str, url: str | None, *, data: bytes | None = None,
+    def _bytes(self, method: str, url: str | None, *, data: bytes | Iterable[bytes] | None = None,
                headers: dict[str, str] | None = None, maximum: int) -> bytes:
         if not isinstance(url, str) or urlparse(url).scheme != "https":
             raise GridlineError("Grant URL must use HTTPS", code="remote_contract_invalid")
@@ -382,7 +553,7 @@ def _local_inputs(document: dict[str, Any]) -> list[tuple[str, dict[str, Any]]]:
     inputs = document.get("inputs", {})
     if not isinstance(inputs, dict):
         raise GridlineError("Invalid YAML inputs", code="invalid_yaml")
-    return [(name, {"path": item["file"], "format": item["format"],
+    return [(name, {"path": item["file"], "format": item.get("format") or Path(item["file"]).suffix[1:].lower(),
                     "sha256": item.get("sha256"), "bytes": item.get("bytes")})
             for name, item in inputs.items() if isinstance(item, dict) and "file" in item]
 
@@ -408,6 +579,25 @@ def _bounded_file(path: Path, maximum: int) -> bytes:
     return data
 
 
+def _bounded_file_identity(path: Path, maximum: int) -> tuple[int, str]:
+    if path.is_symlink() or not path.is_file():
+        raise GridlineError("File must be a readable regular file", code="invalid_file")
+    declared_size = path.stat().st_size
+    if declared_size < 1 or declared_size > maximum:
+        raise GridlineError("File exceeds allowed size", code="file_size")
+    size = 0
+    checksum = hashlib.sha256()
+    with path.open("rb") as handle:
+        while chunk := handle.read(65_536):
+            size += len(chunk)
+            if size > maximum:
+                raise GridlineError("File exceeds allowed size", code="file_size")
+            checksum.update(chunk)
+    if size != declared_size:
+        raise GridlineError("File changed while preparing upload", code="input_changed")
+    return size, checksum.hexdigest()
+
+
 def _id(value: Any, label: str) -> str:
     if not isinstance(value, str) or not _ID.fullmatch(value):
         raise GridlineError(f"Invalid {label}", code="remote_contract_invalid")
@@ -426,3 +616,41 @@ def _future(value: Any) -> bool:
         return moment.tzinfo is not None and moment > datetime.now(timezone.utc)
     except ValueError:
         return False
+
+
+def _tus_endpoint(value: Any) -> str:
+    if not isinstance(value, str):
+        raise GridlineError("Invalid TUS endpoint", code="remote_contract_invalid")
+    parsed = urlparse(value)
+    if (parsed.scheme != "https" or not parsed.hostname
+            or not re.fullmatch(r"[a-z0-9-]+\.storage\.supabase\.co", parsed.hostname)
+            or parsed.netloc != parsed.hostname or parsed.path != _TUS_PATH
+            or parsed.query or parsed.fragment):
+        raise GridlineError("Invalid TUS endpoint", code="remote_contract_invalid")
+    return value
+
+
+def _tus_location(endpoint: str, value: Any) -> str:
+    if not isinstance(value, str) or not value or len(value) > 2048 or re.search(r"[\x00-\x1f]", value):
+        raise GridlineError("TUS upload location missing", code="remote_contract_invalid")
+    location = urljoin(endpoint, value)
+    parsed, origin = urlparse(location), urlparse(endpoint)
+    if (parsed.scheme != "https" or parsed.netloc != origin.netloc
+            or parsed.username or parsed.password
+            or not re.fullmatch(r"/storage/v1/upload/resumable/sign/[A-Za-z0-9._~-]{8,2048}", parsed.path)
+            or parsed.query or parsed.fragment):
+        raise GridlineError("TUS upload location escaped storage host", code="remote_contract_invalid")
+    return location
+
+
+def _tus_offset(value: Any, size: int) -> int:
+    if not isinstance(value, str) or not re.fullmatch(r"0|[1-9][0-9]*", value):
+        raise GridlineError("Invalid TUS offset", code="remote_contract_invalid")
+    offset = int(value)
+    if offset > size:
+        raise GridlineError("TUS offset exceeded input size", code="remote_contract_invalid")
+    return offset
+
+
+def _tus_retryable(error: GridlineError) -> bool:
+    return error.code == "network_error" or error.status == 409 or bool(error.status and error.status >= 500)

{gridlinegpu-0.1.3 → gridlinegpu-0.1.4}/src/gridlinegpu.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridlinegpu
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python client for Gridline YAML workload routing
 Author: Gridline GPU
 License: Proprietary
@@ -23,7 +23,7 @@ the `gridline` command in the same Python environment on macOS and Linux.
 ## Install
 
 ```sh
-python -m pip install 'gridlinegpu>=0.1.3,<0.2'
+python -m pip install 'gridlinegpu>=0.1.4,<0.2'
 ```
 
 Run browser setup once. It creates a 30-day scoped token in a private file, attempts to
@@ -36,7 +36,9 @@ gridline setup --apply
 
 Use a YAML file beside its referenced inputs. Task, model, engine, providers, output,
 budget, and deadline belong in YAML rather than Python arguments.
-Current hosted artifact limits are 40 MiB per local input and 8 MiB per output.
+Server-advertised artifact limits govern each submission. Newer Gridline deployments
+use direct, signed resumable Storage uploads for large local inputs; older deployments
+may still cap inputs at 40 MiB and outputs at 8 MiB.
 
 ```python
 from gridlinegpu import GridlineClient
@@ -86,3 +88,22 @@ new key. `outputs()` verifies byte count and SHA-256 before creating private fil
 Cancellation requests stop; cleanup and final provider billing can remain pending.
 For finite jobs, `wait()` returns when outputs are complete, even if cleanup and billing
 leave `outcome` pending. Check `status()` later for final settlement.
+
+When worker progress is enabled on the hosted API/control service and supported by the
+deployed worker image, `status()` also returns optional `progress`:
+
+```python
+status = client.status(job_id)
+progress = status.get("progress")
+if progress:
+    for event in progress["events"]:
+        print(event["stage"], event["observedAt"])
+```
+
+Events are bounded, ordered worker reports for `progress["attemptId"]` and its fence.
+Stages include input staging, model preparation/loading, inference start/completion,
+and output upload. `observedAt` is the server's receipt time. Poll no faster than every
+five seconds; deduplicate by attempt/fence/stage. Missing progress or skipped stages
+mean unavailable evidence, not failure or an inferred stage. Inference completion
+does not imply stored outputs, job success, cleanup, or settled billing. `wait()` keeps
+its existing completion behavior and does not stream progress callbacks.

{gridlinegpu-0.1.3 → gridlinegpu-0.1.4}/tests/test_cli.py

@@ -57,6 +57,15 @@ class CliTest(unittest.TestCase):
         self.assertEqual(client_type.return_value.launch.call_args.kwargs["idempotency_key"], "one")
         self.assertIn('"jobId": "job_1"', self.output.getvalue())
 
+    @patch("gridlinegpu.cli.GridlineClient")
+    def test_plan_warns_when_task_duration_is_customer_declared(self, client_type):
+        planned = MagicMock()
+        planned.review = {"result": {"status": "planned", "quote": {"selected": {
+            "expectedDurationMs": {"source": "customer_declared", "value": 600000}}}}}
+        client_type.return_value.plan.return_value = planned
+        self.assertEqual(self.invoke("workload", "plan", "--file", "workload.yaml"), 0)
+        self.assertIn("not measured GPU-specific performance", self.errors.getvalue())
+
     @patch("gridlinegpu.cli.GridlineClient")
     def test_router_abstention_cannot_launch_even_with_yes(self, client_type):
         planned = MagicMock()

gridlinegpu-0.1.4/tests/test_client.py

@@ -0,0 +1,403 @@
+import hashlib
+import io
+import json
+import os
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from urllib.error import URLError
+from unittest.mock import patch
+
+from gridlinegpu import GridlineClient, GridlineError
+
+
+TOKEN = "gla_" + "a" * 43
+YAML = """name: speech
+task:
+  operation: asr_transcription
+  model: Systran/faster-whisper-large-v3
+inputs:
+  audio: { file: audio.wav, format: wav }
+limits: { maxCostUSD: 5, deadline: 1h }
+"""
+CUSTOM_YAML = """apiVersion: gridline.workload/v1
+kind: Workload
+metadata: { name: pytorch-probe, labels: {} }
+task:
+  kind: custom
+  workloadClass: inference
+  image: pytorch/pytorch@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+  command: [/opt/conda/bin/python, run.py]
+  runtime: { architecture: amd64, internetAccess: required }
+execution: { mode: finite, deadlineSeconds: 3600 }
+inputs:
+  - { name: beta, format: bin, source: { type: package_file, path: beta.bin } }
+  - { name: alpha, format: bin, source: { type: package_file, path: alpha.bin } }
+outputs:
+  - { type: artifact, name: result, format: json, path: result.json, required: true,
+      destination: { type: gridline_artifact } }
+resources:
+  nodeCount: 1
+  accelerators: { minimumCount: 1, maximumCount: 1, minimumVramBytesPerGpu: 1000,
+                  vendors: [nvidia], topology: [single] }
+  minimumCpuCores: 2
+  minimumMemoryBytes: 1000
+  minimumDiskBytes: 1000
+  estimatedDurationSeconds: 60
+  network: {}
+budget: { maximumTotalMicros: 10000000, currency: USD, scope: all_in_cost }
+providers: { mode: include, providers: [runpod] }
+geography: { allowedCountries: [], blockedCountries: [], allowedRegions: [] }
+retry: { maximumAttempts: 1, interruption: forbid, spot: forbid }
+profiling: { allowed: false }
+"""
+
+
+class Response(io.BytesIO):
+    def __init__(self, body=b"", *, status=200, headers=None):
+        super().__init__(body)
+        self.status = status
+        self.headers = headers or {}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()
+
+
+class FakeOpener:
+    def __init__(self):
+        self.calls = []
+        self.changed = False
+        self.output_body = b"{}"
+        self.upload_required = False
+        self.uploaded = b""
+        self.upload_mode = "put"
+        self.tus_location = "https://fixture.storage.supabase.co/storage/v1/upload/resumable/sign/session-1"
+        self.tus_location_header = None
+        self.tus_fail_patch_once = False
+        self.tus_fail_final_reply_and_head = False
+        self.tus_patches = []
+        self.maximum_attachment_bytes = 1024
+        self.required_attachments = ["audio"]
+        self.job = {"jobId": "job_1", "outcome": "succeeded"}
+        self.expiry = (datetime.now(timezone.utc) + timedelta(minutes=2)).isoformat()
+
+    def open(self, request, timeout):
+        path = request.full_url.removeprefix("https://gridlinegpu.com")
+        self.calls.append((request.get_method(), path, request.headers, request.data))
+        if path == "/api/workloads/yaml/validate":
+            result = {"schemaVersion": 1, "requiredAttachments": self.required_attachments}
+        elif path == "/api/workloads/yaml/availability":
+            result = {"schemaVersion": 1, "planningAvailable": True, "executionEnabled": True,
+                      "artifactStagingAvailable": True,
+                      "maximumAttachmentBytes": self.maximum_attachment_bytes}
+        elif path == "/api/workloads/yaml/attachments":
+            requested = json.loads(request.data)
+            upload = ({"method": "TUS",
+                       "url": "https://fixture.storage.supabase.co/storage/v1/upload/resumable/sign",
+                       "headers": {"x-signature": "signed-fixture-token"},
+                       "metadata": {"bucketName": "private-input", "objectName": "runs/input_1",
+                                    "contentType": "application/octet-stream"},
+                       "chunkBytes": 6 * 1024 * 1024, "expiresAt": self.expiry}
+                      if self.upload_mode == "tus" else
+                      {"method": "PUT", "url": "https://storage.example/input",
+                       "headers": {"Authorization": "fixture-upload-grant"}})
+            result = {"artifactId": "input_" + requested["sha256"][:12],
+                      "sha256": requested["sha256"], "byteLength": requested["byteLength"],
+                      "format": requested["format"],
+                      "state": "reserved" if self.upload_required else "ready",
+                      "upload": upload}
+        elif path == "https://storage.example/input":
+            self.uploaded = b"".join(request.data)
+            return Response(b"")
+        elif path == "https://fixture.storage.supabase.co/storage/v1/upload/resumable/sign":
+            return Response(status=201, headers={"Location": self.tus_location_header or self.tus_location})
+        elif path == self.tus_location:
+            if request.get_method() == "HEAD":
+                if self.tus_fail_final_reply_and_head and len(self.uploaded) == self.tus_length:
+                    raise URLError("status unavailable after committed final chunk")
+                return Response(headers={"Upload-Offset": str(len(self.uploaded)),
+                                         "Upload-Length": str(self.tus_length)})
+            if request.get_method() != "PATCH":
+                raise AssertionError(f"Unexpected TUS method: {request.get_method()}")
+            offset = next(value for key, value in request.headers.items()
+                          if key.lower() == "upload-offset")
+            if int(offset) != len(self.uploaded):
+                raise AssertionError("Wrong TUS offset")
+            self.uploaded += request.data
+            self.tus_patches.append(len(request.data))
+            if self.tus_fail_patch_once:
+                self.tus_fail_patch_once = False
+                raise URLError("lost response after storage accepted chunk")
+            if self.tus_fail_final_reply_and_head and len(self.uploaded) == self.tus_length:
+                raise URLError("final reply lost after commit")
+            return Response(status=204, headers={"Upload-Offset": str(len(self.uploaded))})
+        elif path.startswith("/api/workloads/yaml/attachments/") and path.endswith("/confirm"):
+            result = {"state": "ready", "artifactId": path.split("/")[-2],
+                      "sha256": hashlib.sha256(self.uploaded).hexdigest(),
+                      "byteLength": len(self.uploaded)}
+        elif path == "/api/workloads/yaml/submit":
+            result = {"workloadId": "yaml_1", "workloadHash": "b" * 64}
+        elif path == "/api/workloads/yaml/yaml_1/plan":
+            result = {"workloadId": "yaml_1", "workloadHash": "b" * 64,
+                      "result": {"status": "planned", "planHash": "x" * 64 if self.changed else "c" * 64,
+                                 "quote": {"quoteId": "quote_1", "quoteHash": "d" * 64,
+                                           "expiresAt": self.expiry, "maximumTotalMicros": 5_000_000,
+                                           "fallbackConsent": {"mode": "none"}}}}
+        elif path == "/api/workloads/yaml/yaml_1/launch":
+            result = {"workloadId": "yaml_1", "planHash": "c" * 64, "jobId": "job_1"}
+        elif path == "/api/workloads/yaml/jobs/job_1":
+            result = {"job": self.job}
+        elif path == "/api/workloads/yaml/jobs/job_1/output":
+            result = {"jobId": "job_1", "state": "available", "manifest": {"outputs": [{
+                "name": "result.json", "artifactId": "output_1", "sha256": self.output_digest,
+                "bytes": getattr(self, "declared_output_bytes", len(self.output_body)),
+                "completed": True}], "missingRequiredOutputs": []}}
+        elif path == "/api/workloads/yaml/jobs/job_1/output/output_1/grant":
+            result = {"jobId": "job_1", "artifactId": "output_1", "sha256": self.output_digest,
+                      "byteLength": getattr(self, "declared_output_bytes", len(self.output_body)),
+                      "download": {"url": "https://storage.example/result",
+                          "expiresAt": self.expiry}}
+        elif path == "https://storage.example/result":
+            return Response(self.output_body)
+        else:
+            raise AssertionError(f"Unexpected request: {path}")
+        return Response(json.dumps(result).encode())
+
+
+class ClientTest(unittest.TestCase):
+    def setUp(self):
+        self.folder = tempfile.TemporaryDirectory()
+        self.addCleanup(self.folder.cleanup)
+        root = Path(self.folder.name)
+        (root / "workload.yaml").write_text(YAML)
+        (root / "audio.wav").write_bytes(b"RIFF")
+        self.path = root / "workload.yaml"
+        self.opener = FakeOpener()
+        self.opener.output_digest = hashlib.sha256(b"{}").hexdigest()
+        self.client = GridlineClient(token=TOKEN, opener=self.opener)
+
+    def test_plan_launch_and_verified_download(self):
+        plan = self.client.plan(self.path)
+        self.assertEqual(plan.workload_id, "yaml_1")
+        self.assertFalse(any(path.endswith("/launch") for _, path, _, _ in self.opener.calls))
+        launched = self.client.launch(plan, max_cost_usd="5", idempotency_key="test-job-1")
+        self.assertEqual(launched["jobId"], "job_1")
+        self.assertEqual(self.client.wait("job_1", timeout=1)["job"]["outcome"], "succeeded")
+        saved = self.client.outputs("job_1", Path(self.folder.name) / "results")
+        self.assertEqual(Path(saved["downloaded"][0]["path"]).read_bytes(), b"{}")
+        self.assertRaises(FileExistsError, self.client.outputs, "job_1", Path(self.folder.name) / "results")
+
+    def test_minimal_file_extension_supplies_omitted_upload_format(self):
+        (Path(self.folder.name) / "talk.OGG").write_bytes(b"OggS")
+        self.path.write_text("""task:
+  operation: asr_transcription
+  model: Systran/faster-whisper-large-v3
+inputs:
+  audio: { file: talk.OGG }
+limits: { maxCostUSD: 5 }
+""")
+        self.client.plan(self.path)
+        grants = [json.loads(body) for method, path, _, body in self.opener.calls
+                  if method == "POST" and path.endswith("/attachments")]
+        self.assertEqual(grants[0]["format"], "ogg")
+        self.assertFalse(any(path.endswith("/launch") for _, path, _, _ in self.opener.calls))
+
+    def test_minimal_explicit_format_overrides_filename_extension(self):
+        (Path(self.folder.name) / "audio.data").write_bytes(b"RIFF")
+        self.path.write_text(YAML.replace("audio.wav", "audio.data"))
+        self.client.plan(self.path)
+        grant = next(json.loads(body) for method, path, _, body in self.opener.calls
+                     if method == "POST" and path.endswith("/attachments"))
+        self.assertEqual(grant["format"], "wav")
+
+    def test_output_download_rejects_oversize_without_partial_file(self):
+        self.opener.output_body = b"unexpected"
+        self.opener.declared_output_bytes = 2
+        directory = Path(self.folder.name) / "results"
+        with self.assertRaises(GridlineError) as raised:
+            self.client.outputs("job_1", directory)
+        self.assertEqual(raised.exception.code, "output_hash_mismatch")
+        self.assertEqual(list(directory.iterdir()), [])
+
+    def test_output_download_rejects_same_length_digest_mismatch(self):
+        self.opener.output_body = b"[]"
+        directory = Path(self.folder.name) / "results"
+        with self.assertRaises(GridlineError) as raised:
+            self.client.outputs("job_1", directory)
+        self.assertEqual(raised.exception.code, "output_hash_mismatch")
+        self.assertEqual(list(directory.iterdir()), [])
+
+    def test_output_download_streams_beyond_legacy_eight_mib(self):
+        self.opener.output_body = b"x" * (8 * 1024 * 1024 + 1)
+        self.opener.output_digest = hashlib.sha256(self.opener.output_body).hexdigest()
+        directory = Path(self.folder.name) / "results"
+        saved = self.client.outputs("job_1", directory)
+        self.assertEqual(Path(saved["downloaded"][0]["path"]).stat().st_size,
+                         len(self.opener.output_body))
+
+    def test_input_upload_streams_and_confirms_exact_file(self):
+        self.opener.upload_required = True
+        planned = self.client.plan(self.path)
+        self.assertIsNotNone(planned.quote)
+        self.assertEqual(self.opener.uploaded, b"RIFF")
+        upload = next(call for call in self.opener.calls if call[1] == "https://storage.example/input")
+        self.assertEqual(next(value for key, value in upload[2].items()
+                              if key.lower() == "content-length"), "4")
+
+    def test_input_limit_follows_server_advertisement(self):
+        self.opener.maximum_attachment_bytes = 64 * 1024 * 1024
+        digest = hashlib.sha256(b"RIFF").hexdigest()
+        with patch("gridlinegpu.client._bounded_file_identity", return_value=(4, digest)) as identity:
+            self.client.plan(self.path)
+        identity.assert_called_once_with(Path(self.folder.name) / "audio.wav",
+                                         self.opener.maximum_attachment_bytes)
+
+    def test_signed_tus_upload_streams_fixed_chunks_and_recovers_lost_patch_reply(self):
+        payload = b"x" * (6 * 1024 * 1024) + b"tail"
+        (Path(self.folder.name) / "audio.wav").write_bytes(payload)
+        self.opener.maximum_attachment_bytes = 8 * 1024 * 1024
+        self.opener.upload_required = True
+        self.opener.upload_mode = "tus"
+        self.opener.tus_length = len(payload)
+        self.opener.tus_fail_patch_once = True
+        self.opener.tus_location_header = "sign/session-1"
+
+        plan = self.client.plan(self.path)
+
+        self.assertIsNotNone(plan.quote)
+        self.assertEqual(self.opener.uploaded, payload)
+        self.assertEqual(self.opener.tus_patches, [6 * 1024 * 1024, 4])
+        tus_calls = [call for call in self.opener.calls if "upload/resumable" in call[1]]
+        self.assertEqual([call[0] for call in tus_calls], ["POST", "PATCH", "HEAD", "PATCH"])
+        for _, _, headers, _ in tus_calls:
+            self.assertTrue(any(key.lower() == "x-signature" for key in headers))
+            self.assertFalse(any(key.lower() == "authorization" for key in headers))
+
+    def test_signed_tus_confirms_committed_object_after_final_reply_and_status_are_lost(self):
+        payload = b"x" * 1024
+        (Path(self.folder.name) / "audio.wav").write_bytes(payload)
+        self.opener.maximum_attachment_bytes = 8 * 1024 * 1024
+        self.opener.upload_required = True
+        self.opener.upload_mode = "tus"
+        self.opener.tus_length = len(payload)
+        self.opener.tus_fail_final_reply_and_head = True
+
+        plan = self.client.plan(self.path)
+
+        self.assertIsNotNone(plan.quote)
+        self.assertEqual(self.opener.uploaded, payload)
+        self.assertEqual(len([call for call in self.opener.calls if call[1].endswith("/confirm")]), 1)
+
+    def test_signed_tus_rejects_escaped_upload_locations(self):
+        self.opener.upload_required = True
+        self.opener.upload_mode = "tus"
+        for location in (
+            "https://attacker.example/storage/v1/upload/resumable/session-1",
+            "https://user@fixture.storage.supabase.co/storage/v1/upload/resumable/sign/session-1",
+            "https://fixture.storage.supabase.co/storage/v1/upload/resumable/session-1",
+            "/storage/v1/upload/resumable/session-1?token=leak",
+            "/storage/v1/upload/resumable/session-1#fragment",
+            "/storage/v1/upload/resumable/short",
+            "/storage/v1/upload/resumable/session-1/extra",
+        ):
+            self.opener.tus_location = location
+            with self.assertRaises(GridlineError) as raised:
+                self.client.plan(self.path)
+            self.assertEqual(raised.exception.code, "remote_contract_invalid")
+            self.assertFalse(any(call[1] == location for call in self.opener.calls))
+
+    def test_invalid_advertised_attachment_limit_fails_before_reservation(self):
+        for value in (True, 512 * 1024 * 1024 + 1):
+            self.opener.maximum_attachment_bytes = value
+            with self.assertRaises(GridlineError) as raised:
+                self.client.plan(self.path)
+            self.assertEqual(raised.exception.code, "remote_contract_invalid")
+        self.assertFalse(any(path.endswith("/attachments") for _, path, _, _ in self.opener.calls))
+
+    def test_plan_stages_out_of_order_package_files_by_logical_name(self):
+        self.path.write_text(CUSTOM_YAML)
+        root = Path(self.folder.name)
+        (root / "beta.bin").write_bytes(b"BBBB")
+        (root / "alpha.bin").write_bytes(b"AAAA")
+        self.opener.required_attachments = ["alpha", "beta"]
+
+        self.client.plan(self.path)
+
+        submitted = next(json.loads(body) for _, path, _, body in self.opener.calls
+                         if path.endswith("/submit"))
+        bindings = {item["logicalName"]: item for item in submitted["attachmentBindings"]}
+        self.assertEqual(set(bindings), {"alpha", "beta"})
+        for name, contents in (("alpha", b"AAAA"), ("beta", b"BBBB")):
+            self.assertEqual(bindings[name]["sha256"], hashlib.sha256(contents).hexdigest())
+            self.assertEqual(bindings[name]["bytes"], len(contents))
+            self.assertEqual(bindings[name]["artifactId"],
+                             "input_" + hashlib.sha256(contents).hexdigest()[:12])
+
+    def test_plan_rejects_duplicate_server_attachment_names_before_staging(self):
+        self.opener.required_attachments = ["audio", "audio"]
+        with self.assertRaisesRegex(GridlineError, "Input names differ"):
+            self.client.plan(self.path)
+        self.assertFalse(any(path.endswith("/attachments") for _, path, _, _ in self.opener.calls))
+
+    def test_changed_plan_cannot_launch(self):
+        plan = self.client.plan(self.path)
+        self.opener.changed = True
+        with self.assertRaisesRegex(GridlineError, "changed"):
+            self.client.launch(plan, max_cost_usd="5", idempotency_key="same-key")
+        self.assertFalse(any(path.endswith("/launch") for _, path, _, _ in self.opener.calls))
+
+    def test_identical_yaml_creates_fresh_submission_unless_retry_key_is_explicit(self):
+        for _ in range(2):
+            self.client.plan(self.path)
+        keys = [next(value for name, value in headers.items() if name.lower() == "idempotency-key")
+                for _, path, headers, _ in self.opener.calls
+                if path.endswith("/submit")]
+        self.assertEqual(len(keys), 2)
+        self.assertNotEqual(keys[0], keys[1])
+        self.client.plan(self.path, submission_key="retry-this-submit")
+        self.client.plan(self.path, submission_key="retry-this-submit")
+        keys = [next(value for name, value in headers.items() if name.lower() == "idempotency-key")
+                for _, path, headers, _ in self.opener.calls
+                if path.endswith("/submit")]
+        self.assertEqual(keys[-2:], ["retry-this-submit", "retry-this-submit"])
+
+    def test_cost_ceiling_and_yaml_change_cannot_launch(self):
+        plan = self.client.plan(self.path)
+        with self.assertRaisesRegex(GridlineError, "ceiling"):
+            self.client.launch(plan, max_cost_usd="4.99", idempotency_key="same-key")
+        self.path.write_text(YAML + "# changed\n")
+        with self.assertRaisesRegex(GridlineError, "changed"):
+            self.client.launch(plan, max_cost_usd="5", idempotency_key="same-key")
+
+    def test_requests_identify_sdk_to_production_edge(self):
+        self.client.availability()
+        headers = self.opener.calls[-1][2]
+        self.assertEqual(next(value for name, value in headers.items() if name.lower() == "user-agent"),
+                         "GridlinePythonSDK/1")
+
+    def test_uses_private_token_created_by_pip_installed_cli(self):
+        token_file = Path(self.folder.name) / ".config" / "gridline" / "python-token"
+        token_file.parent.mkdir(parents=True)
+        token_file.write_text(TOKEN + "\n")
+        token_file.chmod(0o600)
+        with patch.dict(os.environ, {"GRIDLINE_API_TOKEN_FILE": "", "GRIDLINE_API_TOKEN": ""}):
+            with patch.object(Path, "home", return_value=Path(self.folder.name)):
+                client = GridlineClient(opener=self.opener)
+                self.assertEqual(client._read_token(), TOKEN)
+
+    def test_wait_returns_when_finite_outputs_are_complete_before_billing(self):
+        self.opener.job = {"jobId": "job_1", "outcome": "pending", "execution": {"mode": "finite"},
+                           "outputs": "complete", "cleanup": "pending", "billing": "pending"}
+        result = self.client.wait("job_1", timeout=1)
+        self.assertEqual(result["job"]["outcome"], "pending")
+        self.assertEqual(result["job"]["outputs"], "complete")
+        self.assertEqual(self.client.outputs("job_1", Path(self.folder.name) / "results")["state"],
+                         "available")
+
+
+if __name__ == "__main__":
+    unittest.main()

gridlinegpu-0.1.3/tests/test_client.py

@@ -1,159 +0,0 @@
-import io
-import json
-import os
-import tempfile
-import unittest
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from unittest.mock import patch
-
-from gridlinegpu import GridlineClient, GridlineError
-
-
-TOKEN = "gla_" + "a" * 43
-YAML = """name: speech
-task:
-  operation: asr_transcription
-  model: Systran/faster-whisper-large-v3
-inputs:
-  audio: { file: audio.wav, format: wav }
-limits: { maxCostUSD: 5, deadline: 1h }
-"""
-
-
-class Response(io.BytesIO):
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *_):
-        self.close()
-
-
-class FakeOpener:
-    def __init__(self):
-        self.calls = []
-        self.changed = False
-        self.job = {"jobId": "job_1", "outcome": "succeeded"}
-        self.expiry = (datetime.now(timezone.utc) + timedelta(minutes=2)).isoformat()
-
-    def open(self, request, timeout):
-        path = request.full_url.removeprefix("https://gridlinegpu.com")
-        self.calls.append((request.get_method(), path, request.headers, request.data))
-        if path == "/api/workloads/yaml/validate":
-            result = {"schemaVersion": 1, "requiredAttachments": ["audio"]}
-        elif path == "/api/workloads/yaml/availability":
-            result = {"schemaVersion": 1, "planningAvailable": True, "executionEnabled": True,
-                      "artifactStagingAvailable": True, "maximumAttachmentBytes": 1024}
-        elif path == "/api/workloads/yaml/attachments":
-            result = {"artifactId": "input_1", "sha256": self.digest, "byteLength": 4,
-                      "format": "wav", "state": "ready"}
-        elif path == "/api/workloads/yaml/submit":
-            result = {"workloadId": "yaml_1", "workloadHash": "b" * 64}
-        elif path == "/api/workloads/yaml/yaml_1/plan":
-            result = {"workloadId": "yaml_1", "workloadHash": "b" * 64,
-                      "result": {"status": "planned", "planHash": "x" * 64 if self.changed else "c" * 64,
-                                 "quote": {"quoteId": "quote_1", "quoteHash": "d" * 64,
-                                           "expiresAt": self.expiry, "maximumTotalMicros": 5_000_000,
-                                           "fallbackConsent": {"mode": "none"}}}}
-        elif path == "/api/workloads/yaml/yaml_1/launch":
-            result = {"workloadId": "yaml_1", "planHash": "c" * 64, "jobId": "job_1"}
-        elif path == "/api/workloads/yaml/jobs/job_1":
-            result = {"job": self.job}
-        elif path == "/api/workloads/yaml/jobs/job_1/output":
-            result = {"jobId": "job_1", "state": "available", "manifest": {"outputs": [{
-                "name": "result.json", "artifactId": "output_1", "sha256": self.output_digest,
-                "bytes": 2, "completed": True}], "missingRequiredOutputs": []}}
-        elif path == "/api/workloads/yaml/jobs/job_1/output/output_1/grant":
-            result = {"jobId": "job_1", "artifactId": "output_1", "sha256": self.output_digest,
-                      "byteLength": 2, "download": {"url": "https://storage.example/result",
-                          "expiresAt": self.expiry}}
-        elif path == "https://storage.example/result":
-            return Response(b"{}")
-        else:
-            raise AssertionError(f"Unexpected request: {path}")
-        return Response(json.dumps(result).encode())
-
-
-class ClientTest(unittest.TestCase):
-    def setUp(self):
-        import hashlib
-        self.folder = tempfile.TemporaryDirectory()
-        self.addCleanup(self.folder.cleanup)
-        root = Path(self.folder.name)
-        (root / "workload.yaml").write_text(YAML)
-        (root / "audio.wav").write_bytes(b"RIFF")
-        self.path = root / "workload.yaml"
-        self.opener = FakeOpener()
-        self.opener.digest = hashlib.sha256(b"RIFF").hexdigest()
-        self.opener.output_digest = hashlib.sha256(b"{}").hexdigest()
-        self.client = GridlineClient(token=TOKEN, opener=self.opener)
-
-    def test_plan_launch_and_verified_download(self):
-        plan = self.client.plan(self.path)
-        self.assertEqual(plan.workload_id, "yaml_1")
-        self.assertFalse(any(path.endswith("/launch") for _, path, _, _ in self.opener.calls))
-        launched = self.client.launch(plan, max_cost_usd="5", idempotency_key="test-job-1")
-        self.assertEqual(launched["jobId"], "job_1")
-        self.assertEqual(self.client.wait("job_1", timeout=1)["job"]["outcome"], "succeeded")
-        saved = self.client.outputs("job_1", Path(self.folder.name) / "results")
-        self.assertEqual(Path(saved["downloaded"][0]["path"]).read_bytes(), b"{}")
-        self.assertRaises(FileExistsError, self.client.outputs, "job_1", Path(self.folder.name) / "results")
-
-    def test_changed_plan_cannot_launch(self):
-        plan = self.client.plan(self.path)
-        self.opener.changed = True
-        with self.assertRaisesRegex(GridlineError, "changed"):
-            self.client.launch(plan, max_cost_usd="5", idempotency_key="same-key")
-        self.assertFalse(any(path.endswith("/launch") for _, path, _, _ in self.opener.calls))
-
-    def test_identical_yaml_creates_fresh_submission_unless_retry_key_is_explicit(self):
-        for _ in range(2):
-            self.client.plan(self.path)
-        keys = [next(value for name, value in headers.items() if name.lower() == "idempotency-key")
-                for _, path, headers, _ in self.opener.calls
-                if path.endswith("/submit")]
-        self.assertEqual(len(keys), 2)
-        self.assertNotEqual(keys[0], keys[1])
-        self.client.plan(self.path, submission_key="retry-this-submit")
-        self.client.plan(self.path, submission_key="retry-this-submit")
-        keys = [next(value for name, value in headers.items() if name.lower() == "idempotency-key")
-                for _, path, headers, _ in self.opener.calls
-                if path.endswith("/submit")]
-        self.assertEqual(keys[-2:], ["retry-this-submit", "retry-this-submit"])
-
-    def test_cost_ceiling_and_yaml_change_cannot_launch(self):
-        plan = self.client.plan(self.path)
-        with self.assertRaisesRegex(GridlineError, "ceiling"):
-            self.client.launch(plan, max_cost_usd="4.99", idempotency_key="same-key")
-        self.path.write_text(YAML + "# changed\n")
-        with self.assertRaisesRegex(GridlineError, "changed"):
-            self.client.launch(plan, max_cost_usd="5", idempotency_key="same-key")
-
-    def test_requests_identify_sdk_to_production_edge(self):
-        self.client.availability()
-        headers = self.opener.calls[-1][2]
-        self.assertEqual(next(value for name, value in headers.items() if name.lower() == "user-agent"),
-                         "GridlinePythonSDK/1")
-
-    def test_uses_private_token_created_by_pip_installed_cli(self):
-        token_file = Path(self.folder.name) / ".config" / "gridline" / "python-token"
-        token_file.parent.mkdir(parents=True)
-        token_file.write_text(TOKEN + "\n")
-        token_file.chmod(0o600)
-        with patch.dict(os.environ, {"GRIDLINE_API_TOKEN_FILE": "", "GRIDLINE_API_TOKEN": ""}):
-            with patch.object(Path, "home", return_value=Path(self.folder.name)):
-                client = GridlineClient(opener=self.opener)
-                self.assertEqual(client._read_token(), TOKEN)
-
-    def test_wait_returns_when_finite_outputs_are_complete_before_billing(self):
-        self.opener.job = {"jobId": "job_1", "outcome": "pending", "execution": {"mode": "finite"},
-                           "outputs": "complete", "cleanup": "pending", "billing": "pending"}
-        result = self.client.wait("job_1", timeout=1)
-        self.assertEqual(result["job"]["outcome"], "pending")
-        self.assertEqual(result["job"]["outputs"], "complete")
-        self.assertEqual(self.client.outputs("job_1", Path(self.folder.name) / "results")["state"],
-                         "available")
-
-
-if __name__ == "__main__":
-    unittest.main()