@camstack/addon-pipeline 1.2.103 → 1.2.104

package/python/postprocessors/test_plate_slots.py

@@ -0,0 +1,217 @@
+"""Tests for the fixed-slot plate-OCR postprocessor (`cct-s-v2-global`).
+
+The properties that make this reader safe are DIFFERENT from the CTC one's, and
+that difference is the whole point of the file:
+
+1. **A fixed-slot reader is never silent on its own.** CTC collapses toward the
+   blank on noise, so "the string is too short" was a usable plausibility gate.
+   This model emits `max_plate_slots` softmax heads on EVERY input, so a wall,
+   a bumper and an OSD band all decode to some 7-character string. The gate
+   here is therefore a per-character CONFIDENCE FLOOR plus the region grammar —
+   `minTextLength` would pass literally everything.
+
+2. **The floor is on the WEAKEST character, not the mean.** A plate misread in
+   one position still averages ~0.9; it is the single bad slot that gives it
+   away. Measured on the 39-crop cam-617 set: every correct read has min-char
+   probability >= 0.75 or is silenced, and no junk ROI clears it on any engine.
+
+3. **Trailing pad is the length signal; interior pad is a refusal.** `_` is a
+   real class the model picks when a slot has no glyph. Trailing pads are
+   stripped (a 6-glyph plate in 10 slots); a pad in the MIDDLE means the model
+   declined a position it thinks exists, and that read is never a plate.
+"""
+import numpy as np
+import pytest
+
+# Package-qualified, unlike the flat `from ctc import` of the sibling suites:
+# `plate_slots` imports the shared plate grammar from `ctc`, so it has to be
+# loaded AS a package member or the relative import has no parent. Same
+# invocation as every other python suite here — `python -m pytest` from this
+# directory, which puts both this directory and its parent on sys.path.
+from postprocessors.plate_slots import (
+    DEFAULT_MIN_CHAR_PROBABILITY,
+    PLATE_ALPHABET,
+    PLATE_PAD_CHAR,
+    PLATE_SLOTS,
+    postprocess_plate_slots,
+)
+
+VOCAB = len(PLATE_ALPHABET)
+
+
+def _slots(text: str, prob: float = 0.99, per_slot: "dict[int, float] | None" = None):
+    """Build a ``[1, SLOTS, VOCAB]`` softmax whose per-slot argmax spells `text`.
+
+    Slots beyond `text` take the pad class. `per_slot` overrides the winning
+    probability at individual positions so a single weak character can be
+    tested without weakening the rest.
+    """
+    padded = text.ljust(PLATE_SLOTS, PLATE_PAD_CHAR)[:PLATE_SLOTS]
+    out = np.zeros((PLATE_SLOTS, VOCAB), dtype=np.float32)
+    for slot, char in enumerate(padded):
+        winner = PLATE_ALPHABET.index(char)
+        p = (per_slot or {}).get(slot, prob)
+        out[slot] = (1.0 - p) / (VOCAB - 1)
+        out[slot, winner] = p
+        # A softmax over 37 classes cannot put its argmax below ~1/37, so a
+        # fixture asking for less would silently spell a DIFFERENT string and
+        # the test would be measuring nothing.
+        assert int(np.argmax(out[slot])) == winner, f"slot {slot}: p={p} does not win"
+    return out[np.newaxis]
+
+
+def _read(text: str, config: "dict | None" = None, **kwargs) -> dict:
+    cfg = {"plateRegion": "DE"}
+    cfg.update(config or {})
+    return postprocess_plate_slots({"plate": _slots(text, **kwargs)}, cfg, 128, 64, 1.0, (0, 0))
+
+
+# --- decode ------------------------------------------------------------------
+
+
+def test_alphabet_matches_the_published_plate_config():
+    """The published `cct_s_v2_global_plate_config.yaml` contract. A drift here
+    shifts every class index and the model reads a different alphabet."""
+    assert PLATE_ALPHABET == "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_"
+    assert PLATE_PAD_CHAR == "_"
+    assert PLATE_SLOTS == 10
+    assert VOCAB == 37
+
+
+def test_decodes_the_per_slot_argmax():
+    assert _read("DNRO309")["text"] == "DNRO309"
+
+
+def test_strips_trailing_pad_only():
+    assert _read("DNLL78")["text"] == "DNLL78"
+
+
+def test_interior_pad_is_refused():
+    """`DN_RO309` is the model declining slot 2, not a plate with an underscore."""
+    assert _read("DN_RO309")["text"] == ""
+
+
+def test_all_pad_reads_empty():
+    assert _read("")["text"] == ""
+
+
+def test_confidence_is_the_mean_over_kept_characters_only():
+    """The pad slots the model is trivially sure about must not inflate it."""
+    result = _read("DNLL78", prob=0.8)
+    assert result["confidence"] == pytest.approx(0.8, abs=1e-3)
+
+
+def test_reads_the_plate_output_by_name_not_by_position():
+    """The graph emits `plate` AND `region`; dict order is not a contract."""
+    predictions = {"region": np.zeros((1, 66), np.float32), "plate": _slots("DNRO309")}
+    result = postprocess_plate_slots(predictions, {"plateRegion": "DE"}, 128, 64, 1.0, (0, 0))
+    assert result["text"] == "DNRO309"
+
+
+def test_flat_output_is_reshaped():
+    """A [1, slots*vocab] export decodes identically to the [1, slots, vocab] one."""
+    flat = _slots("DNRO309").reshape(1, PLATE_SLOTS * VOCAB)
+    result = postprocess_plate_slots({"plate": flat}, {"plateRegion": "DE"}, 128, 64, 1.0, (0, 0))
+    assert result["text"] == "DNRO309"
+
+
+def test_wrong_sized_output_is_refused_not_guessed():
+    with pytest.raises(ValueError):
+        postprocess_plate_slots(
+            {"plate": np.zeros((1, 9, VOCAB), np.float32)},
+            {"plateRegion": "DE"},
+            128,
+            64,
+            1.0,
+            (0, 0),
+        )
+
+
+# --- the confidence gate -----------------------------------------------------
+
+
+def test_default_floor_is_the_measured_one():
+    assert DEFAULT_MIN_CHAR_PROBABILITY == 0.75
+
+
+def test_one_weak_character_silences_the_whole_read():
+    """The failure this gate exists for: six confident glyphs and one guess."""
+    result = _read("DNRO309", per_slot={3: 0.42})
+    assert result["text"] == ""
+
+
+def test_a_read_whose_weakest_character_clears_the_floor_survives():
+    result = _read("DNRO309", per_slot={3: 0.81})
+    assert result["text"] == "DNRO309"
+
+
+def test_the_mean_cannot_rescue_a_weak_character():
+    """Six slots at 1.0 and one at 0.3 average 0.9 — the gate must still refuse."""
+    result = _read("DNRO309", prob=1.0, per_slot={0: 0.3})
+    assert result["text"] == ""
+
+
+def test_floor_is_configurable():
+    result = _read("DNRO309", config={"minCharProbability": 0.4}, per_slot={3: 0.42})
+    assert result["text"] == "DNRO309"
+
+
+def test_floor_of_zero_disables_the_gate():
+    result = _read("DNRO309", config={"minCharProbability": 0.0}, per_slot={3: 0.05})
+    assert result["text"] == "DNRO309"
+
+
+def test_pad_slot_confidence_is_not_part_of_the_floor():
+    """Only the emitted glyphs are gated; a hesitant trailing pad is irrelevant."""
+    weak_pad = {slot: 0.3 for slot in range(6, PLATE_SLOTS)}
+    result = _read("DNLL78", per_slot=weak_pad)
+    assert result["text"] == "DNLL78"
+
+
+# --- the grammar -------------------------------------------------------------
+
+
+def test_non_conforming_read_is_silenced_when_a_region_is_active():
+    """Unlike the CTC path, a read that fails the grammar is DROPPED, not kept
+    with formatValid False: this reader's alphabet cannot produce the
+    'obviously junk' shapes that made an annotated-but-kept read useful."""
+    assert _read("3JU511X")["text"] == ""
+
+
+def test_conforming_read_is_marked_valid():
+    result = _read("DNRO309")
+    assert result["formatValid"] is True
+
+
+def test_region_off_returns_the_raw_read():
+    result = _read("3JU511X", config={"plateRegion": "off"})
+    assert result["text"] == "3JU511X"
+    assert result["formatValid"] is False
+
+
+def test_absent_region_defaults_to_off():
+    """A bare call (no config plumbing) must not silently apply a German
+    grammar to a plate photographed in another country."""
+    result = postprocess_plate_slots({"plate": _slots("3JU511X")}, {}, 128, 64, 1.0, (0, 0))
+    assert result["text"] == "3JU511X"
+
+
+def test_unknown_region_does_not_crash_and_does_not_gate():
+    result = _read("3JU511X", config={"plateRegion": "ZZ"})
+    assert result["text"] == "3JU511X"
+    assert result["formatValid"] is False
+
+
+def test_grammar_accepts_the_electric_suffix():
+    assert _read("DNRO309E")["text"] == "DNRO309E"
+
+
+def test_kind_is_text():
+    assert _read("DNRO309")["kind"] == "text"
+
+
+def test_silenced_read_still_reports_its_confidence():
+    """A dropped read must remain diagnosable in the logs."""
+    result = _read("3JU511X")
+    assert result["text"] == ""
+    assert result["confidence"] > 0

package/python/postprocessors/test_yolonas.py

@@ -0,0 +1,83 @@
+"""Tests for the YOLO-NAS (Frigate-style flat NMS export) postprocessor.
+
+Frigate's YOLO-NAS ONNX exports (super-gradients ``model.export()`` with fused
+batched NMS, the format Frigate+ ships) emit ONE flat output tensor of shape
+``[N, 7]`` where each row is ``(batch_index, x1, y1, x2, y2, score, class_id)``
+in INPUT pixel space, post-NMS. Empty GPU slots carry a negative class id.
+"""
+import numpy as np
+
+from postprocessors import POSTPROCESSORS
+from postprocessors.yolonas import postprocess_yolonas
+
+
+FRIGATE_LABELS = ["person", "car", "dog"]
+
+
+def _run(output, config=None, orig_w=1280, orig_h=720, scale=0.25, pad=(0, 70)):
+    cfg = {"labels": FRIGATE_LABELS, "confidence": 0.3}
+    if config:
+        cfg.update(config)
+    return postprocess_yolonas({"output0": output}, cfg, orig_w, orig_h, scale, pad)
+
+
+def test_registered_in_dispatch_table():
+    assert POSTPROCESSORS["yolonas"] is postprocess_yolonas
+
+
+def test_decodes_flat_rows_and_undoes_letterbox():
+    # One person box at input-space (100, 120) → (200, 220), score 0.9.
+    out = np.array(
+        [
+            [0, 100.0, 120.0, 200.0, 220.0, 0.9, 0],
+        ],
+        dtype=np.float32,
+    )
+    result = _run(out)
+    assert result["kind"] == "detections"
+    dets = result["detections"]
+    assert len(dets) == 1
+    det = dets[0]
+    assert det["class"] == "person"
+    assert det["score"] == 0.9
+    # Undo letterbox: (x - pad_x) / scale, (y - pad_y) / scale
+    x1, y1, x2, y2 = det["bbox"]
+    assert x1 == 400.0  # (100 - 0) / 0.25
+    assert y1 == 200.0  # (120 - 70) / 0.25
+    assert x2 == 800.0
+    assert y2 == 600.0
+
+
+def test_drops_below_confidence_and_negative_class():
+    out = np.array(
+        [
+            [0, 10, 10, 20, 20, 0.2, 0],  # below floor
+            [0, 10, 10, 20, 20, 0.9, -1],  # empty slot (negative class)
+            [0, 10, 10, 20, 20, 0.8, 1],  # kept
+        ],
+        dtype=np.float32,
+    )
+    dets = _run(out)["detections"]
+    assert len(dets) == 1
+    assert dets[0]["class"] == "car"
+
+
+def test_accepts_batched_3d_shape():
+    out = np.array([[[0, 10, 10, 20, 20, 0.8, 2]]], dtype=np.float32)
+    dets = _run(out)["detections"]
+    assert len(dets) == 1
+    assert dets[0]["class"] == "dog"
+
+
+def test_out_of_range_class_uses_index_string():
+    out = np.array([[0, 10, 10, 20, 20, 0.8, 7]], dtype=np.float32)
+    dets = _run(out)["detections"]
+    assert dets[0]["class"] == "7"
+
+
+def test_clamps_to_original_frame():
+    out = np.array([[0, -50, 0, 5000, 5000, 0.9, 0]], dtype=np.float32)
+    dets = _run(out)["detections"]
+    x1, y1, x2, y2 = dets[0]["bbox"]
+    assert x1 >= 0 and y1 >= 0
+    assert x2 <= 1280 and y2 <= 720

package/python/postprocessors/yolonas.py

@@ -0,0 +1,67 @@
+"""YOLO-NAS postprocessor — Frigate-style flat batched-NMS ONNX export.
+
+Frigate+ ``yolonas`` models (and any super-gradients ``model.export()`` with
+fused NMS in FLAT format) emit ONE output tensor of shape ``[N, 7]`` where each
+row is ``(batch_index, x1, y1, x2, y2, score, class_id)``:
+
+  - coordinates are in INPUT pixel space (0..inputSize), post-NMS,
+  - GPU exports pad unused slots with a NEGATIVE class id (skip them),
+  - class ids index the model's own label map (Frigate+ label set or COCO-80).
+
+Output matches the yolo postprocessor:
+``{"kind": "detections", "detections": [{"class", "score", "bbox": [x1,y1,x2,y2]}]}``
+with pixel bboxes re-projected to ORIGINAL frame coordinates (letterbox undone
+via the pool-provided ``scale`` + ``pad``).
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .yolo import COCO_80
+
+
+def postprocess_yolonas(
+    predictions: dict,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+) -> dict:
+    conf_threshold = float(config.get("confidence", 0))
+    labels = config.get("labels", COCO_80)
+
+    output = np.asarray(list(predictions.values())[0])
+    # Accept [1, N, 7] batched exports by squeezing the batch axis.
+    if output.ndim == 3:
+        output = output.reshape(-1, output.shape[-1])
+    if output.ndim != 2 or output.shape[-1] != 7:
+        raise ValueError(
+            f"yolonas postprocessor expects a flat [N, 7] output, got shape {output.shape}"
+        )
+
+    detections = []
+    for row in output:
+        _batch_idx, x1, y1, x2, y2, score, class_id = row
+        score = float(score)
+        class_id = int(class_id)
+        if class_id < 0:
+            continue
+        if score < conf_threshold:
+            continue
+
+        ox1 = max(0.0, min(float(orig_w), (float(x1) - pad[0]) / scale))
+        oy1 = max(0.0, min(float(orig_h), (float(y1) - pad[1]) / scale))
+        ox2 = max(0.0, min(float(orig_w), (float(x2) - pad[0]) / scale))
+        oy2 = max(0.0, min(float(orig_h), (float(y2) - pad[1]) / scale))
+
+        label = labels[class_id] if class_id < len(labels) else str(class_id)
+        detections.append(
+            {
+                "class": label,
+                "score": round(score, 4),
+                "bbox": [round(ox1, 1), round(oy1, 1), round(ox2, 1), round(oy2, 1)],
+            }
+        )
+
+    return {"kind": "detections", "detections": detections}

package/python/test_inference_pool_backpressure.py

@@ -16,7 +16,9 @@ import unittest
 # Stub the heavy third-party imports BEFORE importing inference_pool.
 # ---------------------------------------------------------------------------
 
-if "numpy" not in sys.modules:
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
     # The stub must satisfy inference_pool's MODULE-LEVEL numpy usage
     # (_IMAGENET_MEAN/_IMAGENET_STD = np.array([...], dtype=np.float32));
     # a bare ModuleType broke this harness when those constants were added.
@@ -25,7 +27,9 @@ if "numpy" not in sys.modules:
     _np.array = lambda values, dtype=None: values
     sys.modules["numpy"] = _np
 
-if "PIL" not in sys.modules:
+try:  # real PIL when present, for the same reason
+    import PIL.Image  # noqa: F401
+except ImportError:
     _pil = types.ModuleType("PIL")
     _pil_image = types.ModuleType("PIL.Image")
     _pil.Image = _pil_image

package/python/test_inference_pool_coreml_cache.py

@@ -29,10 +29,18 @@ import unittest
 # Stub the heavy third-party imports BEFORE importing inference_pool.
 # ---------------------------------------------------------------------------
 
-if "numpy" not in sys.modules:
-    sys.modules["numpy"] = types.ModuleType("numpy")
-
-if "PIL" not in sys.modules:
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
+    _np = types.ModuleType("numpy")
+    # `inference_pool` builds `_IMAGENET_MEAN = np.array(...)` at import time.
+    _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
+    _np.float32 = "float32"
+    sys.modules["numpy"] = _np
+
+try:  # real PIL when present, for the same reason
+    import PIL.Image  # noqa: F401
+except ImportError:
     _pil = types.ModuleType("PIL")
     _pil_image = types.ModuleType("PIL.Image")
     _pil.Image = _pil_image

package/python/test_inference_pool_device_selection.py

@@ -21,10 +21,18 @@ import unittest
 # Stub the heavy third-party imports BEFORE importing inference_pool.
 # ---------------------------------------------------------------------------
 
-if "numpy" not in sys.modules:
-    sys.modules["numpy"] = types.ModuleType("numpy")
-
-if "PIL" not in sys.modules:
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
+    _np = types.ModuleType("numpy")
+    # `inference_pool` builds `_IMAGENET_MEAN = np.array(...)` at import time.
+    _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
+    _np.float32 = "float32"
+    sys.modules["numpy"] = _np
+
+try:  # real PIL when present, for the same reason
+    import PIL.Image  # noqa: F401
+except ImportError:
     _pil = types.ModuleType("PIL")
     _pil_image = types.ModuleType("PIL.Image")
     _pil.Image = _pil_image

package/python/test_inference_pool_layout.py

@@ -12,11 +12,22 @@ in a minimal sandbox.
 import sys
 import types
 
-for _mod in ("numpy", "PIL", "PIL.Image"):
-    if _mod not in sys.modules:
-        sys.modules[_mod] = types.ModuleType(_mod)
-if not hasattr(sys.modules["PIL"], "Image"):
-    sys.modules["PIL"].Image = types.ModuleType("PIL.Image")
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
+    _np = types.ModuleType("numpy")
+    # `inference_pool` builds `_IMAGENET_MEAN = np.array(...)` at import time.
+    _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
+    _np.float32 = "float32"
+    sys.modules["numpy"] = _np
+try:  # real PIL when present, for the same reason
+    import PIL.Image  # noqa: F401
+except ImportError:
+    _pil = types.ModuleType("PIL")
+    _pil_image = types.ModuleType("PIL.Image")
+    _pil.Image = _pil_image
+    sys.modules["PIL"] = _pil
+    sys.modules["PIL.Image"] = _pil_image
 
 from inference_pool import _is_channels_last, _resolve_input_dims  # noqa: E402
 

package/python/test_inference_pool_memstats.py

@@ -17,7 +17,9 @@ import unittest
 # Stub the heavy third-party imports BEFORE importing inference_pool.
 # ---------------------------------------------------------------------------
 
-if "numpy" not in sys.modules:
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
     # The stub must satisfy inference_pool's MODULE-LEVEL numpy usage
     # (_IMAGENET_MEAN/_IMAGENET_STD = np.array([...], dtype=np.float32));
     # a bare ModuleType broke this harness when those constants were added.
@@ -26,7 +28,9 @@ if "numpy" not in sys.modules:
     _np.array = lambda values, dtype=None: values
     sys.modules["numpy"] = _np
 
-if "PIL" not in sys.modules:
+try:  # real PIL when present, for the same reason
+    import PIL.Image  # noqa: F401
+except ImportError:
     _pil = types.ModuleType("PIL")
     _pil_image = types.ModuleType("PIL.Image")
     _pil.Image = _pil_image

package/python/test_inference_pool_ov_ppp.py

@@ -13,19 +13,22 @@ import sys
 import types
 import unittest
 
-if "numpy" not in sys.modules:
+try:  # real numpy when the sandbox has it — a blind stub POISONS the whole
+    import numpy  # noqa: F401  # pytest session for every sibling that needs it
+except ImportError:
     _np = types.ModuleType("numpy")
-    # inference_pool builds `_IMAGENET_MEAN = np.array(...)` at import time; the
-    # PPP plan decision under test needs no real numpy, so a passthrough stub
-    # keeps this pure test runnable in a numpy-less sandbox.
+    # `inference_pool` builds `_IMAGENET_MEAN = np.array(...)` at import time.
     _np.array = lambda seq, dtype=None: list(seq)  # noqa: E731
     _np.float32 = "float32"
     sys.modules["numpy"] = _np
-for _mod in ("PIL", "PIL.Image"):
-    if _mod not in sys.modules:
-        sys.modules[_mod] = types.ModuleType(_mod)
-if not hasattr(sys.modules["PIL"], "Image"):
-    sys.modules["PIL"].Image = types.ModuleType("PIL.Image")
+try:  # real PIL when present, for the same reason
+    import PIL.Image  # noqa: F401
+except ImportError:
+    _pil = types.ModuleType("PIL")
+    _pil_image = types.ModuleType("PIL.Image")
+    _pil.Image = _pil_image
+    sys.modules["PIL"] = _pil
+    sys.modules["PIL.Image"] = _pil_image
 if "postprocessors" not in sys.modules:
     _pp = types.ModuleType("postprocessors")
     _pp.POSTPROCESSORS = {}

package/python/test_inference_pool_preprocess.py

@@ -155,3 +155,60 @@ def test_untagged_frame_never_caches() -> None:
     assert inference_pool._bench_cache_hits == 0
     assert inference_pool._bench_cache_misses == 0
     assert len(inference_pool._bench_preprocess_cache) == 0
+
+
+# ---------------------------------------------------------------------------
+# uint8-input ONNX models (super-gradients / Frigate YOLO-NAS exports bake the
+# /255 preprocessing INTO the graph and declare a uint8 input tensor)
+# ---------------------------------------------------------------------------
+
+
+def test_onnx_uint8_input_is_fed_raw_uint8_nchw() -> None:
+    inference_pool._runtime = "onnxruntime"
+    cfg = {
+        "inputSize": 320,
+        "_input_name": "input",
+        "_input_shape": [1, 3, 320, 320],
+        "_input_dtype": "uint8",
+        "preprocessMode": "letterbox",
+    }
+    img = Image.new("RGB", (640, 360), (200, 100, 50))
+    input_dict, scale, pad = _preprocess(img, cfg)
+    tensor = input_dict["input"]
+    assert tensor.dtype == np.uint8
+    assert tensor.shape == (1, 3, 320, 320)
+    # Letterbox math still reported for the postprocess re-projection.
+    assert scale == pytest.approx(0.5)
+    assert pad[1] > 0  # vertical padding for a 16:9 frame in a square input
+
+
+def test_onnx_uint8_input_respects_nhwc_declared_shape() -> None:
+    inference_pool._runtime = "onnxruntime"
+    cfg = {
+        "inputSize": 320,
+        "_input_name": "input",
+        "_input_shape": [1, 320, 320, 3],
+        "_input_dtype": "uint8",
+        "preprocessMode": "letterbox",
+    }
+    img = Image.new("RGB", (320, 320), (10, 20, 30))
+    input_dict, _scale, _pad = _preprocess(img, cfg)
+    tensor = input_dict["input"]
+    assert tensor.dtype == np.uint8
+    assert tensor.shape == (1, 320, 320, 3)
+
+
+def test_onnx_float_input_unchanged_by_dtype_feature() -> None:
+    # No `_input_dtype` → the historical float32 [0,1] path, byte-identical.
+    inference_pool._runtime = "onnxruntime"
+    cfg = {
+        "inputSize": 320,
+        "_input_name": "images",
+        "_input_shape": [1, 3, 320, 320],
+        "preprocessMode": "letterbox",
+    }
+    img = Image.new("RGB", (320, 320), (255, 255, 255))
+    input_dict, _scale, _pad = _preprocess(img, cfg)
+    tensor = input_dict["images"]
+    assert tensor.dtype == np.float32
+    assert float(tensor.max()) <= 1.0