nnInteractive 2.3.0__tar.gz → 2.3.1__tar.gz

{nninteractive-2.3.0 → nninteractive-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nnInteractive
-Version: 2.3.0
+Version: 2.3.1
 Summary: Inference code for nnInteractive
 Author: Helmholtz Imaging Applied Computer Vision Lab
 Author-email: Fabian Isensee <f.isensee@dkfz-heidelberg.de>

{nninteractive-2.3.0 → nninteractive-2.3.1}/nnInteractive/inference/remote/remote_session.py

@@ -42,6 +42,16 @@ from nnInteractive.inference.remote._protocol import (
 from nnInteractive.inference.remote.serialization import pack_array, unpack_array
 
 
+def _compression_threads() -> int:
+    """blosc2 thread count for client-side upload compression.
+
+    Full logical CPU count: blosc2 scales measurably onto SMT siblings, so use them all to
+    minimize upload latency. Per-call only (passed to pack_array → compress2), so it never
+    mutates blosc2's global nthreads.
+    """
+    return max(1, os.cpu_count() or 1)
+
+
 class SessionExpiredError(RuntimeError):
     """Raised when the server reports the client's lease no longer exists.
 
@@ -290,7 +300,7 @@ class nnInteractiveRemoteInferenceSession:
     def set_image(self, image: np.ndarray, image_properties: Optional[dict] = None) -> None:
         assert image.ndim == 4, f"expected a 4d image as input, got {image.ndim}d. Shape {image.shape}"
         meta = {"image_properties": image_properties or {}}
-        resp = self._post_binary(PATH_SET_IMAGE, meta, pack_array(image))
+        resp = self._post_binary(PATH_SET_IMAGE, meta, pack_array(image, nthreads=_compression_threads()))
         info = resp.json()
         self.original_image_shape = tuple(info["original_image_shape"])
 
@@ -402,7 +412,9 @@ class nnInteractiveRemoteInferenceSession:
             "interaction_bbox": ([list(b) for b in interaction_bbox] if interaction_bbox is not None else None),
         }
         # Interactions (scribble/lasso masks) compress best with NOFILTER; skip auto-selection.
-        resp = self._post_binary(path, meta, pack_array(mask_image, filters=[blosc2.Filter.NOFILTER]))
+        resp = self._post_binary(
+            path, meta, pack_array(mask_image, filters=[blosc2.Filter.NOFILTER], nthreads=_compression_threads())
+        )
         self._apply_prediction_response(resp)
 
     def add_initial_seg_interaction(
@@ -428,7 +440,11 @@ class nnInteractiveRemoteInferenceSession:
             "override_capability_checks": bool(override_capability_checks),
         }
         # Segmentations compress best with NOFILTER; skip auto-selection.
-        resp = self._post_binary(PATH_ADD_INITIAL_SEG, meta, pack_array(initial_seg, filters=[blosc2.Filter.NOFILTER]))
+        resp = self._post_binary(
+            PATH_ADD_INITIAL_SEG,
+            meta,
+            pack_array(initial_seg, filters=[blosc2.Filter.NOFILTER], nthreads=_compression_threads()),
+        )
         self._apply_prediction_response(resp)
 
     # ------------------------------------------------------------------ #

{nninteractive-2.3.0 → nninteractive-2.3.1}/nnInteractive/inference/remote/serialization.py

@@ -51,18 +51,21 @@ _ID_CODEC = {v: k for k, v in _CODEC_ID.items()}
 _SELECT_FILTER_CROP_FRACTION = 0.25
 
 
-def _compress_all(raw: memoryview, total: int, codec: blosc2.Codec, clevel: int, filters: list) -> int:
+def _compress_all(
+    raw: memoryview, total: int, codec: blosc2.Codec, clevel: int, filters: list, nthreads: Optional[int]
+) -> int:
     """Compressed byte length of ``raw`` under ``filters``, chunked exactly as pack_array does."""
+    extra = {} if nthreads is None else {"nthreads": nthreads}
     size = 0
     nchunks = (total + _CHUNK_SIZE - 1) // _CHUNK_SIZE
     for i in range(nchunks):
         start = i * _CHUNK_SIZE
         end = min(start + _CHUNK_SIZE, total)
-        size += len(blosc2.compress2(raw[start:end], codec=codec, clevel=clevel, filters=filters))
+        size += len(blosc2.compress2(raw[start:end], codec=codec, clevel=clevel, filters=filters, **extra))
     return size
 
 
-def _select_filter(arr: np.ndarray, codec: blosc2.Codec, clevel: int) -> "blosc2.Filter":
+def _select_filter(arr: np.ndarray, codec: blosc2.Codec, clevel: int, nthreads: Optional[int]) -> "blosc2.Filter":
     """Pick NOFILTER vs SHUFFLE for ``arr`` by trial-compressing a small centered crop.
 
     Uses ``compress2`` on the raw bytes — exactly the path pack_array takes — so the decision
@@ -79,7 +82,7 @@ def _select_filter(arr: np.ndarray, codec: blosc2.Codec, clevel: int) -> "blosc2
 
         best_filter, best_bytes = blosc2.Filter.NOFILTER, None
         for f in (blosc2.Filter.NOFILTER, blosc2.Filter.SHUFFLE):
-            cb = _compress_all(raw, total, codec, clevel, [f])
+            cb = _compress_all(raw, total, codec, clevel, [f], nthreads)
             if best_bytes is None or cb < best_bytes:
                 best_bytes, best_filter = cb, f
         return best_filter
@@ -95,6 +98,7 @@ def pack_array(
     codec: blosc2.Codec = blosc2.Codec.ZSTD,
     clevel: int = 3,
     filters: Optional[list] = None,
+    nthreads: Optional[int] = None,
 ) -> bytes:
     """Serialize a numpy array to a self-describing compressed byte string.
 
@@ -104,6 +108,10 @@ def pack_array(
     know the optimum (interactions and segmentations compress best with NOFILTER) should pass
     ``[blosc2.Filter.NOFILTER]`` to skip the selection. The chosen filter is self-describing
     inside the blosc2 frame, so unpack_array (decompress2) needs no changes.
+
+    ``nthreads`` is the per-call blosc2 thread count for compression. ``None`` (the default)
+    inherits blosc2's global ``nthreads`` (= core count). Passing an explicit value overrides
+    it for this call only, without mutating global state.
     """
     arr = np.ascontiguousarray(arr)
     dtype_str = arr.dtype.str.lstrip("<>|=").encode("ascii")
@@ -137,13 +145,14 @@ def pack_array(
     if filters is None:
         # Auto-select the better filter from a small centered crop, using the same
         # compress2 path as below for consistency.
-        filters = [_select_filter(arr, codec, clevel)]
+        filters = [_select_filter(arr, codec, clevel, nthreads)]
 
+    extra = {} if nthreads is None else {"nthreads": nthreads}
     parts = [header, shape_bytes, struct.pack("<I", nchunks)]
     for i in range(nchunks):
         start = i * _CHUNK_SIZE
         end = min(start + _CHUNK_SIZE, total)
-        chunk = blosc2.compress2(raw[start:end], codec=codec, clevel=clevel, filters=filters)
+        chunk = blosc2.compress2(raw[start:end], codec=codec, clevel=clevel, filters=filters, **extra)
         parts.append(struct.pack("<QQ", end - start, len(chunk)))
         parts.append(chunk)
     return b"".join(parts)

{nninteractive-2.3.0 → nninteractive-2.3.1}/nnInteractive/inference/server/app.py

@@ -443,7 +443,9 @@ def make_app(
         session._last_paste_bbox = None
         return Response(
             # Segmentations compress best with NOFILTER; skip auto-selection.
-            content=pack_array(sub, filters=[blosc2.Filter.NOFILTER]),
+            content=pack_array(
+                sub, filters=[blosc2.Filter.NOFILTER], nthreads=min(session.torch_n_threads, os.cpu_count())
+            ),
             media_type=CONTENT_TYPE_OCTET_STREAM,
             headers={META_HEADER: json.dumps(meta, separators=(",", ":"))},
         )

{nninteractive-2.3.0 → nninteractive-2.3.1}/nnInteractive.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nnInteractive
-Version: 2.3.0
+Version: 2.3.1
 Summary: Inference code for nnInteractive
 Author: Helmholtz Imaging Applied Computer Vision Lab
 Author-email: Fabian Isensee <f.isensee@dkfz-heidelberg.de>

{nninteractive-2.3.0 → nninteractive-2.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nnInteractive"
-version = "2.3.0"
+version = "2.3.1"
 requires-python = ">=3.10"
 description = "Inference code for nnInteractive"
 readme = "readme.md"