arrayview 0.40.0__tar.gz → 0.41.1__tar.gz

{arrayview-0.40.0 → arrayview-0.41.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.40.0
+Version: 0.41.1
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview

{arrayview-0.40.0 → arrayview-0.41.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.40.0"
+version = "0.41.1"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"
@@ -63,6 +63,7 @@ test = [
     "httpx>=0.27",
     "pytest-playwright>=0.5",
     "pillow>=12.1.1",
+    "nbclassic>=1.3,<2",
 ]
 docs = [
     "mkdocs>=1.6",

{arrayview-0.40.0 → arrayview-0.41.1}/src/arrayview/ARCHITECTURE.md

@@ -169,7 +169,7 @@ A refactoring in progress that introduces a View/Layer/Slicer/LayoutStrategy/Mod
 **Status:** Phases 1–15 complete. Phase 12 (keybind collapse) and Phase 17 (final cleanup) pending completion of render-pipeline migration from legacy globals to `displayState`.
 
 ### Command Registry
-All keybinds flow through a VS Code-style command registry in `_viewer.html`. Three tables: `commands` (id → `{title, when, run}`), `keybinds` (key+modifiers → command id), and `makeContext(state)` (mode/state flag bag). `dispatchCommand(e)` is wired as a prefix to the keydown handler; on a match it evaluates `when` against the context and runs the command, otherwise falls through. The help overlay is rendered at runtime from the `GUIDE_TABS` static data structure in `_viewer.html` — when adding or changing a keybind, update `GUIDE_TABS` manually. A `/`-triggered command palette fuzzy-searches all commands. Cross-mode enablement is guarded by `tests/test_command_reachability.py`.
+All keybinds flow through a VS Code-style command registry in `_viewer.html`. Three tables: `commands` (id → `{title, when, run}`), `keybinds` (key+modifiers → command id), and `makeContext(state)` (mode/state flag bag). `dispatchCommand(e)` is wired as a prefix to the keydown handler; on a match it evaluates `when` against the context and runs the command, otherwise falls through. The help overlay is rendered at runtime from the `GUIDE_TABS` static data structure in `_viewer.html` — when adding or changing a keybind, update `GUIDE_TABS` manually. A `/`-triggered command palette fuzzy-searches all commands.
 
 ### Reconcilers
 Functions in the "UI Validation and Reconciliation" section (~line 13666) that enforce consistent UI state. When mode changes happen, reconcilers update visibility of containers, colorbars, dynamic islands, and compare sub-mode UI. There are four:

{arrayview-0.40.0 → arrayview-0.41.1}/src/arrayview/_analysis.py

@@ -51,6 +51,7 @@ def _build_metadata(session) -> dict:
             "voxel_sizes": list(sm["voxel_sizes"]),
             "axis_labels": list(sm["axis_labels"]),
             "is_oblique": bool(sm["is_oblique"]),
+            "is_canonical": bool(sm.get("is_canonical", True)),
         }
         meta["ras_resample_active"] = bool(
             getattr(session, "ras_resample_active", False)

{arrayview-0.40.0 → arrayview-0.41.1}/src/arrayview/_io.py

@@ -139,8 +139,13 @@ def _select_npz_array(npz, filepath):
     return npz[keys[0]]
 
 
-def _nifti_header_with_meta(filepath):
-    """Return a NIfTI image and canonical spatial metadata without reading voxels."""
+def _nifti_header_with_meta(filepath, *, native=False):
+    """Return a NIfTI image and spatial metadata without reading voxels.
+
+    Directory collections use canonical metadata because their lazy series
+    objects expose canonical axes. A single volume uses native metadata so an
+    uncompressed NIfTI can keep its proxy and storage-friendly axis order.
+    """
     nib = _nib()
     img = nib.load(filepath)
     original_affine = np.asarray(img.affine, dtype=np.float64)
@@ -151,30 +156,40 @@ def _nifti_header_with_meta(filepath):
         transform, img.shape[:3]
     )
 
-    rot = affine_canonical[:3, :3]
+    data_affine = original_affine if native else affine_canonical
+    rot = data_affine[:3, :3]
     voxel_sizes = tuple(float(np.linalg.norm(rot[:, i])) for i in range(3))
+    canonical_rot = affine_canonical[:3, :3]
+    canonical_voxel_sizes = tuple(
+        float(np.linalg.norm(canonical_rot[:, i])) for i in range(3)
+    )
     norm_rot = np.zeros((3, 3))
     for i in range(3):
-        if voxel_sizes[i] > 0:
-            norm_rot[:, i] = rot[:, i] / voxel_sizes[i]
-    pos_labels = ("R", "A", "S")
-    neg_labels = ("L", "P", "I")
-    axis_labels = tuple(
-        pos_labels[i] if norm_rot[i, i] >= 0 else neg_labels[i] for i in range(3)
-    )
+        if canonical_voxel_sizes[i] > 0:
+            norm_rot[:, i] = canonical_rot[:, i] / canonical_voxel_sizes[i]
+    axis_labels = tuple(str(v) for v in nib.aff2axcodes(data_affine))
     off_diag_max = max(
         (abs(norm_rot[i, j]) for i in range(3) for j in range(3) if i != j),
         default=0.0,
     )
     canonical_shape = tuple(int(img.shape[int(axis)]) for axis in transform[:, 0])
-    return img, {
+    meta = {
         "affine": original_affine,
         "affine_canonical": affine_canonical,
+        "data_affine": data_affine,
         "voxel_sizes": voxel_sizes,
         "axis_labels": axis_labels,
         "is_oblique": bool(off_diag_max > 1e-3),
-        "canonical_shape": canonical_shape,
+        "is_canonical": bool(
+            np.array_equal(transform, np.asarray([[0, 1], [1, 1], [2, 1]]))
+        ),
+        "to_canonical": transform,
     }
+    if native:
+        meta["spatial_shape"] = tuple(int(v) for v in img.shape[:3])
+    else:
+        meta["canonical_shape"] = canonical_shape
+    return img, meta
 
 
 def _nifti_display_array(proxy):
@@ -373,25 +388,19 @@ def _get_progressive_nifti_pool(*, overlay_prefetch=False):
 
 
 def _load_nifti_with_meta(filepath):
-    """Load a NIfTI file, canonical-reorient, return (array, meta).
-
-    meta is a dict with keys:
-      affine            : original 4x4 affine (RAS+ mm)
-      affine_canonical  : 4x4 affine after as_closest_canonical
-      voxel_sizes       : tuple (sx, sy, sz) in mm, post-reorient
-      axis_labels       : tuple of 3 strs from {"R","L","A","P","S","I"}
-                          — positive direction of each canonical axis
-      is_oblique        : bool — True if rotation part has off-diagonal magnitude > 1e-3
-                          after normalizing voxel sizes
-    """
-    img, meta = _nifti_header_with_meta(filepath)
-    canon = _nib().as_closest_canonical(img)
-
-    # NOTE: reorient requires materializing axis permutes/flips. .nii.gz is
-    # already eager (gzip not seekable), so this is free; .nii loses mmap as a
-    # necessary cost to apply the reorient.
-    arr = np.asarray(canon.dataobj)
+    """Load a NIfTI file in native voxel order and return (array, meta).
 
+    Uncompressed .nii stays proxy-backed. This preserves cheap native-plane
+    reads even when the affine describes permuted or flipped anatomical axes.
+    Compressed .nii.gz still has to be decoded eagerly because gzip is not
+    random-access, but it is no longer silently reordered.
+    """
+    img, meta = _nifti_header_with_meta(filepath, native=True)
+    arr = (
+        img.dataobj
+        if filepath.endswith(".nii")
+        else _nifti_display_array(img.dataobj)
+    )
     return arr, meta
 
 

{arrayview-0.40.0 → arrayview-0.41.1}/src/arrayview/_launch_plan.py

@@ -267,6 +267,8 @@ def _completion_target(
     if plan.display is Display.BROWSER:
         if _placement(evidence) is Placement.SSH:
             return CompletionTarget.GUIDANCE_PRINTED
+        if _placement(evidence) is Placement.VSCODE_REMOTE:
+            return CompletionTarget.FRAME_READY
         return CompletionTarget.DISPATCH_ACCEPTED
     if invocation in {Invocation.CLI, Invocation.VSCODE_EXPLORER}:
         return CompletionTarget.FRAME_READY
@@ -412,7 +414,9 @@ def plan_launch(
         window=None if remote_jupyter else window,
         inline=False if remote_jupyter else intent.inline,
         environment=environment,
-        native_available=facts.native_backend is not None, reasons=reasons,
+        native_available=facts.native_backend is not None,
+        in_vscode_tunnel=facts.in_vscode_tunnel,
+        reasons=reasons,
     )
     if display is Display.VSCODE and environment not in {
         Environment.VSCODE_LOCAL, Environment.VSCODE_REMOTE
@@ -436,6 +440,7 @@ def _display_policy(
     inline: bool | None,
     environment: Environment,
     native_available: bool,
+    in_vscode_tunnel: bool,
     reasons: list[str],
 ) -> tuple[Display, Display | None, bool]:
     if window == "none":
@@ -461,6 +466,9 @@ def _display_policy(
             return Display.VSCODE, None, False
         return Display.VSCODE, Display.BROWSER, True
     if window == "browser":
+        if environment is Environment.VSCODE_REMOTE and in_vscode_tunnel:
+            reasons.append("remote_external_browser")
+            return Display.BROWSER, None, False
         if environment is Environment.VSCODE_REMOTE:
             reasons.append("remote_browser_redirected_to_vscode")
             return Display.VSCODE, None, False