tensorplate-python 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

tensorplate/__init__.py

@@ -16,7 +16,7 @@ from tensorplate.client import (
     canonicalize_serving_url,
     resolve_serving_url,
 )
-from tensorplate.conventions import YOLO_V8_SINGLE_OUTPUT, detections
+from tensorplate.conventions import YOLO26_E2E_DETECTIONS, YOLO_V8_SINGLE_OUTPUT, detections
 from tensorplate.errors import (
     EndpointResolutionError,
     ErrorCode,
@@ -29,7 +29,7 @@ from tensorplate.errors import (
 )
 from tensorplate.postprocess import Detection, decode_detections
 from tensorplate.preprocess import LetterboxTransform, PreprocessConfig, preprocess
-from tensorplate.serving import HealthSnapshot, InferResult, ServingClient, Timing
+from tensorplate.serving import ClientTiming, HealthSnapshot, InferResult, ServingClient, Timing
 from tensorplate.tensors import DType, Layout, TensorInput, TensorOutput
 from tensorplate.vision import VisionClient
 
@@ -40,7 +40,9 @@ except PackageNotFoundError:  # pragma: no cover - only hit outside an installed
 
 __all__ = [
     "LOOPBACK_DEFAULT",
+    "YOLO26_E2E_DETECTIONS",
     "YOLO_V8_SINGLE_OUTPUT",
+    "ClientTiming",
     "DType",
     "Detection",
     "EndpointResolutionError",

tensorplate/client.py

@@ -104,8 +104,9 @@ def http_request(
     :class:`RequestTimeoutError`.
     """
     request = urllib.request.Request(url, data=body, method=method)
-    request.add_header("Accept", "application/json")
-    if body is not None:
+    normalized_headers = {key.lower(): value for key, value in (headers or {}).items()}
+    request.add_header("Accept", normalized_headers.get("accept", "application/json"))
+    if body is not None and "content-type" not in normalized_headers:
         request.add_header("Content-Type", "application/json")
     for key, value in (headers or {}).items():
         request.add_header(key, value)

tensorplate/conventions.py

@@ -21,9 +21,15 @@ class detections:
     classes = "detections.classes"
 
 
-#: Supported built-in detector output contract: a single tensor shaped
+#: Supported built-in YOLOv8-style detector output contract: a single tensor shaped
 #: ``[1, 4 + C, N]`` (YOLOv8-style; 4 box coords + C class scores over N
 #: anchors), or its transpose ``[1, N, 4 + C]`` when the caller declares
 #: it. Other heads (YOLOv5 objectness, exporter-side NMS, masks,
 #: keypoints) remain application-side postprocessing in v0.1.3.
 YOLO_V8_SINGLE_OUTPUT = "yolo_v8_single_output"
+
+#: Supported built-in YOLO26 default one-to-one / end-to-end detector output
+#: contract: a single NMS-free tensor shaped ``[1, K, 6]`` with
+#: ``K <= 300`` and columns ``x1, y1, x2, y2, score, class_id`` in
+#: letterboxed model-input pixels.
+YOLO26_E2E_DETECTIONS = "yolo26_e2e_detections"

tensorplate/postprocess.py

@@ -7,13 +7,14 @@ lazily.
 
 from __future__ import annotations
 
+import math
 from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from tensorplate.conventions import YOLO_V8_SINGLE_OUTPUT
+from tensorplate.conventions import YOLO26_E2E_DETECTIONS, YOLO_V8_SINGLE_OUTPUT
 from tensorplate.errors import ProtocolError
-from tensorplate.tensors import TensorOutput
+from tensorplate.tensors import DType, TensorOutput
 
 if TYPE_CHECKING:
     import numpy as np
@@ -41,16 +42,22 @@ def decode_detections(
     transposed: bool = False,
     contract: str = YOLO_V8_SINGLE_OUTPUT,
 ) -> list[Detection]:
-    """Decode a YOLOv8-style single-output tensor into source-pixel detections.
+    """Decode a supported YOLO-style output tensor into source-pixel detections.
 
-    Expects ``[1, 4 + C, N]`` (or ``[1, N, 4 + C]`` when ``transposed``): 4
-    box coordinates (center-x, center-y, width, height in model-input
-    pixels) followed by C per-class scores. Applies score thresholding and
-    class-aware NMS, then maps boxes back to source pixels via ``transform``.
+    ``yolo_v8_single_output`` expects ``[1, 4 + C, N]`` (or
+    ``[1, N, 4 + C]`` when ``transposed``): 4 center-format box coordinates
+    followed by C per-class scores. It applies score thresholding and
+    class-aware NMS.
+
+    ``yolo26_e2e_detections`` expects NMS-free ``[1, K, 6]`` with columns
+    x1, y1, x2, y2, score, class_id. It applies only score thresholding.
     """
+    if contract == YOLO26_E2E_DETECTIONS:
+        return _decode_yolo26_e2e(output, transform, score_threshold=score_threshold, labels=labels)
     if contract != YOLO_V8_SINGLE_OUTPUT:
         raise ValueError(
-            f"unsupported output contract {contract!r}; only {YOLO_V8_SINGLE_OUTPUT!r} is built in"
+            f"unsupported output contract {contract!r}; supported contracts are "
+            f"{YOLO_V8_SINGLE_OUTPUT!r} and {YOLO26_E2E_DETECTIONS!r}"
         )
     import numpy as np
 
@@ -99,6 +106,56 @@ def decode_detections(
     return detections
 
 
+def _decode_yolo26_e2e(
+    output: TensorOutput,
+    transform: LetterboxTransform,
+    *,
+    score_threshold: float,
+    labels: Sequence[str] | None,
+) -> list[Detection]:
+    if output.dtype not in (DType.FLOAT16, DType.FLOAT32):
+        raise ProtocolError(
+            f"detector output for {YOLO26_E2E_DETECTIONS!r} must be float16 or float32, "
+            f"got {output.dtype.value!r}"
+        )
+    try:
+        array = output.to_numpy().astype("float32")
+    except (RuntimeError, ValueError) as exc:
+        raise ProtocolError(
+            f"could not convert detector output for {YOLO26_E2E_DETECTIONS!r} to float32"
+        ) from exc
+    if array.ndim != 3 or array.shape[0] != 1 or array.shape[2] != 6:
+        raise ProtocolError(
+            f"detector output must be [1, K, 6] for {YOLO26_E2E_DETECTIONS!r}, "
+            f"got shape {tuple(array.shape)}"
+        )
+    if array.shape[1] > 300:
+        raise ProtocolError(
+            f"detector output has {int(array.shape[1])} rows for {YOLO26_E2E_DETECTIONS!r}; "
+            "expected K <= 300"
+        )
+
+    detections: list[Detection] = []
+    for row in array[0]:
+        score = float(row[4])
+        # Skip non-finite scores (NaN never compares >= threshold and would
+        # otherwise fall through to int(row[5]) and raise on a NaN class id).
+        if not math.isfinite(score) or score < score_threshold:
+            continue
+        class_value = float(row[5])
+        # A real YOLO26 head never emits a negative or non-finite class id;
+        # drop such rows rather than store a nonsensical Detection.class_id.
+        if not math.isfinite(class_value) or class_value < 0:
+            continue
+        class_id = int(class_value)
+        box = transform.map_box_to_source(
+            float(row[0]), float(row[1]), float(row[2]), float(row[3])
+        )
+        label = labels[class_id] if labels is not None and class_id < len(labels) else None
+        detections.append(Detection(class_id=class_id, score=score, box=box, label=label))
+    return detections
+
+
 def _looks_like_wrong_layout(array: np.ndarray, transposed: bool) -> bool:
     """Return true for the common unambiguous YOLO transpose mismatch."""
     rows = int(array.shape[1])

tensorplate/serving.py

@@ -3,9 +3,13 @@
 from __future__ import annotations
 
 import json
+import math
+import struct
+import time
 import uuid
 from collections.abc import Sequence
 from dataclasses import dataclass
+from typing import Literal
 
 from tensorplate.client import (
     DEFAULT_TIMEOUT_S,
@@ -19,12 +23,16 @@ from tensorplate.errors import (
     ServingError,
     UnsupportedSchemaVersionError,
 )
-from tensorplate.tensors import DType, Layout, TensorInput, TensorOutput
+from tensorplate.tensors import DType, Layout, TensorInput, TensorOutput, itemsize
 
 #: Serving envelope schema_version this SDK speaks.
 SCHEMA_VERSION = "0.1"
 
 _HEALTH_PATH = "/health"
+_BINARY_CONTENT_TYPE = "application/vnd.tensorplate.infer.binary.v1"
+_BINARY_INFER_MAGIC = b"TPINFER1"
+_BINARY_RESULT_MAGIC = b"TPRESULT1"
+TransportPreference = Literal["auto", "binary", "json"]
 
 
 @dataclass(frozen=True)
@@ -36,6 +44,17 @@ class Timing:
     total_latency_ns: int | None = None
 
 
+@dataclass(frozen=True)
+class ClientTiming:
+    """Optional SDK-side timing for request encode, transport, and decode."""
+
+    encode_ns: int
+    http_roundtrip_ns: int
+    decode_ns: int
+    request_bytes: int
+    response_bytes: int
+
+
 @dataclass(frozen=True)
 class InferResult:
     """Parsed v0.1 ``success`` response."""
@@ -44,6 +63,8 @@ class InferResult:
     outputs: tuple[TensorOutput, ...]
     correlation_id: str | None = None
     timing: Timing | None = None
+    transport: str = "json"
+    client_timing: ClientTiming | None = None
 
     def output(self, name: str) -> TensorOutput:
         """Return the output tensor named ``name`` or raise ``KeyError``."""
@@ -89,7 +110,10 @@ class ServingClient:
         config_path: str | None = None,
         timeout: float = DEFAULT_TIMEOUT_S,
         discover: bool = True,
+        preferred_transport: TransportPreference = "auto",
     ) -> None:
+        if preferred_transport not in ("auto", "binary", "json"):
+            raise ValueError("preferred_transport must be 'auto', 'binary', or 'json'")
         self._endpoint = resolve_serving_url(
             serving_url,
             profile=profile,
@@ -98,6 +122,8 @@ class ServingClient:
             discover=discover,
         )
         self._timeout = timeout
+        self._preferred_transport: TransportPreference = preferred_transport
+        self._binary_supported: bool | None = None
 
     @property
     def endpoint(self) -> ResolvedEndpoint:
@@ -129,6 +155,7 @@ class ServingClient:
         *,
         deadline_ms: int | None = None,
         correlation_id: str | None = None,
+        profile: bool = False,
     ) -> InferResult:
         """Run a single synchronous inference against ``endpoint``.
 
@@ -150,23 +177,118 @@ class ServingClient:
         if correlation_id is not None and not correlation_id:
             raise ValueError("correlation_id must be non-empty when provided")
         request_id = str(uuid.uuid4())
-        request_body: dict[str, object] = {
-            "schema_version": SCHEMA_VERSION,
-            "request_id": request_id,
-            "endpoint": endpoint,
-            "inputs": [tensor.to_named_input() for tensor in inputs],
-        }
-        if deadline_ms is not None:
-            request_body["deadline_ms"] = deadline_ms
-        headers: dict[str, str] = {}
-        if correlation_id is not None:
-            request_body["metadata"] = {"correlation_id": correlation_id}
-            headers["X-Correlation-Id"] = correlation_id
-        payload = json.dumps(request_body).encode("utf-8")
+        if self._should_try_binary():
+            status_code, raw, timing = self._infer_http(
+                "binary",
+                request_id,
+                endpoint,
+                inputs,
+                deadline_ms=deadline_ms,
+                correlation_id=correlation_id,
+                profile=profile,
+            )
+            if status_code == 415 and _is_binary_unsupported(raw):
+                if self._preferred_transport == "binary":
+                    return _parse_infer_response(
+                        raw, status_code, self._endpoint.url, "binary", timing
+                    )
+                # In 'auto' mode a 415 'unsupported' is ambiguous: the worker may
+                # lack the binary transport, or the request itself may be
+                # unsupported (unknown dtype/layout, schema_version, ...) — both
+                # surface as 415 + code 'unsupported'. Retry over JSON and only
+                # mark binary unsupported when that retry actually succeeds;
+                # otherwise the failure was request content, not transport
+                # capability, so binary must stay enabled (a transient bad
+                # request must not permanently downgrade the client to JSON).
+                status_code, raw, timing = self._infer_http(
+                    "json",
+                    request_id,
+                    endpoint,
+                    inputs,
+                    deadline_ms=deadline_ms,
+                    correlation_id=correlation_id,
+                    profile=profile,
+                )
+                result = _parse_infer_response(raw, status_code, self._endpoint.url, "json", timing)
+                self._binary_supported = False
+                return result
+            else:
+                result = _parse_binary_or_json_response(
+                    raw, status_code, self._endpoint.url, "binary", timing
+                )
+                if result.transport == "binary":
+                    self._binary_supported = True
+                return result
+
+        status_code, raw, timing = self._infer_http(
+            "json",
+            request_id,
+            endpoint,
+            inputs,
+            deadline_ms=deadline_ms,
+            correlation_id=correlation_id,
+            profile=profile,
+        )
+        return _parse_infer_response(raw, status_code, self._endpoint.url, "json", timing)
+
+    def _should_try_binary(self) -> bool:
+        if self._preferred_transport == "binary":
+            return True
+        if self._preferred_transport == "json":
+            return False
+        return self._binary_supported is not False
+
+    def _infer_http(
+        self,
+        transport: Literal["binary", "json"],
+        request_id: str,
+        endpoint: str,
+        inputs: Sequence[TensorInput],
+        *,
+        deadline_ms: int | None,
+        correlation_id: str | None,
+        profile: bool,
+    ) -> tuple[int, bytes, ClientTiming | None]:
+        t0 = time.perf_counter_ns()
+        if transport == "binary":
+            payload = _encode_binary_infer_request(
+                request_id,
+                endpoint,
+                inputs,
+                deadline_ms=deadline_ms,
+                correlation_id=correlation_id,
+            )
+            headers = {
+                "Content-Type": _BINARY_CONTENT_TYPE,
+                "Accept": f"{_BINARY_CONTENT_TYPE}, application/json",
+            }
+            if correlation_id is not None:
+                headers["X-Correlation-Id"] = correlation_id
+        else:
+            payload, headers = _encode_json_infer_request(
+                request_id,
+                endpoint,
+                inputs,
+                deadline_ms=deadline_ms,
+                correlation_id=correlation_id,
+            )
+        t1 = time.perf_counter_ns()
         status_code, raw = http_request(
             "POST", self._endpoint.url, body=payload, headers=headers, timeout=self._timeout
         )
-        return _parse_infer_response(raw, status_code, self._endpoint.url)
+        t2 = time.perf_counter_ns()
+        timing = (
+            ClientTiming(
+                encode_ns=t1 - t0,
+                http_roundtrip_ns=t2 - t1,
+                decode_ns=0,
+                request_bytes=len(payload),
+                response_bytes=len(raw),
+            )
+            if profile
+            else None
+        )
+        return status_code, raw, timing
 
     def health(self) -> HealthSnapshot:
         """Read ``GET /health`` and parse the worker's readiness snapshot.
@@ -182,6 +304,72 @@ class ServingClient:
         return _parse_health(payload, url)
 
 
+def _encode_json_infer_request(
+    request_id: str,
+    endpoint: str,
+    inputs: Sequence[TensorInput],
+    *,
+    deadline_ms: int | None = None,
+    correlation_id: str | None = None,
+) -> tuple[bytes, dict[str, str]]:
+    request_body: dict[str, object] = {
+        "schema_version": SCHEMA_VERSION,
+        "request_id": request_id,
+        "endpoint": endpoint,
+        "inputs": [tensor.to_named_input() for tensor in inputs],
+    }
+    if deadline_ms is not None:
+        request_body["deadline_ms"] = deadline_ms
+    headers: dict[str, str] = {}
+    if correlation_id is not None:
+        request_body["metadata"] = {"correlation_id": correlation_id}
+        headers["X-Correlation-Id"] = correlation_id
+    return json.dumps(request_body).encode("utf-8"), headers
+
+
+def _encode_binary_infer_request(
+    request_id: str,
+    endpoint: str,
+    inputs: Sequence[TensorInput],
+    *,
+    deadline_ms: int | None = None,
+    correlation_id: str | None = None,
+) -> bytes:
+    payload = bytearray()
+    encoded_inputs: list[dict[str, object]] = []
+    for tensor in inputs:
+        offset = len(payload)
+        payload.extend(tensor.data)
+        encoded_inputs.append(
+            {
+                "name": tensor.name,
+                "tensor": {
+                    "dtype": tensor.dtype.value,
+                    "layout": tensor.layout.value,
+                    "shape": list(tensor.shape),
+                    "byte_offset": 0,
+                    "byte_size": len(tensor.data),
+                },
+                "payload_offset": offset,
+                "payload_size": len(tensor.data),
+            }
+        )
+    request_body: dict[str, object] = {
+        "schema_version": SCHEMA_VERSION,
+        "request_id": request_id,
+        "endpoint": endpoint,
+        "inputs": encoded_inputs,
+    }
+    if deadline_ms is not None:
+        request_body["deadline_ms"] = deadline_ms
+    if correlation_id is not None:
+        request_body["metadata"] = {"correlation_id": correlation_id}
+    metadata = json.dumps(request_body, separators=(",", ":")).encode("utf-8")
+    if len(metadata) > 0xFFFFFFFF:
+        raise ValueError("binary infer metadata exceeds uint32 length limit")
+    return _BINARY_INFER_MAGIC + struct.pack("<I", len(metadata)) + metadata + bytes(payload)
+
+
 def _decode_json_object(raw: bytes, url: str) -> dict[str, object]:
     try:
         parsed = json.loads(raw)
@@ -200,7 +388,47 @@ def _require_supported_schema(payload: dict[str, object]) -> None:
         )
 
 
-def _parse_infer_response(raw: bytes, status_code: int, url: str) -> InferResult:
+def _with_decode_timing(
+    result: InferResult, timing: ClientTiming | None, started_ns: int
+) -> InferResult:
+    if timing is None:
+        return result
+    return InferResult(
+        request_id=result.request_id,
+        outputs=result.outputs,
+        correlation_id=result.correlation_id,
+        timing=result.timing,
+        transport=result.transport,
+        client_timing=ClientTiming(
+            encode_ns=timing.encode_ns,
+            http_roundtrip_ns=timing.http_roundtrip_ns,
+            decode_ns=time.perf_counter_ns() - started_ns,
+            request_bytes=timing.request_bytes,
+            response_bytes=timing.response_bytes,
+        ),
+    )
+
+
+def _parse_binary_or_json_response(
+    raw: bytes,
+    status_code: int,
+    url: str,
+    transport: str,
+    client_timing: ClientTiming | None = None,
+) -> InferResult:
+    if raw.startswith(_BINARY_RESULT_MAGIC):
+        return _parse_binary_infer_response(raw, status_code, url, client_timing)
+    return _parse_infer_response(raw, status_code, url, transport, client_timing)
+
+
+def _parse_infer_response(
+    raw: bytes,
+    status_code: int,
+    url: str,
+    transport: str = "json",
+    client_timing: ClientTiming | None = None,
+) -> InferResult:
+    decode_started = time.perf_counter_ns()
     payload = _decode_json_object(raw, url)
     _require_supported_schema(payload)
     status = payload.get("status")
@@ -218,14 +446,145 @@ def _parse_infer_response(raw: bytes, status_code: int, url: str) -> InferResult
     if not isinstance(request_id, str):
         raise ProtocolError(f"serving success response from {url!r} is missing 'request_id'")
     correlation_id = payload.get("correlation_id")
-    return InferResult(
-        request_id=request_id,
-        outputs=outputs,
-        correlation_id=correlation_id if isinstance(correlation_id, str) else None,
-        timing=_parse_timing(payload.get("timing")),
+    return _with_decode_timing(
+        InferResult(
+            request_id=request_id,
+            outputs=outputs,
+            correlation_id=correlation_id if isinstance(correlation_id, str) else None,
+            timing=_parse_timing(payload.get("timing")),
+            transport=transport,
+        ),
+        client_timing,
+        decode_started,
     )
 
 
+def _parse_binary_infer_response(
+    raw: bytes,
+    status_code: int,
+    url: str,
+    client_timing: ClientTiming | None = None,
+) -> InferResult:
+    del status_code
+    decode_started = time.perf_counter_ns()
+    metadata, payload = _split_binary_envelope(raw, _BINARY_RESULT_MAGIC, url)
+    _require_supported_schema(metadata)
+    if metadata.get("status") != "success":
+        raise ProtocolError(f"binary serving response from {url!r} did not declare success")
+    outputs_obj = metadata.get("outputs")
+    if not isinstance(outputs_obj, list) or not outputs_obj:
+        raise ProtocolError(f"binary serving success response from {url!r} is missing outputs")
+    outputs = tuple(_binary_output_from_metadata(item, payload) for item in outputs_obj)
+    request_id = metadata.get("request_id")
+    if not isinstance(request_id, str):
+        raise ProtocolError(f"binary serving success response from {url!r} is missing request_id")
+    correlation_id = metadata.get("correlation_id")
+    return _with_decode_timing(
+        InferResult(
+            request_id=request_id,
+            outputs=outputs,
+            correlation_id=correlation_id if isinstance(correlation_id, str) else None,
+            timing=_parse_timing(metadata.get("timing")),
+            transport="binary",
+        ),
+        client_timing,
+        decode_started,
+    )
+
+
+def _split_binary_envelope(raw: bytes, magic: bytes, url: str) -> tuple[dict[str, object], bytes]:
+    header_size = len(magic) + 4
+    if len(raw) < header_size or not raw.startswith(magic):
+        raise ProtocolError(f"binary serving response from {url!r} has invalid magic")
+    (metadata_len,) = struct.unpack("<I", raw[len(magic) : header_size])
+    metadata_end = header_size + metadata_len
+    if len(raw) < metadata_end:
+        raise ProtocolError(f"binary serving response from {url!r} has truncated metadata")
+    try:
+        metadata = json.loads(raw[header_size:metadata_end])
+    except ValueError as exc:
+        raise ProtocolError(
+            f"binary serving response from {url!r} has invalid metadata JSON: {exc}"
+        ) from exc
+    if not isinstance(metadata, dict):
+        raise ProtocolError(f"binary serving response from {url!r} metadata is not an object")
+    return metadata, raw[metadata_end:]
+
+
+def _binary_output_from_metadata(obj: object, payload: bytes) -> TensorOutput:
+    if not isinstance(obj, dict):
+        raise ProtocolError("binary serving output entry is not a JSON object")
+    name = obj.get("name")
+    if not isinstance(name, str) or not name:
+        raise ProtocolError("binary serving output is missing a non-empty 'name'")
+    tensor = obj.get("tensor")
+    if not isinstance(tensor, dict):
+        raise ProtocolError(f"binary serving output {name!r} is missing tensor metadata")
+    dtype_value = tensor.get("dtype")
+    try:
+        dtype = DType(dtype_value)
+    except ValueError as exc:
+        raise ProtocolError(
+            f"binary serving output {name!r} has unknown dtype {dtype_value!r}"
+        ) from exc
+    layout_value = tensor.get("layout", Layout.ROW_MAJOR.value)
+    try:
+        layout = Layout(layout_value)
+    except ValueError as exc:
+        raise ProtocolError(
+            f"binary serving output {name!r} has unknown layout {layout_value!r}"
+        ) from exc
+    shape_raw = tensor.get("shape")
+    if (
+        not isinstance(shape_raw, list)
+        or not shape_raw
+        or not all(
+            isinstance(dim, int) and not isinstance(dim, bool) and dim >= 1 for dim in shape_raw
+        )
+    ):
+        raise ProtocolError(f"binary serving output {name!r} has an invalid shape")
+    shape = tuple(int(dim) for dim in shape_raw)
+    expected_size = itemsize(dtype) * math.prod(shape)
+    offset = _required_nonnegative_int(obj, "payload_offset", name)
+    size = _required_nonnegative_int(obj, "payload_size", name)
+    if size < expected_size:
+        raise ProtocolError(
+            f"binary serving output {name!r} payload_size is {size}, expected {expected_size}"
+        )
+    end = offset + size
+    if len(payload) < end:
+        raise ProtocolError(
+            f"binary serving output {name!r} payload is {len(payload)} bytes, need {end}"
+        )
+    semantic_tag = obj.get("semantic_tag")
+    return TensorOutput(
+        name=name,
+        dtype=dtype,
+        shape=shape,
+        data=payload[offset : offset + expected_size],
+        layout=layout,
+        semantic_tag=semantic_tag if isinstance(semantic_tag, str) else None,
+    )
+
+
+def _required_nonnegative_int(obj: dict[str, object], field: str, name: str) -> int:
+    value = obj.get(field)
+    if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+        raise ProtocolError(f"binary serving output {name!r} has invalid {field!r}")
+    return value
+
+
+def _is_binary_unsupported(raw: bytes) -> bool:
+    try:
+        payload = json.loads(raw)
+    except (ValueError, UnicodeDecodeError):
+        return True
+    if not isinstance(payload, dict) or payload.get("status") != "failure":
+        return False
+    error_obj = payload.get("error")
+    return isinstance(error_obj, dict) and error_obj.get("code") == ErrorCode.UNSUPPORTED.value
+
+
 def _serving_error(payload: dict[str, object]) -> ServingError:
     request_id = payload.get("request_id")
     request_id = request_id if isinstance(request_id, str) else None

tensorplate/vision.py

@@ -12,7 +12,7 @@ from tensorplate.conventions import YOLO_V8_SINGLE_OUTPUT, detections
 from tensorplate.errors import ProtocolError
 from tensorplate.postprocess import Detection, decode_detections
 from tensorplate.preprocess import PreprocessConfig, preprocess
-from tensorplate.serving import InferResult, ServingClient
+from tensorplate.serving import InferResult, ServingClient, TransportPreference
 from tensorplate.tensors import TensorOutput
 
 if TYPE_CHECKING:
@@ -39,6 +39,7 @@ class VisionClient:
         config_path: str | None = None,
         timeout: float = DEFAULT_TIMEOUT_S,
         discover: bool = True,
+        preferred_transport: TransportPreference = "auto",
         client: ServingClient | None = None,
     ) -> None:
         self._serving = client or ServingClient(
@@ -47,6 +48,7 @@ class VisionClient:
             config_path=config_path,
             timeout=timeout,
             discover=discover,
+            preferred_transport=preferred_transport,
         )
 
     @property

{tensorplate_python-0.1.3.dist-info → tensorplate_python-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorplate-python
-Version: 0.1.3
+Version: 0.1.5
 Summary: First-party Python SDK for calling deployed TensorPlate detection and vision serving models.
 Author: TensorPlate Contributors
 License: Apache-2.0

tensorplate_python-0.1.5.dist-info/RECORD

@@ -0,0 +1,15 @@
+tensorplate/__init__.py,sha256=GnFr1z9YVQirlbudOJzmYlpPWmBnFLLKL24_SyOBvsk,2047
+tensorplate/client.py,sha256=hVoVAaqXUT8ZcP6HDbhk1OtqL_4uS5R9E4LgPDz4n_M,10673
+tensorplate/conventions.py,sha256=6b2WBWHAGNxuPninMqNVRpe6pGz2k8FCI1SbLe-r33c,1414
+tensorplate/errors.py,sha256=oZSYgG1T8TtLaw4jFwW806KzfDzke_5GB6Omlkvx8Uw,2718
+tensorplate/postprocess.py,sha256=nKcPf5LeIOZIn-IlEKhQOOV3Qc6YUMAYk5uiTThco2s,7553
+tensorplate/preprocess.py,sha256=ItUWijW3jKzel3ESLhnjg5ag6BoNXQhytpa_2o08fKk,6019
+tensorplate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tensorplate/serving.py,sha256=pq3mvLsgqf2DyFcbdi-zZM0JZglJdd_O_kyd3TIzhtw,23560
+tensorplate/tensors.py,sha256=KvI3zYkAfNuquBKb9xDT-Mt4W8HudMECt02aHbMKm6Y,8939
+tensorplate/vision.py,sha256=d4p-Gm5X4fhF4QH0nI0w66kS74pEZZywS_teUAr9c0A,4664
+tensorplate_python-0.1.5.dist-info/licenses/LICENSE,sha256=ZxVIDHiEBfOHLu3QJTeSSO8fYRNUlInHP9ESK3DZmEE,11389
+tensorplate_python-0.1.5.dist-info/METADATA,sha256=4kVJXFmVg9ro0cfMWg6S6eX8k6S9HvyjMx6jHutqGmA,2905
+tensorplate_python-0.1.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+tensorplate_python-0.1.5.dist-info/top_level.txt,sha256=FFVk-zeOOH6pSd9Hd9gzDD7WSJpbZ23RazVSCssIXnM,12
+tensorplate_python-0.1.5.dist-info/RECORD,,

{tensorplate_python-0.1.3.dist-info → tensorplate_python-0.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tensorplate_python-0.1.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-tensorplate/__init__.py,sha256=cPJYqsMBR-PjWtfqN1N1yA2alUrVv32RwaSSTPQ1UUs,1961
-tensorplate/client.py,sha256=SwgFZYnxXO1Ff3ruBSIAdCMzbyReGixlXOvjYK6Oj5M,10506
-tensorplate/conventions.py,sha256=rysRZVfesQ6vRLrlTxiWbRBK4zbazvv-9njmBVKdJJo,1109
-tensorplate/errors.py,sha256=oZSYgG1T8TtLaw4jFwW806KzfDzke_5GB6Omlkvx8Uw,2718
-tensorplate/postprocess.py,sha256=GusFErKCJdUERoDUDvdrPbMkt0wtEFkXL5R3_c5O_JA,5186
-tensorplate/preprocess.py,sha256=ItUWijW3jKzel3ESLhnjg5ag6BoNXQhytpa_2o08fKk,6019
-tensorplate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tensorplate/serving.py,sha256=d4OYe4JdcPFJWTwTzbi3xgbftFxgfSEHDiubc7C_eAc,10287
-tensorplate/tensors.py,sha256=KvI3zYkAfNuquBKb9xDT-Mt4W8HudMECt02aHbMKm6Y,8939
-tensorplate/vision.py,sha256=KwbVfPqtqdbIGSzEKqbkif9-KZj6U0zUZ81MrQDPPhw,4531
-tensorplate_python-0.1.3.dist-info/licenses/LICENSE,sha256=ZxVIDHiEBfOHLu3QJTeSSO8fYRNUlInHP9ESK3DZmEE,11389
-tensorplate_python-0.1.3.dist-info/METADATA,sha256=vS3F-CXLjd5BCrwYKRsUkzbzkyZZtNPp9d3Oy62JX3c,2905
-tensorplate_python-0.1.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-tensorplate_python-0.1.3.dist-info/top_level.txt,sha256=FFVk-zeOOH6pSd9Hd9gzDD7WSJpbZ23RazVSCssIXnM,12
-tensorplate_python-0.1.3.dist-info/RECORD,,