arrayview 0.48.4__tar.gz → 0.49.0__tar.gz

{arrayview-0.48.4 → arrayview-0.49.0}/PKG-INFO

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

{arrayview-0.48.4 → arrayview-0.49.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.48.4"
+version = "0.49.0"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_analysis.py

@@ -60,6 +60,15 @@ def _build_metadata(session) -> dict:
     }
     if getattr(session, "initial_view", None):
         meta["initial_view"] = session.initial_view
+    if meta["has_source_file"]:
+        from arrayview._config import get_viewer_remember_view
+
+        if get_viewer_remember_view():
+            from arrayview._view_memory import remembered_view
+
+            remembered = remembered_view(session)
+            if remembered:
+                meta["remembered_view"] = remembered
     code_source = _code_source(session)
     if code_source is not None:
         meta["code_source"] = code_source

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_config.py

@@ -39,6 +39,8 @@ BUILTIN_PREFERENCES = {
         "theme": "dark",
         "rounded_panes": True,
         "qmri_gapless": False,
+        "compare_gapless": False,
+        "remember_view": False,
         "ortho_layout": None,
         "dimbar_mode": "compact",
     },
@@ -49,6 +51,8 @@ PREFERENCE_SCHEMA = {
         "theme": sorted(_VALID_THEMES),
         "rounded_panes": "boolean",
         "qmri_gapless": "boolean",
+        "compare_gapless": "boolean",
+        "remember_view": "boolean",
         "colormaps": "non-empty list of names",
         "ortho_layout": sorted(_VALID_ORTHO_LAYOUTS),
         "dimbar_mode": sorted(_VALID_DIMBAR_MODES),
@@ -120,7 +124,7 @@ def _validate_preference(section: str, key: str, value):
         )
     if section == "viewer" and key == "theme":
         return _normalized_string(value, _VALID_THEMES, "viewer.theme")
-    if section == "viewer" and key in ("rounded_panes", "qmri_gapless"):
+    if section == "viewer" and key in ("rounded_panes", "qmri_gapless", "compare_gapless", "remember_view"):
         if not isinstance(value, bool):
             raise InvalidPreferenceError(f"viewer.{key} must be a boolean")
         return value
@@ -246,6 +250,20 @@ def get_viewer_qmri_gapless() -> bool:
     return isinstance(viewer_cfg, dict) and viewer_cfg.get("qmri_gapless") is True
 
 
+def get_viewer_compare_gapless() -> bool:
+    """Whether arrays compared side by side touch, with no space between them."""
+    viewer_cfg = load_config().get("viewer", {})
+    return isinstance(viewer_cfg, dict) and viewer_cfg.get("compare_gapless") is True
+
+
+def get_viewer_remember_view() -> bool:
+    """Whether reopening a file brings back the view it was last left in."""
+    viewer_cfg = load_config().get("viewer", {})
+    val = viewer_cfg.get("remember_view") if isinstance(viewer_cfg, dict) else None
+    # `arrayview config set` stores the word "true"; the Preferences menu a boolean.
+    return val is True or (isinstance(val, str) and val.strip().lower() in ("true", "1", "yes", "on"))
+
+
 def get_viewer_ortho_layout() -> str | None:
     """Return the preferred initial ortho-view layout."""
     viewer_cfg = load_config().get("viewer", {})

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_diff.py

@@ -135,8 +135,13 @@ def _compute_diff(
     diff_mode,
     indices_a=None,
     indices_b=None,
+    stats_out=None,
 ):
-    """Return raw diff, display range, colormap, and optional separator mask."""
+    """Return raw diff, display range, colormap, and optional separator mask.
+
+    When *stats_out* is a dict it is filled with summary numbers for the
+    compared view (see `_diff_summary`).
+    """
     def _parse_indices(raw_indices):
         if raw_indices is None:
             return ()
@@ -170,6 +175,8 @@ def _compute_diff(
         a = _render_values(session_a, dim_x, dim_y, idx_a, complex_mode, log_scale)
         b = _render_values(session_b, dim_x, dim_y, idx_b, complex_mode, log_scale)
         b = _resize_values_like(b, a)
+    if stats_out is not None:
+        stats_out.update(_diff_summary(a, b, nan_mask))
     if diff_mode == 1:
         raw = a - b
         lo = float(np.nanpercentile(raw, 1))
@@ -192,6 +199,29 @@ def _compute_diff(
     return raw, vmin, vmax, colormap, nan_mask
 
 
+def _diff_summary(a: np.ndarray, b: np.ndarray, nan_mask: np.ndarray | None) -> dict[str, float]:
+    """RMS of A−B, largest |A−B|, and RMS of A−B relative to the RMS of A.
+
+    Pixels that are not finite in either array (or are mosaic separators)
+    are left out. Empty or all-zero inputs give NaN for what is undefined.
+    """
+    a = np.asarray(a, dtype=np.float64)
+    b = np.asarray(b, dtype=np.float64)
+    valid = np.isfinite(a) & np.isfinite(b)
+    if nan_mask is not None and nan_mask.shape == valid.shape:
+        valid &= ~nan_mask
+    if not valid.any():
+        return {"rmse": float("nan"), "max_abs": float("nan"), "rel": float("nan")}
+    d = a[valid] - b[valid]
+    rmse = float(np.sqrt(np.mean(d * d)))
+    rms_a = float(np.sqrt(np.mean(a[valid] ** 2)))
+    return {
+        "rmse": rmse,
+        "max_abs": float(np.max(np.abs(d))),
+        "rel": rmse / rms_a if rms_a > 0 else float("nan"),
+    }
+
+
 def _render_diff_rgba(
     raw: np.ndarray,
     vmin: float,

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_io.py

@@ -1106,11 +1106,12 @@ class _FileSeries:
 
     _av_lazy = True
 
-    def __init__(self, file_matrix, vol_shape, dtype, spatial_meta=None):
+    def __init__(self, file_matrix, vol_shape, dtype, spatial_meta=None, spacing_matrix=None):
         self._file_matrix = file_matrix
         self._vol_shape = tuple(vol_shape)
         self._dtype = np.dtype(dtype)
         self._spatial_meta = spatial_meta
+        self._spacing_matrix = spacing_matrix
         n_patients = len(file_matrix)
         n_modalities = len(file_matrix[0]) if file_matrix else 0
         if n_modalities <= 1:
@@ -1126,6 +1127,10 @@ class _FileSeries:
         )
         self._cache_lock = threading.Lock()
 
+    @property
+    def case_voxel_spacings(self):
+        return self._spacing_matrix
+
     @property
     def dtype(self):
         return self._dtype
@@ -1378,6 +1383,11 @@ def _is_nifti_path(filepath):
     return filepath.endswith(".nii") or filepath.endswith(".nii.gz")
 
 
+def _is_gipl_path(filepath):
+    """True if *filepath* ends with .gipl or .gipl.gz."""
+    return filepath.lower().endswith((".gipl", ".gipl.gz"))
+
+
 def _get_ext(filepath):
     """Return the extension of *filepath*, normalising .nii.gz and .zarr.zip."""
     lower = filepath.lower()
@@ -1596,11 +1606,15 @@ def _series_from_file_matrix(
         return series, spatial_meta
 
     spatial_shapes = []
+    # GIPL headers carry a voxel size; use it when every file has one.
+    gipl_metas = [] if all(_is_gipl_path(path) for path in all_paths) else None
     for fpath in all_paths:
         arr = load_data(fpath)
         shape = arr.shape
         dtype = arr.dtype
         spatial_shapes.append(shape)
+        if gipl_metas is not None:
+            gipl_metas.append(_gipl_spatial_meta(fpath, arr))
         if ref_shape is None:
             ref_shape = shape
             ref_dtype = dtype
@@ -1616,30 +1630,47 @@ def _series_from_file_matrix(
             )
         if scan_progress is not None:
             scan_progress(scan_label, fpath)
+    spacing_matrix = None
+    if gipl_metas and all(meta is not None for meta in gipl_metas):
+        spatial_meta = gipl_metas[0]
+        spacing_matrix = []
     shape_matrix = []
     pos = 0
     for row in file_matrix:
         row_shapes = []
+        row_spacings = []
         for path in row:
             if path is None:
                 row_shapes.append(ref_shape)
+                if spacing_matrix is not None:
+                    row_spacings.append(gipl_metas[0]["voxel_sizes"])
             else:
                 row_shapes.append(spatial_shapes[pos])
+                if spacing_matrix is not None:
+                    row_spacings.append(gipl_metas[pos]["voxel_sizes"])
                 pos += 1
         shape_matrix.append(row_shapes)
+        if spacing_matrix is not None:
+            spacing_matrix.append(row_spacings)
     shapes_differ = any(shape != ref_shape for shape in spatial_shapes)
     if stack == "dense" and shapes_differ:
         raise ValueError("Dense stacking requires every file to have the same shape.")
     if stack == "ragged" or shapes_differ:
-        series = _RaggedFileSeries(file_matrix, shape_matrix, ref_dtype, spatial_meta=None)
+        series = _RaggedFileSeries(
+            file_matrix, shape_matrix, ref_dtype,
+            spatial_meta=spatial_meta, spacing_matrix=spacing_matrix,
+        )
     else:
-        series = _FileSeries(file_matrix, ref_shape, ref_dtype, spatial_meta=None)
+        series = _FileSeries(
+            file_matrix, ref_shape, ref_dtype,
+            spatial_meta=spatial_meta, spacing_matrix=spacing_matrix,
+        )
     if load == "eager":
         for p, row in enumerate(file_matrix):
             for m, path in enumerate(row):
                 if path is not None:
                     series._get_volume(p, m)
-    return series, None
+    return series, spatial_meta
 
 
 def _collection_scan_workers():
@@ -2350,6 +2381,9 @@ def load_data_with_meta(filepath, key=None, *, load="lazy", stack="auto", select
         return _load_file_series(filepath, load=load, stack=stack)
     if filepath.endswith(".nii") or filepath.endswith(".nii.gz"):
         return _load_nifti_with_meta(filepath)
+    if filepath.lower().endswith((".gipl", ".gipl.gz")):
+        arr = _load_gipl(filepath)
+        return arr, _gipl_spatial_meta(filepath, arr)
     return load_data(
         filepath, key=key, progress=progress, fast_first_frame=fast_first_frame
     ), None
@@ -2546,6 +2580,31 @@ def _load_gipl(filepath):
     return np.ascontiguousarray(arr)
 
 
+def _gipl_spatial_meta(filepath, arr):
+    """Voxel sizes from a GIPL header, so the viewer shows true proportions.
+
+    GIPL stores no orientation, so axis labels stay empty. Returns None when
+    the header has no usable voxel sizes.
+    """
+    import gzip
+
+    opener = gzip.open if filepath.lower().endswith(".gz") else open
+    with opener(filepath, "rb") as f:
+        header = f.read(_GIPL_HEADER_SIZE)
+    pixdim = np.frombuffer(header, ">f4", count=4, offset=10).astype(float)
+    n = min(arr.ndim, 3)
+    voxel_sizes = tuple(float(v) for v in pixdim[:n])
+    if not all(np.isfinite(v) and v > 0 for v in voxel_sizes):
+        return None
+    return {
+        "voxel_sizes": voxel_sizes,
+        "axis_labels": (),
+        "is_oblique": False,
+        "is_canonical": True,
+        "spatial_shape": tuple(int(v) for v in arr.shape[:n]),
+    }
+
+
 def _tensor_to_numpy(obj, source="object"):
     """Convert a tensor-like object (PyTorch, etc.) to a numpy array."""
     if isinstance(obj, np.ndarray):

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_launcher.py

@@ -3539,11 +3539,12 @@ def view(
     vmax: float | None = None,
     log: bool = False,
     complex: str | None = None,
+    voxel_size=None,
 ):
     """
     Launch the viewer. Does not block the main Python process.
 
-    Accepts one to four arrays::
+    Accepts one to six arrays (the same limit as the command line)::
 
         handle = arrayview.view(a)
         ha, hb = arrayview.view(a, b)
@@ -3588,6 +3589,10 @@ def view(
     ``"imag"`` (``"mag"`` shows the absolute value of real data). Pressing
     ``E`` in the viewer copies the current view as such a call.
 
+    ``voxel_size`` — physical size of one step along each dimension, e.g.
+    ``(1, 1, 2)`` for 1 mm pixels and 2 mm slices. Slices then show their
+    true proportions. Leading dimensions only; later ones keep size 1.
+
     Returns a ``ViewHandle`` for a single array, or a tuple of ``ViewHandle``
     objects for multiple arrays (one per array). In inline/Jupyter mode with
     multiple arrays, the IFrame is displayed automatically and a uniform tuple
@@ -3601,9 +3606,14 @@ def view(
 
     _initial_view = _session_mod.initial_view_spec(
         mode=mode, dims=dims, index=index, cmap=cmap, vmin=vmin, vmax=vmax, log=log,
-        complex=complex,
+        complex=complex, voxel_size=voxel_size,
     )
     _code_name = _caller_variable_name(arrays[0]) if arrays else None
+    # Several arrays side by side need telling apart; the caller's variable
+    # names do that better than identical "Array (shape)" labels.
+    _var_names = (
+        [_caller_variable_name(arr) for arr in arrays] if len(arrays) > 1 else []
+    )
 
     height = _normalize_inline_height(height)
     _inline_mode_heights = _normalize_inline_mode_heights(mode_heights)
@@ -3612,8 +3622,8 @@ def view(
     n_arrays = len(arrays)
     if n_arrays == 0:
         raise ValueError("view() requires at least one array.")
-    if n_arrays > 4:
-        raise ValueError(f"view() accepts at most 4 arrays, got {n_arrays}.")
+    if n_arrays > 6:
+        raise ValueError(f"view() accepts at most 6 arrays, got {n_arrays}.")
 
     # --- Normalise per-array kwargs (name, rgb) ---
     if isinstance(name, list):
@@ -3664,6 +3674,8 @@ def view(
     arrays = tuple(_convert_array(arr) for arr in arrays)
 
     # --- Apply name defaults after conversion (shape is available now) ---
+    if len(set(filter(None, _var_names))) == n_arrays:
+        names = [names[i] if names[i] is not None else _var_names[i] for i in range(n_arrays)]
     names = [
         (f"Array {getattr(arrays[i], 'shape', '?')}" if names[i] is None else names[i])
         for i in range(n_arrays)
@@ -3680,6 +3692,13 @@ def view(
                 f"index has {len(_initial_view['index'])} entries but the array "
                 f"has {_ndim} dimensions"
             )
+    if _initial_view and "voxel_size" in _initial_view:
+        _ndim = len(getattr(data, "shape", ()))
+        if len(_initial_view["voxel_size"]) > _ndim:
+            raise ValueError(
+                f"voxel_size has {len(_initial_view['voxel_size'])} entries but the "
+                f"array has {_ndim} dimensions"
+            )
 
     # --- Normalise string window modes ---
     _raw_window = window

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_platform.py

@@ -452,8 +452,17 @@ def _has_vscode_window_registration() -> bool:
 def _process_is_alive(pid: object) -> bool:
     try:
         numeric_pid = int(pid)
+    except (TypeError, ValueError):
+        return False
+    if os.name == "nt":
+        # Signal 0 is CTRL_C_EVENT on Windows: os.kill would try to interrupt
+        # a console process group rather than test whether the pid exists.
+        from arrayview._instance_registry import process_start_identity
+
+        return process_start_identity(numeric_pid) is not None
+    try:
         os.kill(numeric_pid, 0)
-    except (OSError, TypeError, ValueError):
+    except OSError:
         return False
     if sys.platform.startswith("linux"):
         try:

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_routes_preferences.py

@@ -68,6 +68,28 @@ def register_preferences_routes(app) -> None:
             return JSONResponse({"error": "session_not_found"}, status_code=404)
         return _response_payload()
 
+    @app.post("/view-memory/{sid}")
+    async def view_memory_post(sid: str, request: Request):
+        """Store the view a file was left in (Preferences → Reopen where you left off)."""
+        session = SESSIONS.get(sid)
+        if session is None:
+            return JSONResponse({"error": "session_not_found"}, status_code=404)
+        from arrayview._config import get_viewer_remember_view
+        from arrayview._view_memory import remember_view
+
+        if not get_viewer_remember_view():
+            return {"saved": False}
+        try:
+            body = await request.json()
+        except Exception:
+            return JSONResponse({"error": "invalid_json"}, status_code=400)
+        view = body.get("view") if isinstance(body, dict) else None
+        try:
+            saved = remember_view(session, view)
+        except OSError:
+            saved = False
+        return {"saved": saved}
+
     @app.patch("/preferences/{sid}")
     async def preferences_patch(sid: str, request: Request):
         if SESSIONS.get(sid) is None:

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_routes_rendering.py

@@ -360,6 +360,7 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
         session_b = SESSIONS.get(sid_b)
         if not session_a or not session_b:
             return Response(status_code=404)
+        stats: dict[str, float] = {}
         try:
             raw, vmin, vmax, colormap, nan_mask = _compute_diff(
                 session_a,
@@ -374,6 +375,7 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                 diff_mode,
                 indices_a=indices_a,
                 indices_b=indices_b,
+                stats_out=stats,
             )
         except Exception:
             return Response(status_code=422)
@@ -399,6 +401,11 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                 "X-ArrayView-Vmin": str(vmin),
                 "X-ArrayView-Vmax": str(vmax),
                 "X-ArrayView-Colormap": colormap,
+                # Numbers for the A−B title: RMS difference, largest
+                # difference, RMS difference relative to A.
+                "X-ArrayView-Diff-Rmse": str(stats.get("rmse", "nan")),
+                "X-ArrayView-Diff-Max": str(stats.get("max_abs", "nan")),
+                "X-ArrayView-Diff-Rel": str(stats.get("rel", "nan")),
             },
         )
 

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_routes_websocket.py

@@ -284,6 +284,29 @@ async def _send_json_quietly(ws, payload):
         pass
 
 
+# Viewer tabs whose slice position follows the other linked tabs (Shift+L).
+# Rides on each viewer's existing socket: VS Code tabs share one channel with
+# a small socket budget, so linking must not open connections of its own.
+_LINKED_VIEWER_SOCKETS: set = set()
+
+
+def _handle_link_message(ws, msg: dict) -> None:
+    action = msg.get("action")
+    if action == "join":
+        _LINKED_VIEWER_SOCKETS.add(ws)
+    elif action == "leave":
+        _LINKED_VIEWER_SOCKETS.discard(ws)
+    elif action == "position" and ws in _LINKED_VIEWER_SOCKETS:
+        indices = msg.get("indices")
+        shape = msg.get("shape")
+        if not isinstance(indices, list) or not isinstance(shape, list):
+            return
+        payload = {"type": "link", "indices": indices, "shape": shape}
+        for other in list(_LINKED_VIEWER_SOCKETS):
+            if other is not ws:
+                asyncio.ensure_future(_send_json_quietly(other, payload))
+
+
 def _render_rgba_from_data(data, colormap, vmin, vmax):
     if vmax > vmin:
         normalized = np.clip((data - vmin) / (vmax - vmin), 0, 1)
@@ -503,6 +526,11 @@ def register_websocket_routes(app) -> None:
             try:
                 while True:
                     msg = await ws.receive_json()
+                    if isinstance(msg, dict) and msg.get("type") == "link":
+                        # Not a frame request: answer here so it never
+                        # displaces (or is displaced by) a pending render.
+                        _handle_link_message(ws, msg)
+                        continue
                     try:
                         _pending.get_nowait()
                     except asyncio.QueueEmpty:
@@ -904,6 +932,7 @@ def register_websocket_routes(app) -> None:
                 _session_mod.LIVE_VIEWER_SOCKETS.remove(ws)
             except ValueError:
                 pass
+            _LINKED_VIEWER_SOCKETS.discard(ws)
             try:
                 from arrayview import _extra_ports
 

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_server.py

@@ -55,6 +55,8 @@ from arrayview._config import (
     get_viewer_ortho_layout,
     get_viewer_rounded_panes,
     get_viewer_qmri_gapless,
+    get_viewer_compare_gapless,
+    get_viewer_remember_view,
     get_viewer_theme,
 )
 
@@ -484,6 +486,8 @@ def _viewer_ui_response(
         .replace("__DEFAULT_THEME_IDX__", str(_default_theme_idx))
         .replace("__DEFAULT_ROUNDED_PANES__", _default_rounded_panes)
         .replace("__DEFAULT_QMRI_GAPLESS__", "true" if get_viewer_qmri_gapless() else "false")
+        .replace("__DEFAULT_COMPARE_GAPLESS__", "true" if get_viewer_compare_gapless() else "false")
+        .replace("__DEFAULT_REMEMBER_VIEW__", "true" if get_viewer_remember_view() else "false")
         .replace("__DEFAULT_ORTHO_LAYOUT__", _default_ortho_layout)
         .replace("__DEFAULT_DIMBAR_MODE__", _default_dimbar_mode)
         .replace("__BODY_CLASS__", "av-loading" if sid else "")

{arrayview-0.48.4 → arrayview-0.49.0}/src/arrayview/_session.py

@@ -690,6 +690,7 @@ def initial_view_spec(
     vmax=None,
     log=False,
     complex=None,
+    voxel_size=None,
 ) -> dict | None:
     """Validate how a caller asks the viewer to open; None when nothing is set.
 
@@ -734,6 +735,14 @@ def initial_view_spec(
         if complex not in COMPLEX_PARTS:
             raise ValueError(f"complex must be one of: {', '.join(COMPLEX_PARTS)}")
         spec["complex"] = complex
+    if voxel_size is not None:
+        try:
+            sizes = [float(v) for v in voxel_size]
+        except (TypeError, ValueError):
+            raise ValueError("voxel_size must be one size per dimension, e.g. (1, 1, 2)")
+        if not sizes or not all(np.isfinite(v) and v > 0 for v in sizes):
+            raise ValueError("voxel_size must be positive numbers, e.g. (1, 1, 2)")
+        spec["voxel_size"] = sizes
     return spec or None
 
 

arrayview-0.49.0/src/arrayview/_view_memory.py

@@ -0,0 +1,102 @@
+"""Remember the last view of each file, for Preferences → Reopen where you left off.
+
+Stored in ~/.arrayview/view_memory.json, keyed by the file's real path (plus the
+array name inside .npz/.mat files). A remembered view is only handed back for
+an array of the same shape, so a file rewritten with new dimensions starts fresh.
+A file rewritten with the same shape keeps its slice, view and colormap, but not
+its display range, which no longer fits the new values.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+import time
+
+VIEW_MEMORY_PATH = os.path.expanduser("~/.arrayview/view_memory.json")
+_MAX_ENTRIES = 200
+_RANGE_KEYS = ("manualVmin", "manualVmax")
+_LOCK = threading.Lock()
+
+
+def view_memory_key(session) -> str | None:
+    filepath = getattr(session, "filepath", None)
+    if not filepath:
+        return None
+    try:
+        key = os.path.realpath(str(filepath))
+    except (OSError, ValueError):
+        return None
+    array_key = getattr(session, "array_key", None)
+    return f"{key}#{array_key}" if array_key else key
+
+
+def _file_signature(session) -> list | None:
+    from arrayview._session import file_signature
+
+    sig = file_signature(str(session.filepath))
+    return list(sig) if sig else None
+
+
+def _load() -> dict:
+    try:
+        with open(VIEW_MEMORY_PATH, encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _save(entries: dict) -> None:
+    folder = os.path.dirname(VIEW_MEMORY_PATH)
+    os.makedirs(folder, exist_ok=True)
+    fd, temp_path = tempfile.mkstemp(prefix=".view_memory.", suffix=".tmp", dir=folder)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(entries, f)
+        os.replace(temp_path, VIEW_MEMORY_PATH)
+    except Exception:
+        try:
+            os.unlink(temp_path)
+        except FileNotFoundError:
+            pass
+        raise
+
+
+def remembered_view(session) -> dict | None:
+    key = view_memory_key(session)
+    if key is None:
+        return None
+    with _LOCK:
+        entry = _load().get(key)
+    if not isinstance(entry, dict) or not isinstance(entry.get("view"), dict):
+        return None
+    if entry.get("shape") != [int(s) for s in session.shape]:
+        return None
+    view = dict(entry["view"])
+    if entry.get("signature") is None or entry.get("signature") != _file_signature(session):
+        for k in _RANGE_KEYS:
+            view.pop(k, None)
+    return view
+
+
+def remember_view(session, view: dict) -> bool:
+    key = view_memory_key(session)
+    if key is None or not isinstance(view, dict):
+        return False
+    with _LOCK:
+        entries = _load()
+        entries[key] = {
+            "shape": [int(s) for s in session.shape],
+            "view": view,
+            "signature": _file_signature(session),
+            "updated": time.time(),
+        }
+        if len(entries) > _MAX_ENTRIES:
+            oldest = sorted(entries, key=lambda k: entries[k].get("updated", 0) if isinstance(entries[k], dict) else 0)
+            for stale in oldest[: len(entries) - _MAX_ENTRIES]:
+                entries.pop(stale, None)
+        _save(entries)
+    return True