arrayview 0.35.3__tar.gz → 0.36.0__tar.gz

{arrayview-0.35.3 → arrayview-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.35.3
+Version: 0.36.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.35.3 → arrayview-0.36.0}/pyproject.toml

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

{arrayview-0.35.3 → arrayview-0.36.0}/src/arrayview/_launcher.py

@@ -2590,6 +2590,11 @@ _PERSIST_DAEMON_CONNECT_TIMEOUT_SECONDS = float(
 _PERSIST_DAEMON_IDLE_SECONDS = float(
     os.environ.get("ARRAYVIEW_PERSIST_IDLE_SECONDS", "1800")
 )
+# How long a daemon whose initial load failed keeps serving so the opener can
+# read the reason from /metadata/<sid> before the port is released.
+_FAILED_LOAD_EXIT_GRACE_SECONDS = float(
+    os.environ.get("ARRAYVIEW_FAILED_LOAD_EXIT_GRACE_SECONDS", "30")
+)
 
 
 def _join_query_values(values: _CSVValues) -> str:
@@ -4169,6 +4174,7 @@ def _serve_daemon(
         owner="persistent" if persist else "transient",
     )
     # Register sid as pending so /metadata can poll while data loads.
+    _initial_load_failed = threading.Event()
     _session_mod.PENDING_SESSIONS.add(sid)
     _pending_event = threading.Event()
     _session_mod.PENDING_SESSION_EVENTS[sid] = _pending_event
@@ -4349,6 +4355,18 @@ def _serve_daemon(
                 sid_tag=sid_tag,
                 error_type=type(exc).__name__,
             )
+            # This runs on a daemon thread, so re-raising only kills the thread
+            # and writes to a stderr nobody reads. Record why the sid will never
+            # become ready so /metadata can report it instead of returning 404
+            # until the opener gives up.
+            _session_mod.FAILED_PENDING_SESSIONS[sid] = (
+                str(exc) or type(exc).__name__
+            )
+            _vprint(
+                f"[ArrayView] Failed to load {filepath}: {exc}",
+                flush=True,
+            )
+            _initial_load_failed.set()
             raise
         finally:
             _session_mod.PENDING_SESSIONS.discard(sid)
@@ -4357,6 +4375,32 @@ def _serve_daemon(
 
     threading.Thread(target=_load, daemon=True).start()
 
+    def _exit_if_initial_load_failed() -> None:
+        """Release the port when the file this daemon exists to serve won't load.
+
+        uvicorn starts before the load finishes, so a failed load otherwise
+        leaves a server with no session holding the port until the connect
+        timeout expires minutes later — and answering /ping the whole time. The
+        grace period is only so the opener can read the failure from
+        /metadata/<sid> before the port goes away.
+        """
+        _initial_load_failed.wait()
+        time.sleep(_FAILED_LOAD_EXIT_GRACE_SECONDS)
+        if _session_mod.SESSIONS or _session_mod.VIEWER_SOCKETS:
+            return  # something else is using this server; leave it alone
+        _trace_launch_event(
+            "daemon.exiting",
+            reason="initial_load_failed",
+            instance_tag=_launch_trace_tag(record.instance_id),
+        )
+        try:
+            registry.remove(record.instance_id)
+        except Exception:
+            pass
+        os._exit(0)
+
+    threading.Thread(target=_exit_if_initial_load_failed, daemon=True).start()
+
     if persist:
         _wait_for_viewer_close(
             idle_seconds=_PERSIST_DAEMON_IDLE_SECONDS,

{arrayview-0.35.3 → arrayview-0.36.0}/src/arrayview/_routes_loading.py

@@ -18,6 +18,7 @@ from arrayview._lifecycle import (
 )
 from arrayview._session import (
     CANCELLED_PENDING_SESSIONS,
+    FAILED_PENDING_SESSIONS,
     PENDING_SESSION_EVENTS,
     PENDING_SESSIONS,
     SESSIONS,
@@ -263,6 +264,7 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
             # the real Session instead of seeing a transient 404.
             sid = requested_sid or uuid.uuid4().hex
             pending_event = threading.Event()
+            FAILED_PENDING_SESSIONS.pop(sid, None)
             PENDING_SESSIONS.add(sid)
             PENDING_SESSION_EVENTS[sid] = pending_event
             signature_before_load = file_signature(abs_path)
@@ -293,12 +295,14 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
                     ]
                     commit_pending_session(sid, session)
                 except Exception as exc:
-                    # Keep the server alive and make the failure visible in its
-                    # log. The opener will fail closed when metadata never
-                    # becomes ready, while a retry creates a fresh request.
+                    # Keep the server alive, and record why this sid will never
+                    # become ready. Without the record the opener cannot tell a
+                    # failed load from a slow one and burns its whole deadline
+                    # on a file that raised immediately.
                     import traceback
 
                     traceback.print_exc()
+                    FAILED_PENDING_SESSIONS[sid] = str(exc) or exc.__class__.__name__
                 finally:
                     PENDING_SESSIONS.discard(sid)
                     CANCELLED_PENDING_SESSIONS.discard(sid)

{arrayview-0.35.3 → arrayview-0.36.0}/src/arrayview/_routes_query.py

@@ -211,6 +211,14 @@ def register_query_routes(app, *, get_session_or_404, pil_image, pil_imageops) -
         # request; the opener retries until the pending Session is published.
         if sid in _session_mod.PENDING_SESSIONS:
             return Response(status_code=404, headers={"Retry-After": "1"})
+        # A load that raised is terminal. Say so with a distinct status and the
+        # real reason, so the caller stops polling and can show the user why
+        # this file will never open instead of waiting out its deadline.
+        load_error = _session_mod.FAILED_PENDING_SESSIONS.get(sid)
+        if load_error is not None:
+            return Response(
+                status_code=422, content=load_error.encode(), media_type="text/plain"
+            )
         session = await wait_for_session_ready(sid)
         if not session:
             return Response(status_code=404)

{arrayview-0.35.3 → arrayview-0.36.0}/src/arrayview/_session.py

@@ -41,6 +41,10 @@ _window_process = None
 PENDING_SESSIONS: set = set()  # sids whose data is still loading in a background thread
 PENDING_SESSION_EVENTS: dict[str, threading.Event] = {}
 CANCELLED_PENDING_SESSIONS: set[str] = set()
+# sid -> why its background load failed. A load that raises must be reportable:
+# without this the opener cannot tell "still loading" from "will never load" and
+# waits out its whole deadline on a file that failed in the first second.
+FAILED_PENDING_SESSIONS: dict[str, str] = {}
 
 
 def file_signature(filepath: str):
@@ -575,6 +579,7 @@ __all__ = [
     "_window_process",
     "PENDING_SESSIONS",
     "PENDING_SESSION_EVENTS",
+    "FAILED_PENDING_SESSIONS",
     "wait_for_session_ready",
     # Render thread pool
     "_RENDER_QUEUE",

{arrayview-0.35.3 → arrayview-0.36.0}/src/arrayview/_viewer.html

@@ -9278,7 +9278,20 @@
         function formatValueGroup(values, options = {}) {
             const finite = (Array.isArray(values) ? values : [values]).filter(Number.isFinite);
             const cap = Math.max(0, Math.min(8, Math.trunc(options.maxDecimals ?? 7)));
-            const minDecimals = Math.max(0, Math.min(cap, Math.trunc(options.minDecimals ?? 2)));
+            // Decimals worth showing depend on magnitude. Two was applied at
+            // every scale, so a range topping out near 1890 read as "1890.04"
+            // when the hundredths carry no information. The floor is only ever
+            // lowered for large values, never raised, so small ranges keep the
+            // precision they had. The search below can still add decimals when
+            // values would otherwise collide.
+            const _defaultMinDecimals = (vals) => {
+                const m = Math.max(...vals.filter(Number.isFinite).map(v => Math.abs(v)));
+                if (!(m > 0) || !Number.isFinite(m)) return 2;
+                return Math.max(0, Math.min(2, 3 - Math.floor(Math.log10(m))));
+            };
+            const minDecimals = Math.max(0, Math.min(cap, Math.trunc(
+                options.minDecimals ?? _defaultMinDecimals(finite)
+            )));
             const ordinaryLo = options.ordinaryLo ?? 1e-4;
             const ordinaryHi = options.ordinaryHi ?? 1e6;
             const fallback = {
@@ -14242,6 +14255,41 @@
 
         /* ── JS: Initialization and Metadata Fetch ────────────────── */
 
+        // The backend serves this page as soon as its port is up, which can be
+        // seconds before a large array has finished loading. While the session
+        // is still loading /metadata answers 404 with a Retry-After header; an
+        // unknown or released sid answers 404 without one, and a load that
+        // failed answers 422 with the reason. Keep waiting only for the first.
+        async function fetchMetadataWithRetry(sid, timeoutMs = 180000) {
+            const deadline = Date.now() + timeoutMs;
+            for (;;) {
+                const res = await proxyFetch(`/metadata/${sid}`);
+                if (res.ok) return { data: await res.json() };
+                if (res.status === 422) {
+                    let reason = '';
+                    try { reason = (await res.text()).trim(); } catch (_e) {}
+                    return { error: reason || 'This file could not be loaded.', status: 422 };
+                }
+                const pending = res.status === 404 && res.headers.get('Retry-After');
+                if (!pending || Date.now() >= deadline) {
+                    return { error: null, status: res.status };
+                }
+                await new Promise(r => setTimeout(r, 300));
+            }
+        }
+
+        function showMetadataError(result) {
+            const msg = result.error
+                ? result.error
+                : (result.status === 404
+                    ? 'Session not found or expired.'
+                    : `Server error ${result.status} — check Python console for details.`);
+            document.getElementById('loading-overlay').innerHTML =
+                `<div style="color:#c55;font-size:16px;font-family:monospace;max-width:60ch;text-align:center;line-height:1.5;padding:0 2em">${
+                    msg.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+                }</div>`;
+        }
+
         async function init() {
             // Loading spinner is in static HTML — body.av-loading set by server template.
             if (!sid) { hideLoadingOverlay(); drawPlasmaDemo(); return; }
@@ -14260,26 +14308,24 @@
                 );
                 data = await Promise.race([_metadataFromWs, httpFallback]);
                 if (!data) {
-                    // Both failed — try direct HTTP without timeout
-                    const res = await proxyFetch(`/metadata/${sid}`);
-                    if (!res.ok) {
-                        reportParent('metadata-http-error', { status: res.status, sid });
-                        const msg = res.status === 404 ? 'Session not found or expired.' : `Server error ${res.status} — check Python console for details.`;
-                        document.getElementById('loading-overlay').innerHTML = `<div style="color:#c55;font-size:18px;font-family:monospace">${msg}</div>`;
+                    // Both failed — wait out a still-loading session.
+                    const result = await fetchMetadataWithRetry(sid);
+                    if (!result.data) {
+                        reportParent('metadata-http-error', { status: result.status, sid });
+                        showMetadataError(result);
                         return;
                     }
-                    data = await res.json();
+                    data = result.data;
                 }
             } else {
                 // HTTP transport mode (VS Code) — use traditional fetch
-                const res = await proxyFetch(`/metadata/${sid}`);
-                if (!res.ok) {
-                    reportParent('metadata-http-error', { status: res.status, sid });
-                    const msg = res.status === 404 ? 'Session not found or expired.' : `Server error ${res.status} — check Python console for details.`;
-                    document.getElementById('loading-overlay').innerHTML = `<div style="color:#c55;font-size:18px;font-family:monospace">${msg}</div>`;
+                const result = await fetchMetadataWithRetry(sid);
+                if (!result.data) {
+                    reportParent('metadata-http-error', { status: result.status, sid });
+                    showMetadataError(result);
                     return;
                 }
-                data = await res.json();
+                data = result.data;
             }
 
             await _loadOverlayLabelValues();
@@ -35919,9 +35965,12 @@
                 return `${x.toFixed(1)},${y.toFixed(1)}`;
             }).join(' ');
             const distLabel = distance.toFixed(1) + ' px';
+            // Share the colorbar's formatter so the same value does not read
+            // differently here than it does on the colorbar.
+            const _lpFmt = formatValueGroup([vMin, vMax]);
             const fmtVal = v => {
                 if (v === null || !isFinite(v)) return '?';
-                return Math.abs(v) < 0.01 || Math.abs(v) >= 1e4 ? v.toExponential(2) : v.toFixed(2);
+                return _lpFmt.format(v);
             };
             _lineProfileOverlay.innerHTML = `
                 <svg width="${W}" height="${H}" xmlns="http://www.w3.org/2000/svg">

{arrayview-0.35.3 → arrayview-0.36.0}/src/arrayview/_vscode_extension.py

@@ -54,7 +54,7 @@ _VSCODE_EXT_INSTALLED = False  # cached so we only check once per process
 _VSCODE_EXT_FRESH_INSTALL = False  # True if we just installed it this session
 _VSCODE_EXT_RELOAD_REQUIRED = False  # installed files are newer than the live host
 _VSCODE_EXT_INSTALL_FAILED = False  # automatic install could not complete safely
-_VSCODE_EXT_VERSION = "0.14.80"  # current bundled extension version
+_VSCODE_EXT_VERSION = "0.14.87"  # current bundled extension version
 _VSCODE_CONFIGURED_PORTS: set[int] = set()
 
 def _bundled_vscode_vsix_version(vsix_path: str) -> str | None:
@@ -633,6 +633,47 @@ def _ensure_vscode_extension(*, is_remote: bool | None = None) -> bool:
 # ---------------------------------------------------------------------------
 
 
+def _port_has_listener(port: int) -> bool:
+    """Return True when something is listening on ``port`` on loopback."""
+    import socket
+
+    for family, addr in ((socket.AF_INET, "127.0.0.1"), (socket.AF_INET6, "::1")):
+        sock = socket.socket(family, socket.SOCK_STREAM)
+        try:
+            sock.settimeout(0.15)
+            if sock.connect_ex((addr, port)) == 0:
+                return True
+        except OSError:
+            continue
+        finally:
+            sock.close()
+    return False
+
+
+def _stale_arrayview_port_keys(attrs: dict, keep_port: int) -> list[str]:
+    """Return ArrayView port entries that no longer have a live server.
+
+    Every launch on a fresh port used to leave its entry behind for good. On a
+    tunnel those entries keep telling VS Code to forward ports nothing serves,
+    which competes for a limited per-tunnel forwarding budget. Only entries
+    ArrayView wrote are considered, and only when their port is dead, so a
+    second concurrent ArrayView server is never disturbed.
+    """
+    stale: list[str] = []
+    for key, value in list(attrs.items()):
+        if not isinstance(value, dict) or value.get("label") != "ArrayView":
+            continue
+        if key == str(keep_port):
+            continue
+        try:
+            candidate = int(key)
+        except (TypeError, ValueError):
+            continue
+        if not _port_has_listener(candidate):
+            stale.append(key)
+    return stale
+
+
 def _configure_vscode_port_preview(
     port: int,
     *,
@@ -686,8 +727,11 @@ def _configure_vscode_port_preview(
         }
         current = attrs.get(str(port))
         updated = {**current, **desired} if isinstance(current, dict) else desired
-        if current == updated:
+        stale = _stale_arrayview_port_keys(attrs, port)
+        if current == updated and not stale:
             return
+        for key in stale:
+            attrs.pop(key, None)
         attrs[str(port)] = updated
         with open(path, "w") as f:
             json.dump(settings, f, indent=2)

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_api.py

@@ -6754,7 +6754,7 @@ def _isolate_view_planner(
             if port in alive_ports
             else (),
             "1" if port in alive_ports else None,
-            server_uid=os.geteuid() if port in alive_ports else None,
+            server_uid=os.geteuid() if hasattr(os, "geteuid") and port in alive_ports else None,
         ),
     )
     if alive_ports:

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_cli.py

@@ -13,6 +13,7 @@ import pytest
 import arrayview._app as appmod
 import arrayview._launch_plan as _launch_plan_mod
 import arrayview._launcher as _launcher_mod
+import arrayview._platform as _platform_mod
 
 
 class _DummyResponse:
@@ -60,7 +61,7 @@ def _mock_launch_server_snapshot(monkeypatch, *, alive: bool, busy: bool | None
             None,
             ("identity-fenced-load", "identity-fenced-mutations") if alive else (),
             "1" if alive else None,
-            server_uid=os.geteuid() if alive else None,
+            server_uid=os.geteuid() if hasattr(os, "geteuid") and alive else None,
         ),
     )
     if alive:
@@ -263,6 +264,7 @@ def test_cli_stack_existing_server_has_remote_flag_before_register(monkeypatch,
     assert calls[0]["dir_patterns"] == [os.path.abspath(base_pattern)]
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="VSCode terminal readiness test is Unix-specific")
 def test_cli_vscode_terminal_requires_extension_readiness_ack(tmp_path):
     arr_path = tmp_path / "base.npy"
     np.save(arr_path, np.zeros((8, 8), dtype=np.float32))
@@ -690,6 +692,8 @@ def test_cli_existing_server_native_injection_skips_browser(monkeypatch, tmp_pat
     _mock_launch_server_snapshot(monkeypatch, alive=True)
     monkeypatch.setattr(_launch_plan_mod, "_native_window_gui", lambda: "webview")
     monkeypatch.setattr(_launcher_mod, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(_platform_mod, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(_platform_mod, "_in_vscode_terminal", lambda: False)
     monkeypatch.setattr(
         _launcher_mod,
         "_open_browser",
@@ -737,6 +741,8 @@ def test_cli_existing_server_native_shell_connection_skips_browser(
     _mock_launch_server_snapshot(monkeypatch, alive=True)
     monkeypatch.setattr(_launch_plan_mod, "_native_window_gui", lambda: "webview")
     monkeypatch.setattr(_launcher_mod, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(_platform_mod, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(_platform_mod, "_in_vscode_terminal", lambda: False)
     monkeypatch.setattr(
         _launcher_mod,
         "_open_webview_cli_tracked",
@@ -805,6 +811,8 @@ def test_cli_spawn_daemon_opens_viewer_url(monkeypatch, tmp_path):
         lambda port: ("spawned-server", "process-start", 43210),
     )
     monkeypatch.setattr(_launcher_mod, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(_platform_mod, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(_platform_mod, "_in_vscode_terminal", lambda: False)
     monkeypatch.setattr(
         _launcher_mod.subprocess,
         "Popen",

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_instance_registry.py

@@ -4,6 +4,7 @@ import os
 from pathlib import Path
 import subprocess
 import sys
+import sys
 import time
 
 import pytest
@@ -164,11 +165,12 @@ def test_runtime_directory_override(monkeypatch, tmp_path):
     assert runtime_directory() == tmp_path / "custom"
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="UID-based directory resolution is Unix-only")
 def test_runtime_directory_is_per_uid_without_override(monkeypatch, tmp_path):
     monkeypatch.delenv("ARRAYVIEW_RUNTIME_DIR", raising=False)
     monkeypatch.delenv("XDG_RUNTIME_DIR", raising=False)
     monkeypatch.setattr("arrayview._instance_registry.tempfile.gettempdir", lambda: str(tmp_path))
-    current_uid = os.getuid()
+    current_uid = os.getuid() if hasattr(os, "getuid") else 1000
     first = runtime_directory()
     monkeypatch.setattr("arrayview._instance_registry.os.getuid", lambda: current_uid + 1)
     second = runtime_directory()

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_invocation_contract_matrix.py

@@ -7,6 +7,7 @@ remote extension host and therefore belong in the tunnel handoff, not mocks.
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass
 
 import pytest
@@ -147,6 +148,7 @@ def test_compatible_server_reuse_is_identical_for_every_adapter(case, platform):
         "contract-process-start",
         ("identity-fenced-load", "identity-fenced-mutations"),
         "1",
+        server_uid=os.geteuid() if hasattr(os, "geteuid") else None,
     )
 
     plan = plan_launch(

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_launch_diagnostics.py

@@ -3,6 +3,7 @@ import socket
 import sys
 
 import arrayview._launcher as launcher
+import arrayview._platform as _platform_mod
 
 
 def _free_port() -> int:
@@ -18,6 +19,8 @@ def test_diagnose_serializes_shared_snapshot_and_plan(monkeypatch, capsys):
         "argv",
         ["arrayview", "--diagnose", "--port", str(port), "--window", "browser"],
     )
+    monkeypatch.setattr(_platform_mod, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(_platform_mod, "_in_vscode_terminal", lambda: False)
 
     launcher.arrayview()
 

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_launch_execution_ownership.py

@@ -168,7 +168,8 @@ def test_http_load_plan_fails_closed_when_selected_server_changes(
             "planned-process-start",
             ("identity-fenced-load", "identity-fenced-mutations"),
             "1",
-            server_uid=os.geteuid(),
+            server_uid=os.geteuid() if hasattr(os, "geteuid") else None,
+
         ),
     )
     monkeypatch.setattr(
@@ -224,7 +225,8 @@ def test_display_error_after_http_registration_is_not_relabelled(monkeypatch):
             "planned-process-start",
             ("identity-fenced-load", "identity-fenced-mutations"),
             "1",
-            server_uid=os.geteuid(),
+            server_uid=os.geteuid() if hasattr(os, "geteuid") else None,
+
         ),
     )
     monkeypatch.setattr(

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_launch_plan.py

@@ -586,7 +586,8 @@ def test_remote_python_reuses_healthy_cli_default_server():
             "remote-process-start",
             ("identity-fenced-load", "identity-fenced-mutations"),
             "1",
-            server_uid=os.geteuid(),
+            server_uid=os.geteuid() if hasattr(os, "geteuid") else None,
+
         ),
     )
     plan = plan_launch(LaunchIntent(Invocation.PYTHON, 8123), facts)
@@ -662,7 +663,8 @@ def test_existing_server_is_reused_through_http():
             "process-start",
             ("identity-fenced-load", "identity-fenced-mutations"),
             "1",
-            server_uid=os.geteuid(),
+            server_uid=os.geteuid() if hasattr(os, "geteuid") else None,
+
         )
     )
     plan = plan_launch(LaunchIntent(Invocation.CLI, 8123), facts)
@@ -671,6 +673,7 @@ def test_existing_server_is_reused_through_http():
     assert plan.registration.value == "http_load"
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="UID checks are Unix-only")
 @pytest.mark.parametrize(
     "server_uid",
     [None, os.geteuid() + 1 if hasattr(os, "geteuid") else -1],

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_lifecycle_contract.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 import os
+import sys
 from threading import Thread as RealThread
 
 import numpy as np
@@ -388,6 +389,7 @@ def test_vscode_tunnel_open_request_is_remote_only(monkeypatch, tmp_path):
     assert captured[0]["remoteOnly"] is True
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_vscode_extension_disk_check_is_scoped_to_remote_host(monkeypatch, tmp_path):
     import arrayview._vscode_extension as extension
 
@@ -405,6 +407,7 @@ def test_vscode_extension_disk_check_is_scoped_to_remote_host(monkeypatch, tmp_p
     assert extension._extension_on_disk("1.2.3", remote=True) is True
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 @pytest.mark.parametrize("remote", [False, True])
 def test_vscode_extension_missing_hash_verifies_content_without_reinstall(
     monkeypatch, tmp_path, remote
@@ -503,6 +506,7 @@ def test_vscode_port_settings_preserve_unreadable_jsonc(monkeypatch, tmp_path):
     assert settings_path.read_text() == original
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_vscode_port_settings_are_idempotent_and_preserve_extra_keys(
     monkeypatch, tmp_path
 ):
@@ -535,6 +539,7 @@ def test_vscode_port_settings_are_idempotent_and_preserve_extra_keys(
     assert settings_path.read_text() == first
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_vscode_extension_cleanup_never_removes_newer_version(monkeypatch, tmp_path):
     import arrayview._vscode_extension as extension
 
@@ -554,14 +559,14 @@ def test_vscode_extension_cleanup_never_removes_newer_version(monkeypatch, tmp_p
 def test_vscode_extension_keeps_newer_install_without_downgrading(monkeypatch, tmp_path):
     import arrayview._vscode_extension as extension
 
-    home = tmp_path / "home"
     newer_version = "99.0.0"
-    (home / ".vscode" / "extensions" / f"arrayview.arrayview-opener-{newer_version}").mkdir(
-        parents=True
-    )
-    monkeypatch.setenv("HOME", str(home))
     monkeypatch.setattr(extension, "_is_vscode_remote", lambda: False)
     monkeypatch.setattr(extension, "_active_extension_version", lambda: newer_version)
+    monkeypatch.setattr(extension, "_active_extension_registration", lambda: None)
+    monkeypatch.setattr(extension, "_extension_on_disk", lambda *args, **kwargs: False)
+    monkeypatch.setattr(
+        extension, "_newer_extension_on_disk", lambda *args, **kwargs: newer_version
+    )
     monkeypatch.setattr(
         extension.subprocess,
         "run",
@@ -600,6 +605,7 @@ def test_vscode_extension_install_timeout_fails_closed_for_stale_host(monkeypatc
     assert extension._VSCODE_EXT_RELOAD_REQUIRED is True
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_remote_vscode_launch_automatically_runs_exact_installer(monkeypatch, tmp_path):
     import subprocess
     import arrayview._vscode_extension as extension
@@ -634,6 +640,7 @@ def test_remote_vscode_launch_automatically_runs_exact_installer(monkeypatch, tm
     assert extension._VSCODE_EXT_RELOAD_REQUIRED is False
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_active_extension_version_prefers_live_ipc_over_stale_terminal_env(
     monkeypatch, tmp_path
 ):
@@ -660,6 +667,7 @@ def test_active_extension_version_prefers_live_ipc_over_stale_terminal_env(
     assert extension._active_extension_version() == "0.14.70"
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_active_extension_version_recovers_revived_terminal_from_exact_server(
     monkeypatch, tmp_path
 ):
@@ -772,6 +780,7 @@ def test_extension_activation_wait_requires_fresh_exact_registration(monkeypatch
     )
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_remote_vscode_setup_touches_only_active_extension_base(
     monkeypatch, tmp_path
 ):
@@ -811,6 +820,7 @@ def test_remote_vscode_setup_touches_only_active_extension_base(
     assert (remote_base / f"arrayview.arrayview-opener-{old_version}").is_dir()
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix-specific VS Code extension lifecycle")
 def test_remote_vscode_install_requires_exact_activation_before_launch(
     monkeypatch, tmp_path
 ):

{arrayview-0.35.3 → arrayview-0.36.0}/tests/test_public_invocation_regressions.py

@@ -91,6 +91,7 @@ def test_public_cli_explicit_native_in_local_vscode_never_signals_extension(
             None,
             ("identity-fenced-load", "identity-fenced-mutations"),
             "1",
+            server_uid=os.geteuid() if hasattr(os, "geteuid") else None,
         ),
     )
     monkeypatch.setattr(

arrayview-0.36.0/tests/test_value_formatting.py

@@ -0,0 +1,126 @@
+"""Behavioural coverage for the viewer's shared vmin/vmax formatter.
+
+`formatValueGroup` decides how many decimals every colorbar label, range
+readout and line-profile axis shows. The rule is numeric, so asserting on the
+source text would not catch a change in what the user actually sees. These
+tests extract the function and execute it.
+"""
+
+import json
+import shutil
+import subprocess
+import textwrap
+from pathlib import Path
+
+import pytest
+
+VIEWER_HTML = Path(__file__).parent.parent / "src" / "arrayview" / "_viewer.html"
+
+pytestmark = pytest.mark.skipif(
+    shutil.which("node") is None, reason="node is required to execute viewer JS"
+)
+
+
+def _extract_function(source: str, name: str) -> str:
+    """Return the full text of a top-level `function <name>(...) { ... }`.
+
+    Brace counting has to start after the parameter list: a default such as
+    `options = {}` would otherwise close the body before it opened.
+    """
+    start = source.index(f"function {name}(")
+    paren_depth = 0
+    body_start = None
+    for index in range(start, len(source)):
+        char = source[index]
+        if char == "(":
+            paren_depth += 1
+        elif char == ")":
+            paren_depth -= 1
+            if paren_depth == 0:
+                body_start = source.index("{", index)
+                break
+    assert body_start is not None, f"could not find parameter list of {name}"
+
+    depth = 0
+    for index in range(body_start, len(source)):
+        char = source[index]
+        if char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+            if depth == 0:
+                return source[start : index + 1]
+    raise AssertionError(f"unbalanced braces while extracting {name}")
+
+
+def _format_pairs(pairs):
+    """Format each [lo, hi] pair through the real viewer implementation."""
+    fn = _extract_function(VIEWER_HTML.read_text(), "formatValueGroup")
+    script = textwrap.dedent(
+        """
+        const _escapeHtml = (s) => String(s);
+        __FN__
+        const pairs = __PAIRS__;
+        const out = pairs.map((pair) => {
+            const [values, options] = pair;
+            const fmt = formatValueGroup(values, options || {});
+            return values.map((v) => fmt.format(v));
+        });
+        process.stdout.write(JSON.stringify(out));
+        """
+    ).replace("__FN__", fn).replace("__PAIRS__", json.dumps(pairs))
+    result = subprocess.run(
+        ["node", "-e", script], capture_output=True, text=True, timeout=60
+    )
+    assert result.returncode == 0, result.stderr
+    return json.loads(result.stdout)
+
+
+def test_large_ranges_drop_meaningless_decimals():
+    """A range topping out near 1890 should not advertise hundredths."""
+    (near_two_thousand,), = _format_pairs([[[0, 1890.04], None]]),
+    assert near_two_thousand == ["0", "1890"]
+
+
+def test_small_ranges_keep_their_precision():
+    """Lowering the floor for large values must not coarsen small ones."""
+    results = _format_pairs(
+        [
+            [[0, 0.5], None],
+            [[1.23456, 9.87654], None],
+            [[0, 3.14159265], None],
+            [[0, 0.00123], None],
+        ]
+    )
+    assert results[0] == ["0.00", "0.50"]
+    assert results[1] == ["1.23", "9.88"]
+    assert results[2] == ["0.00", "3.14"]
+    assert results[3] == ["0.000", "0.001"]
+
+
+def test_vmin_and_vmax_share_a_decimal_count():
+    """The pair must never read as e.g. "0.1" beside "1890.0421"."""
+    for values in ([0, 1890.04], [0.5, 18.9], [100.5, 100.6], [-1890.04, 1890.04]):
+        low, high = _format_pairs([[values, None]])[0]
+        assert low.partition(".")[2].__len__() == high.partition(".")[2].__len__(), (
+            f"{values} rendered as {low} / {high}"
+        )
+
+
+def test_close_values_stay_distinguishable():
+    """Rounding must never collapse two different values into one label."""
+    for values in ([100.5, 100.6], [1000000, 1000001], [-0.001, 0.001]):
+        low, high = _format_pairs([[values, None]])[0]
+        assert low != high, f"{values} both rendered as {low}"
+
+
+def test_non_finite_and_degenerate_inputs_are_safe():
+    results = _format_pairs([[[0, 0], None]])
+    assert results[0] == ["0", "0"]
+
+
+def test_explicit_min_decimals_still_wins():
+    """The pixel readout asks for three decimals; that override must hold."""
+    low, high = _format_pairs([[[0, 1890.04], {"minDecimals": 3, "maxDecimals": 7}]])[0]
+    assert high == "1890.040"
+    assert low == "0.000"