arrayview 0.31.0__py3-none-any.whl → 0.31.2__py3-none-any.whl

arrayview/_analysis.py

@@ -34,7 +34,15 @@ def _build_metadata(session) -> dict:
         "is_rgb": session.rgb_axis is not None,
         "has_source_file": bool(getattr(session, "filepath", None)),
     }
-    default_dims = _session_mod._startup_dims_for_data(session.data, target_shape)
+    collection_spatial_ndim = getattr(session, "collection_spatial_ndim", None)
+    default_shape = target_shape
+    if collection_spatial_ndim is not None:
+        spatial_ndim = int(collection_spatial_ndim)
+        if 2 <= spatial_ndim <= len(target_shape):
+            # Collection axes are appended after the image dimensions. They
+            # select a case; they must not influence the startup plane.
+            default_shape = target_shape[:spatial_ndim]
+    default_dims = _session_mod._startup_dims_for_data(session.data, default_shape)
     if default_dims is not None:
         meta["default_dims"] = [int(default_dims[0]), int(default_dims[1])]
     if getattr(session, "spatial_meta", None) is not None:
@@ -49,7 +57,6 @@ def _build_metadata(session) -> dict:
         )
     if getattr(session, "array_keys", None):
         meta["array_keys"] = session.array_keys
-    collection_spatial_ndim = getattr(session, "collection_spatial_ndim", None)
     if collection_spatial_ndim is not None:
         meta["collection_spatial_ndim"] = int(collection_spatial_ndim)
     if getattr(session.data, "_av_ragged", False):

arrayview/_instance_registry.py

@@ -115,11 +115,17 @@ def _windows_process_start(pid: int) -> str | None:
     handle = kernel32.OpenProcess(0x1000, False, pid)
     if not handle:
         return None
+    still_active = 259
+    exit_code = ctypes.c_ulong()
     creation = ctypes.c_ulonglong()
     exit_time = ctypes.c_ulonglong()
     kernel = ctypes.c_ulonglong()
     user = ctypes.c_ulonglong()
     try:
+        if not kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code)):
+            return None
+        if exit_code.value != still_active:
+            return None
         ok = kernel32.GetProcessTimes(handle, ctypes.byref(creation),
                                       ctypes.byref(exit_time), ctypes.byref(kernel),
                                       ctypes.byref(user))

arrayview/_overlays.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import numpy as np
 
 from arrayview._render import (
+    _build_mosaic_grid,
     _composite_overlay_mask,
     _extract_overlay_mask,
     _overlay_is_label_map,
@@ -36,6 +37,7 @@ def _composite_overlays(
     dim_y: int,
     idx_tuple: tuple[int, ...],
     shape_hw: tuple[int, int],
+    base_shape: tuple[int, ...] | None = None,
 ) -> np.ndarray:
     """Composite one or more overlay masks onto RGBA pixels."""
     if not overlay_sid_str:
@@ -62,6 +64,7 @@ def _composite_overlays(
             dim_y,
             idx_tuple,
             expected_shape=shape_hw,
+            base_shape=base_shape,
         )
         rgba = _composite_overlay_mask(
             rgba,
@@ -72,3 +75,76 @@ def _composite_overlays(
             outline_only=overlay_outline,
         )
     return rgba
+
+
+def _composite_mosaic_overlays(
+    rgba: np.ndarray,
+    overlay_sid_str: str | None,
+    overlay_colors_str: str | None,
+    overlay_alpha: float,
+    overlay_alphas_str: str | None,
+    overlay_outline: bool,
+    dim_x: int,
+    dim_y: int,
+    dim_z: int,
+    idx_tuple: tuple[int, ...],
+    base_shape: tuple[int, ...],
+    mosaic_cols: int | None = None,
+) -> np.ndarray:
+    """Composite each overlay as a mosaic using the base mosaic's frame indices.
+
+    Missing overlay axes are resolved per frame by ``_extract_overlay_mask``.
+    That lets a mask omit, for example, an echo axis without materialising a
+    repeated full-volume copy.
+    """
+    if not overlay_sid_str:
+        return rgba
+    sids = [sid.strip() for sid in overlay_sid_str.split(",") if sid.strip()]
+    colors_raw = (
+        [color.strip() for color in overlay_colors_str.split(",")]
+        if overlay_colors_str
+        else []
+    )
+    alphas_raw = (
+        [alpha.strip() for alpha in overlay_alphas_str.split(",")]
+        if overlay_alphas_str
+        else []
+    )
+    tile_shape = (int(base_shape[dim_y]), int(base_shape[dim_x]))
+    n_frames = int(base_shape[dim_z])
+
+    for i, sid in enumerate(sids):
+        color = _parse_hex_color(colors_raw[i]) if i < len(colors_raw) else None
+        try:
+            alpha = float(alphas_raw[i]) if i < len(alphas_raw) else overlay_alpha
+        except ValueError:
+            alpha = overlay_alpha
+        alpha = max(0.0, min(1.0, alpha))
+
+        frames = []
+        for frame in range(n_frames):
+            frame_idx = list(idx_tuple)
+            frame_idx[dim_z] = frame
+            ov_raw = _extract_overlay_mask(
+                sid,
+                dim_x,
+                dim_y,
+                tuple(frame_idx),
+                expected_shape=tile_shape,
+                base_shape=base_shape,
+            )
+            frames.append(
+                ov_raw if ov_raw is not None else np.zeros(tile_shape, dtype=np.float32)
+            )
+        grid, _, _ = _build_mosaic_grid(frames, n_frames, cols=mosaic_cols)
+        # Gaps are transparent, not NaN label values or heatmap samples.
+        grid = np.nan_to_num(grid, nan=0.0)
+        rgba = _composite_overlay_mask(
+            rgba,
+            grid,
+            alpha=alpha,
+            is_label=_overlay_is_label_map(sid, grid),
+            override_color=color,
+            outline_only=overlay_outline,
+        )
+    return rgba

arrayview/_render.py

@@ -1,5 +1,6 @@
 """Rendering pipeline: colormaps, LUTs, slice extraction, RGBA, mosaic, RGB, preload."""
 
+import itertools
 import threading
 import time
 
@@ -527,6 +528,7 @@ def _extract_overlay_mask(
     dim_y: int,
     idx_tuple: tuple[int, ...],
     expected_shape: tuple[int, int],
+    base_shape: tuple[int, ...] | None = None,
 ) -> np.ndarray | None:
     """Return the raw overlay slice (float32 H×W) for compositing, or None.
 
@@ -538,27 +540,43 @@ def _extract_overlay_mask(
     if ov_session is None:
         return None
 
-    ov_ndim = ov_session.data.ndim
-    if dim_x >= ov_ndim or dim_y >= ov_ndim:
+    ov_shape = tuple(int(size) for size in ov_session.shape)
+    main_shape = tuple(int(size) for size in (base_shape or ov_shape))
+    if len(ov_shape) > len(main_shape):
         return None
 
-    idx_candidates: list[tuple[int, ...]] = [
-        tuple(int(idx_tuple[i]) if i < len(idx_tuple) else 0 for i in range(ov_ndim))
-    ]
-    if len(idx_tuple) >= ov_ndim:
-        trailing = tuple(int(v) for v in idx_tuple[-ov_ndim:])
-        if trailing != idx_candidates[0]:
-            idx_candidates.append(trailing)
-
-    for ov_idx in idx_candidates:
-        try:
-            ov_raw = extract_slice(ov_session, dim_x, dim_y, list(ov_idx))
-        except Exception:
-            continue
-        if ov_raw.shape != expected_shape:
-            continue
-        if np.any(np.isfinite(ov_raw) & (ov_raw != 0)):
-            return ov_raw.astype(np.float32)
+    # An overlay may omit one or more non-spatial dimensions from the base.
+    # Match its axes to equal-sized base axes, then index only those axes. This
+    # broadcasts the overlay over every omitted axis without allocating a tiled
+    # copy (important for masks next to multi-echo or multi-channel data).
+    map_key = (main_shape, dim_x, dim_y)
+    axis_maps = getattr(ov_session, "_overlay_axis_maps", None)
+    if axis_maps is None:
+        axis_maps = {}
+        ov_session._overlay_axis_maps = axis_maps
+    if map_key not in axis_maps:
+        axis_maps[map_key] = next(
+            (
+                base_axes
+                for base_axes in itertools.combinations(range(len(main_shape)), len(ov_shape))
+                if dim_x in base_axes
+                and dim_y in base_axes
+                and tuple(main_shape[axis] for axis in base_axes) == ov_shape
+            ),
+            None,
+        )
+    base_axes = axis_maps[map_key]
+    if base_axes is None:
+        return None
+    ov_dim_x = base_axes.index(dim_x)
+    ov_dim_y = base_axes.index(dim_y)
+    ov_idx = [int(idx_tuple[axis]) for axis in base_axes]
+    try:
+        ov_raw = extract_slice(ov_session, ov_dim_x, ov_dim_y, ov_idx)
+    except Exception:
+        return None
+    if ov_raw.shape == expected_shape:
+        return ov_raw.astype(np.float32)
     return None
 
 

arrayview/_routes_rendering.py

@@ -6,7 +6,7 @@ from fastapi import Depends, Response
 from fastapi.responses import JSONResponse
 
 from arrayview._diff import _compute_diff, _diff_histogram, _render_diff_rgba
-from arrayview._overlays import _composite_overlays
+from arrayview._overlays import _composite_mosaic_overlays, _composite_overlays
 from arrayview._render import (
     LUTS,
     _build_mosaic_grid,
@@ -178,6 +178,11 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                     vmin_override=vmin_override,
                     vmax_override=vmax_override,
                 )
+                rgba = _composite_mosaic_overlays(
+                    rgba, overlay_sid, overlay_colors, overlay_alpha, overlay_alphas,
+                    overlay_outline, dim_x, dim_y, dim_z, idx_tuple, session.shape,
+                    mosaic_cols,
+                )
                 if vmin_override is not None and vmax_override is not None:
                     vmin, vmax = float(vmin_override), float(vmax_override)
                 else:
@@ -251,6 +256,7 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                     dim_y,
                     idx_tuple,
                     rgba.shape[:2],
+                    session.shape,
                 )
                 _, vmin, vmax = _prepare_display(
                     session,
@@ -263,6 +269,12 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                 )
                 if qmri_role:
                     vmin, vmax = _qmri_adjust_vmin_vmax(vmin, vmax, qmri_role)
+            if dim_z >= 0 and qmri_role:
+                rgba = _composite_mosaic_overlays(
+                    rgba, overlay_sid, overlay_colors, overlay_alpha, overlay_alphas,
+                    overlay_outline, dim_x, dim_y, dim_z, idx_tuple, session.shape,
+                    mosaic_cols,
+                )
         render_ms = (time.perf_counter() - render_t0) * 1000.0
         encode_t0 = time.perf_counter()
         img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")

arrayview/_routes_websocket.py

@@ -8,7 +8,7 @@ from starlette.websockets import WebSocketDisconnect
 import arrayview._session as _session_mod
 from arrayview._analysis import _build_metadata
 from arrayview._lifecycle import release_session
-from arrayview._overlays import _composite_overlays
+from arrayview._overlays import _composite_mosaic_overlays, _composite_overlays
 from arrayview._render import (
     LUTS,
     _prepare_display,
@@ -25,6 +25,7 @@ from arrayview._session import (
     SESSIONS,
     SHELL_SOCKETS,
     _render,
+    _schedule_overlay_prefetch,
     _schedule_prefetch,
     _vprint,
     wait_for_session_ready,
@@ -231,6 +232,12 @@ def register_websocket_routes(app) -> None:
                                 vmax_override=vmax_override,
                             ),
                         )
+                        rgba = _composite_mosaic_overlays(
+                            rgba, msg.get("overlay_sid"), msg.get("overlay_colors"),
+                            float(msg.get("overlay_alpha", 0.45)), msg.get("overlay_alphas"),
+                            bool(msg.get("overlay_outline", False)), dim_x, dim_y, dim_z,
+                            idx_tuple, session.shape, mosaic_cols,
+                        )
                         h, w = rgba.shape[:2]
                         raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
                         _, vmin, vmax = _prepare_display(
@@ -340,6 +347,15 @@ def register_websocket_routes(app) -> None:
                         dim_y,
                         idx_tuple,
                         (h, w),
+                        session.shape,
+                    )
+
+                if dim_z >= 0 and qmri_role:
+                    rgba = _composite_mosaic_overlays(
+                        rgba, msg.get("overlay_sid"), msg.get("overlay_colors"),
+                        float(msg.get("overlay_alpha", 0.45)), msg.get("overlay_alphas"),
+                        bool(msg.get("overlay_outline", False)), dim_x, dim_y, dim_z,
+                        idx_tuple, session.shape, mosaic_cols,
                     )
 
                 render_ms = (time.perf_counter() - render_t0) * 1000.0
@@ -414,6 +430,16 @@ def register_websocket_routes(app) -> None:
                             collection_axis,
                             collection_direction,
                         )
+                    _schedule_overlay_prefetch(
+                        session,
+                        msg.get("overlay_sid"),
+                        msg.get("overlay_alphas"),
+                        dim_x,
+                        dim_y,
+                        list(idx_tuple),
+                        collection_axis,
+                        collection_direction,
+                    )
                 previous_indices = idx_tuple
         except Exception as _ws_exc:
             import traceback

arrayview/_session.py

@@ -101,6 +101,7 @@ def _ensure_render_thread() -> None:
 # Neighbor prefetch thread pool (Phase 3)
 # ---------------------------------------------------------------------------
 _PREFETCH_POOL = None
+_OVERLAY_PREFETCH_POOL = None
 _PREFETCH_LOCK = threading.Lock()
 
 
@@ -116,6 +117,19 @@ def _get_prefetch_pool():
         return _PREFETCH_POOL
 
 
+def _get_overlay_prefetch_pool():
+    """Return the small pool reserved for collection overlay lookahead."""
+    global _OVERLAY_PREFETCH_POOL
+    with _PREFETCH_LOCK:
+        if _OVERLAY_PREFETCH_POOL is None or _OVERLAY_PREFETCH_POOL._shutdown:
+            import concurrent.futures
+
+            _OVERLAY_PREFETCH_POOL = concurrent.futures.ThreadPoolExecutor(
+                max_workers=2, thread_name_prefix="arrayview-overlay-prefetch"
+            )
+        return _OVERLAY_PREFETCH_POOL
+
+
 def _schedule_prefetch(session, dim_x, dim_y, idx_list, slice_dim, direction):
     """Warm raw_cache for the next PREFETCH_NEIGHBORS slices in *direction*.
 
@@ -170,6 +184,85 @@ def _schedule_prefetch(session, dim_x, dim_y, idx_list, slice_dim, direction):
         pass  # pool shutting down
 
 
+def _schedule_overlay_prefetch(
+    session,
+    overlay_sid_str,
+    overlay_alphas_str,
+    dim_x,
+    dim_y,
+    idx_list,
+    collection_axis,
+    direction,
+):
+    """Warm the next collection volume for visible overlays.
+
+    Overlay work uses its own bounded pool so a long mask decompression cannot
+    hold up the main image's single-worker prefetch lane. New navigation
+    supersedes overlay jobs that have not started loading a volume yet.
+    """
+    if not overlay_sid_str:
+        return
+
+    sids = [sid.strip() for sid in overlay_sid_str.split(",") if sid.strip()]
+    alphas = [a.strip() for a in (overlay_alphas_str or "").split(",")]
+    visible_sids = []
+    for i, sid in enumerate(sids):
+        try:
+            alpha = float(alphas[i]) if i < len(alphas) and alphas[i] else 1.0
+        except ValueError:
+            alpha = 1.0
+        if alpha > 0.0:
+            visible_sids.append(sid)
+    if not visible_sids:
+        return
+
+    target = idx_list[collection_axis] + direction
+    if not 0 <= target < session.shape[collection_axis]:
+        return
+
+    request_key = (collection_axis, target, tuple(visible_sids))
+    if request_key == getattr(session, "_overlay_prefetch_request", None):
+        return
+    session._overlay_prefetch_request = request_key
+    generation = getattr(session, "_overlay_prefetch_generation", 0) + 1
+    session._overlay_prefetch_generation = generation
+
+    def _warm(overlay_sid):
+        if generation != getattr(session, "_overlay_prefetch_generation", 0):
+            return
+        overlay = SESSIONS.get(overlay_sid)
+        if overlay is None or collection_axis >= len(overlay.shape):
+            return
+        overlay_stack_axes = tuple(getattr(overlay.data, "_stack_axes", ()))
+        if collection_axis not in overlay_stack_axes or target >= overlay.shape[collection_axis]:
+            return
+        overlay_idx = list(idx_list[: len(overlay.shape)])
+        overlay_idx[collection_axis] = target
+        # Sparse --overlay-dir collections represent a missing patient with a
+        # None filepath. Avoid allocating a fresh full-size zero volume merely
+        # to prefetch an overlay that will be shown empty.
+        file_matrix = getattr(overlay.data, "_file_matrix", None)
+        if file_matrix is not None:
+            modality = 0
+            if len(overlay_stack_axes) > 1:
+                modality = overlay_idx[overlay_stack_axes[1]]
+            if not file_matrix[target][modality]:
+                return
+        try:
+            from arrayview._render import extract_slice
+
+            extract_slice(overlay, dim_x, dim_y, overlay_idx)
+        except Exception:
+            pass
+
+    try:
+        pool = _get_overlay_prefetch_pool()
+        for overlay_sid in visible_sids:
+            pool.submit(_warm, overlay_sid)
+    except RuntimeError:
+        pass  # pool shutting down
+
+
 async def _render(loop: asyncio.AbstractEventLoop, func) -> object:
     """Await *func()* in the render thread without using concurrent.futures."""
     _ensure_render_thread()
@@ -476,9 +569,12 @@ __all__ = [
     "_render",
     # Prefetch
     "_PREFETCH_POOL",
+    "_OVERLAY_PREFETCH_POOL",
     "_PREFETCH_LOCK",
     "_get_prefetch_pool",
+    "_get_overlay_prefetch_pool",
     "_schedule_prefetch",
+    "_schedule_overlay_prefetch",
     # Session
     "Session",
     "SESSIONS",

arrayview/_vscode_browser.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import json
+import platform
 import subprocess
 import sys
 import threading
@@ -219,7 +220,7 @@ def _open_browser(
                     port_hint = int(url.split(":")[2].split("/")[0].split("?")[0])
                 except Exception:
                     port_hint = parsed_port
-                hostname = os.uname().nodename or "<this-host>"
+                hostname = platform.node() or "<this-host>"
                 print(
                     f"[ArrayView] Plain SSH session detected.\n"
                     f"\n"

{arrayview-0.31.0.dist-info → arrayview-0.31.2.dist-info}/METADATA

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

{arrayview-0.31.0.dist-info → arrayview-0.31.2.dist-info}/RECORD

@@ -1,35 +1,35 @@
 arrayview/ARCHITECTURE.md,sha256=3uM548p70zJ_Fj8eYWN1cN8fEsCA2C7eSRvUx-3HhtU,16515
 arrayview/__init__.py,sha256=CBRg7Aqj4Ft2bSNvKb9pfkLrbVxL7bzKsx6ZridmR-E,775
 arrayview/__main__.py,sha256=Fj5RszShrCcAS7_nIyBndtkpMI_PLBxM5GG9huzqhVs,101
-arrayview/_analysis.py,sha256=BAEUmeBgp4gZaQZXkULoxYd_OyJOtfZnigUsKcEm3tc,10209
+arrayview/_analysis.py,sha256=JCbMT6NcUDDIZ24ABCdOXT1NAyGAX96rebq34DloElI,10594
 arrayview/_app.py,sha256=2lA5P4YD8zEJ-HnDiGdZUtO4uOSxRoKrs110Iq5Xl0k,5336
 arrayview/_codex_open.py,sha256=keegkA8G5BIm6g0IgvRMqXCpOg4nKtdTOAsRDlvAB5A,3541
 arrayview/_config.py,sha256=64rtArzgJGF0_ukrWlaNZWQHVRk8wiIinUQQBXoB27g,4356
 arrayview/_diff.py,sha256=mSIo1ArNxkrB0v2iUMy3dezJOlpos0xNu1V_umNUMhU,5677
 arrayview/_icon.png,sha256=a8RTAbvweLhh3hzD5eGg76Peq-KSDcS6YrCphRb_HEs,2748
 arrayview/_imaging.py,sha256=MQX1uy4m1lofOeoLDhCp6cHO5p_V5fXm4qlSu9Ykn-c,534
-arrayview/_instance_registry.py,sha256=E6__kmj5guNSlk5y_cdey7OKjBKwlsu4TTPAhKPR-9c,8638
+arrayview/_instance_registry.py,sha256=N-6uWAmYsO6bkr2v55GDbWX-xRktErP-kFT8FfJ7Y7U,8863
 arrayview/_io.py,sha256=PSSjD7MWQlYQPrY0ELxNtbrEdLYBtdNJsOs-F6JHSyM,50596
 arrayview/_launch_plan.py,sha256=wNWnnrDNzEaDbH3VKK8P_dhQVzv-bvKCGn6nNLXo8P0,16072
 arrayview/_launcher.py,sha256=b91U8XaPGiCVThn-b9p1QEQFMrC0XsM6dTYhHuSscCE,163017
 arrayview/_lifecycle.py,sha256=WE-vXHioGU2H_zBK_sRivmqRfoO9RLDSAJtTq3Oe-WY,1693
-arrayview/_overlays.py,sha256=Qfis82NiIBl4IlilhFj0y1kuu-mUaKqIXKU4Hxuq4F4,2080
+arrayview/_overlays.py,sha256=TsMnXrP_BNSzCj4k8hbWNM-M5lcrro0xA_wusvAdLLw,4622
 arrayview/_platform.py,sha256=U1XPqEjPeqy3l_xJh9Rmn_3d_6Fh_clJUcA0uR6QBGA,19043
-arrayview/_render.py,sha256=Er6EMZCM1LkPC7-Nym1IQBNqlm_eSjyyRyaVGE-VazI,29463
+arrayview/_render.py,sha256=wVvwxQtZ7ldWYZTzlg2CS-esnPHlpSXMW_z22eh-rU0,30296
 arrayview/_routes_analysis.py,sha256=QTTdZrq6bXBAxqrAPf4-3_ANZPv0b8VXyPK8mW_Xe1s,31629
 arrayview/_routes_export.py,sha256=Ha8mMO2E9TlRL5x25-ADV8_8xUiC-jRz9N1oWwgKOsg,3898
 arrayview/_routes_loading.py,sha256=pqhiOaH-hXdCR8P9X26JHm_psR5gurT1N4vh8BIuwcw,21864
 arrayview/_routes_persistence.py,sha256=T03csHb7ppGT-8yMDf227XkqhnhjgSLYj0RW2wmg59g,17176
 arrayview/_routes_preload.py,sha256=KOsankNguxdIWmFW9iZcY9p2SvUN1mOKY7KkW1qMGcc,1729
 arrayview/_routes_query.py,sha256=vEwkNWKVkwTOBswGU079gf_C0fWbO4Bgvg0U7jusBCU,5227
-arrayview/_routes_rendering.py,sha256=qraJoMxCnHDx2Kcvfcrt1N_a6O_KOZj_Hy2GPZC7MDs,21040
+arrayview/_routes_rendering.py,sha256=OiYvdYE2PnTXVo9fUdWN1JvZ-VvUTUgGA7LYGrmMDSo,21688
 arrayview/_routes_segmentation.py,sha256=x2bBjQffZryeTMmOH38YdBWethw1o3KpA8V0chJcZHI,23599
 arrayview/_routes_state.py,sha256=TmxC__NPPsvg59jM2D_FRc_oPv1wWbRmUr6t6ukVj64,11173
 arrayview/_routes_vectorfield.py,sha256=P8avWU8jDH173YQ4Kfpzs8SZz5gIL4ki0-Gc6pGA9w4,7383
-arrayview/_routes_websocket.py,sha256=nBK2wHlxSIiA1G3rMYoYGJUCD3fZNP6Vj_slGqnpUsQ,17367
+arrayview/_routes_websocket.py,sha256=6WCK665MGAbCpOhkxQdEnJN7o1CYB4e2_VB4ilgmr-I,18722
 arrayview/_segmentation.py,sha256=aENWHmefrKDScXhcZL1X3KgYXE784dpMkmFFo83qnrw,7377
 arrayview/_server.py,sha256=XqrC1jbQ_wke4_YgxZ-1xACmUFPYxq2hEU--namvtqA,10407
-arrayview/_session.py,sha256=0Q1iVkoyqrqsIqFNcc6eqiDmLMxs8fKpnJ8a3fgoxVE,18192
+arrayview/_session.py,sha256=NXhx1-XbMNqqsF-A57wmmW2rE9jOUbWtXtjgQRl0b7s,21683
 arrayview/_session_spec.py,sha256=AEqt_5eXIYdlWkJeeVBmG_MqSUgmVDZCTNaMkdRTZ5Y,6969
 arrayview/_shell.html,sha256=xzHIB-kRX12okubZoqdrgsWDY8CCLteg5jtXxDQru8U,11624
 arrayview/_synthetic_mri.py,sha256=CNL-2WC835i6WCqkvmWBCO6WQ5w7HE5trNb8OyEfe64,7365
@@ -37,13 +37,13 @@ arrayview/_torch.py,sha256=13sqIMCUu_-b9SQ9KfDCExDz2UMStL87EDVjnbJxAEo,7536
 arrayview/_vectorfield.py,sha256=eDqMCMEGjO8Jdt-6Auh01cz3WD9dbF7xYUWD9xHAf1E,8115
 arrayview/_viewer.html,sha256=42OHpTAuXsFLB5AGLJhCRs1qw9oIqjEXJjq3i9EKm9c,1789431
 arrayview/_vscode.py,sha256=uY3SYJYjgzuYCbdycmm53ZaPNJIPPtGiIQZKBUobMz4,871
-arrayview/_vscode_browser.py,sha256=BvDyPjBKBUbalPqN0fb5kC5O8ZjucfU9va6kPjY9tlM,11773
+arrayview/_vscode_browser.py,sha256=7WjnJwN--bppJmSv8TFjJWG0_IpGwGqHkNI6ubjxgE8,11785
 arrayview/_vscode_extension.py,sha256=UZqjMPJASvz8U6moa-cX7xVJhbvwpVSmCHXd-wc_W4Y,13423
 arrayview/_vscode_signal.py,sha256=9WZKG3CqZKA9yG6GvSVmkunQs-0DwmRNy5wML4dD0p0,45107
 arrayview/arrayview-opener.vsix,sha256=QeeLuH0h0sFN_tBXIRmFOdm4owSrZ4_aLSQPe7KbOR0,21352
 arrayview/gsap.min.js,sha256=VGihm4idI0E1uqrWezWsiScB9F_jMosn7qs6pPSkeac,72304
-arrayview-0.31.0.dist-info/METADATA,sha256=UFnJ1Mnn10C8pw3Wqp8WnSq_-1ZcYrlcBavk7b_6KlQ,2054
-arrayview-0.31.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-arrayview-0.31.0.dist-info/entry_points.txt,sha256=FQSz3M11B-zaVLDyXofKUDvMhHASz7OjmoLgI4nn7ko,105
-arrayview-0.31.0.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
-arrayview-0.31.0.dist-info/RECORD,,
+arrayview-0.31.2.dist-info/METADATA,sha256=ID8dLoV42W9GRgXawTdg4nupId1kmrlnxMcPNYspMcc,2054
+arrayview-0.31.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+arrayview-0.31.2.dist-info/entry_points.txt,sha256=FQSz3M11B-zaVLDyXofKUDvMhHASz7OjmoLgI4nn7ko,105
+arrayview-0.31.2.dist-info/licenses/LICENSE,sha256=34OivjM9faB2QaPjZpMRTIiSx31V3U9cEyQ6F2k-bH0,1062
+arrayview-0.31.2.dist-info/RECORD,,