arrayview 0.26.2__py3-none-any.whl → 0.27.0__py3-none-any.whl

arrayview/_analysis.py

@@ -67,7 +67,7 @@ def _safe_float(v) -> float | None:
     return f if np.isfinite(f) else None
 
 
-def _histogram_payload(finite: np.ndarray, bins: int) -> dict:
+def _histogram_payload(finite: np.ndarray, bins: int, log_bins: bool = False) -> dict:
     """Build a histogram response from finite values."""
     if finite.size == 0:
         return {"counts": [], "edges": [], "vmin": 0.0, "vmax": 1.0}
@@ -81,7 +81,13 @@ def _histogram_payload(finite: np.ndarray, bins: int) -> dict:
             "vmax": vmax,
         }
     bins = max(8, min(int(bins), 512))
-    counts, edges = np.histogram(finite, bins=bins)
+    if log_bins and vmin > 0:
+        log_data = np.log10(finite)
+        _, log_edges = np.histogram(log_data, bins=bins)
+        edges = np.power(10.0, log_edges)
+        counts, _ = np.histogram(finite, bins=edges)
+    else:
+        counts, edges = np.histogram(finite, bins=bins)
     return {
         "counts": counts.tolist(),
         "edges": [float(e) for e in edges],
@@ -113,7 +119,8 @@ def _slice_histogram(
     data = apply_complex_mode(raw, complex_mode)
     finite = data.ravel()
     finite = finite[np.isfinite(finite)]
-    return _histogram_payload(finite, bins)
+    log_bins = qmri_role in ("t1", "t2")
+    return _histogram_payload(finite, bins, log_bins=log_bins)
 
 
 def _parse_fixed_indices(fixed_indices: str) -> dict[int, int]:
@@ -172,6 +179,7 @@ def _volume_histogram(
         session, dim_x, dim_y, scroll_dim, scroll_dims
     )
 
+    log_bins = qmri_role in ("t1", "t2")
     cache_key = (
         dim_x,
         dim_y,
@@ -179,6 +187,8 @@ def _volume_histogram(
         tuple(sorted(fixed.items())),
         complex_mode,
         qmri_role,
+        bins,
+        log_bins,
     )
     if not hasattr(session, "_volume_hist_cache"):
         session._volume_hist_cache = {}
@@ -224,7 +234,7 @@ def _volume_histogram(
             pixels.append(finite)
 
     if pixels:
-        result = _histogram_payload(np.concatenate(pixels), bins)
+        result = _histogram_payload(np.concatenate(pixels), bins, log_bins=log_bins)
     else:
         result = {"counts": [], "edges": [], "vmin": 0.0, "vmax": 1.0}
     session._volume_hist_cache[cache_key] = {
@@ -241,14 +251,19 @@ def _lebesgue_slice(
     indices,
     complex_mode: int = 0,
     log_scale: bool = False,
+    qmri_role: str = "",
 ) -> np.ndarray:
     """Return float32 slice data for Lebesgue mode."""
+    from arrayview._synthetic_mri import normalize_relaxation_ms
+
     idx_tuple = (
         tuple(int(v) for v in indices.split(","))
         if isinstance(indices, str)
         else tuple(indices)
     )
     raw = extract_slice(session, dim_x, dim_y, list(idx_tuple))
+    if qmri_role:
+        raw = normalize_relaxation_ms(raw, qmri_role)
     data = apply_complex_mode(raw, complex_mode).astype(np.float32)
     if log_scale:
         data = np.log10(np.abs(data) + 1).astype(np.float32)

arrayview/_launch_plan.py

@@ -0,0 +1,285 @@
+"""Data-only launch routing primitives and environment snapshots."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from enum import Enum
+import json
+import os
+import socket
+import sys
+import urllib.request
+
+_LOOPBACK_HOST = "localhost"
+_PING_TIMEOUT_SECONDS = 0.2
+
+_SNAPSHOT_ENV_KEYS = (
+    "ARRAYVIEW_WINDOW",
+    "ARRAYVIEW_WINDOW_ID",
+    "DISPLAY",
+    "TERM_PROGRAM",
+    "VSCODE_AGENT_FOLDER",
+    "VSCODE_INJECTION",
+    "VSCODE_IPC_HOOK_CLI",
+    "WAYLAND_DISPLAY",
+    "SSH_CLIENT",
+    "SSH_CONNECTION",
+)
+
+
+class _StrEnum(str, Enum):
+    def __str__(self) -> str:
+        return self.value
+
+
+class Invocation(_StrEnum):
+    CLI = "cli"
+    PYTHON = "python"
+    JUPYTER = "jupyter"
+    JULIA = "julia"
+    STDIO = "stdio"
+    CODEX = "codex"
+
+
+class Environment(_StrEnum):
+    TERMINAL = "terminal"
+    VSCODE_LOCAL = "vscode_local"
+    VSCODE_REMOTE = "vscode_remote"
+    SSH = "ssh"
+    JUPYTER = "jupyter"
+    JULIA = "julia"
+
+
+class Transport(_StrEnum):
+    HTTP = "http"
+    STDIO_FILE = "stdio_file"
+    STDIO_SHM = "stdio_shm"
+    NONE = "none"
+
+
+class ServerOwner(_StrEnum):
+    EXISTING = "existing"
+    SPAWNED_DAEMON = "spawned_daemon"
+    IN_PROCESS = "in_process"
+    PERSISTENT = "persistent"
+    EXTERNAL = "external"
+
+
+class Display(_StrEnum):
+    NATIVE = "native"
+    BROWSER = "browser"
+    VSCODE = "vscode"
+    INLINE = "inline"
+    NONE = "none"
+
+
+class Registration(_StrEnum):
+    HTTP_LOAD = "http_load"
+    DAEMON_STARTUP = "daemon_startup"
+    IN_PROCESS_SESSION = "in_process_session"
+    STDIO_REGISTER = "stdio_register"
+    RELAY = "relay"
+
+
+@dataclass(frozen=True)
+class ServerSnapshot:
+    port: int
+    port_busy: bool
+    arrayview_server_alive: bool
+    server_pid: int | None = None
+    server_hostname: str | None = None
+
+
+@dataclass(frozen=True)
+class LaunchEnvironmentSnapshot:
+    invocation: Invocation
+    requested_window: str | None
+    environment: Environment
+    platform: str
+    env_vars: dict[str, str]
+    config_default: str | None
+    native_backend: str | None
+    server: ServerSnapshot
+    in_jupyter: bool
+    in_julia: bool
+    in_vscode_terminal: bool
+    is_vscode_remote: bool
+    in_vscode_tunnel: bool
+    ssh_connection: bool
+    ssh_client: bool
+    hostname: str
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class LaunchRequest:
+    port: int
+    requested_window: str | None = None
+
+
+@dataclass(frozen=True)
+class LaunchPlan:
+    invocation: Invocation
+    environment: Environment
+    transport: Transport
+    server_owner: ServerOwner
+    display: Display
+    registration: Registration
+    fallback_display: Display | None = None
+    fallback_allowed: bool = False
+
+
+def snapshot_launch_environment(
+    port: int,
+    invocation: Invocation | str,
+    requested_window: str | None = None,
+) -> LaunchEnvironmentSnapshot:
+    """Capture launch-relevant facts without importing the server stack."""
+    inv = _coerce_invocation(invocation)
+    env_vars = _snapshot_env_vars()
+    in_jupyter = _platform_bool("_in_jupyter")
+    in_julia = _platform_bool("_is_julia_env")
+    in_vscode_terminal = _platform_bool("_in_vscode_terminal")
+    is_vscode_remote = _platform_bool("_is_vscode_remote")
+    in_vscode_tunnel = _platform_bool("_in_vscode_tunnel")
+    ssh_connection = bool(os.environ.get("SSH_CONNECTION"))
+    ssh_client = bool(os.environ.get("SSH_CLIENT"))
+    environment = _classify_environment(
+        in_jupyter=in_jupyter,
+        in_julia=in_julia,
+        in_vscode_terminal=in_vscode_terminal,
+        is_vscode_remote=is_vscode_remote,
+        ssh_connection=ssh_connection,
+        ssh_client=ssh_client,
+    )
+
+    return LaunchEnvironmentSnapshot(
+        invocation=inv,
+        requested_window=requested_window,
+        environment=environment,
+        platform=sys.platform,
+        env_vars=env_vars,
+        config_default=_config_window_default(environment.value),
+        native_backend=_native_window_gui(),
+        server=_server_snapshot(port),
+        in_jupyter=in_jupyter,
+        in_julia=in_julia,
+        in_vscode_terminal=in_vscode_terminal,
+        is_vscode_remote=is_vscode_remote,
+        in_vscode_tunnel=in_vscode_tunnel,
+        ssh_connection=ssh_connection,
+        ssh_client=ssh_client,
+        hostname=socket.gethostname(),
+    )
+
+
+def _coerce_invocation(value: Invocation | str) -> Invocation:
+    if isinstance(value, Invocation):
+        return value
+    return Invocation(value)
+
+
+def _snapshot_env_vars() -> dict[str, str]:
+    return {key: os.environ[key] for key in _SNAPSHOT_ENV_KEYS if key in os.environ}
+
+
+def _platform_bool(name: str) -> bool:
+    try:
+        from arrayview import _platform
+
+        return bool(getattr(_platform, name)())
+    except Exception:
+        return False
+
+
+def _native_window_gui() -> str | None:
+    try:
+        from arrayview._platform import _native_window_gui as native_window_gui
+
+        return native_window_gui()
+    except Exception:
+        return None
+
+
+def _config_window_default(environment: str) -> str | None:
+    try:
+        from arrayview._config import load_config
+
+        cfg = load_config()
+    except Exception:
+        return None
+    window_cfg = cfg.get("window", {})
+    if not isinstance(window_cfg, dict):
+        return None
+    env_key = "vscode" if environment in {"vscode_local", "vscode_remote"} else environment
+    value = window_cfg.get(env_key) or window_cfg.get("default")
+    if isinstance(value, str):
+        return value.strip().lower() or None
+    return None
+
+
+def _classify_environment(
+    *,
+    in_jupyter: bool,
+    in_julia: bool,
+    in_vscode_terminal: bool,
+    is_vscode_remote: bool,
+    ssh_connection: bool,
+    ssh_client: bool,
+) -> Environment:
+    if in_jupyter:
+        return Environment.JUPYTER
+    if in_julia:
+        return Environment.JULIA
+    if is_vscode_remote:
+        return Environment.VSCODE_REMOTE
+    if in_vscode_terminal:
+        return Environment.VSCODE_LOCAL
+    if ssh_connection or ssh_client:
+        return Environment.SSH
+    return Environment.TERMINAL
+
+
+def _server_snapshot(port: int) -> ServerSnapshot:
+    payload = _ping_arrayview_server(port)
+    return ServerSnapshot(
+        port=port,
+        port_busy=_port_busy(port),
+        arrayview_server_alive=payload is not None,
+        server_pid=_int_or_none(payload.get("pid")) if payload else None,
+        server_hostname=_str_or_none(payload.get("hostname")) if payload else None,
+    )
+
+
+def _port_busy(port: int) -> bool:
+    try:
+        with socket.create_connection(
+            (_LOOPBACK_HOST, port), timeout=_PING_TIMEOUT_SECONDS
+        ):
+            return True
+    except OSError:
+        return False
+
+
+def _ping_arrayview_server(port: int) -> dict | None:
+    url = f"http://{_LOOPBACK_HOST}:{port}/ping"
+    try:
+        with urllib.request.urlopen(url, timeout=_PING_TIMEOUT_SECONDS) as resp:
+            if resp.status != 200:
+                return None
+            payload = json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return None
+    if payload.get("ok") is True and payload.get("service") == "arrayview":
+        return payload
+    return None
+
+
+def _int_or_none(value: object) -> int | None:
+    return value if isinstance(value, int) else None
+
+
+def _str_or_none(value: object) -> str | None:
+    return value if isinstance(value, str) else None

arrayview/_launcher.py

@@ -33,6 +33,7 @@ from arrayview._platform import (
     _is_vscode_remote,
     _in_vscode_tunnel,
     _can_native_window,
+    _native_window_gui,
     _find_vscode_ipc_hook,
     _is_julia_env,
     _in_julia_jupyter,
@@ -249,6 +250,7 @@ def _open_webview(
 
     icon_path = _get_icon_png_path() or ""
     inline_html_b64 = None
+    gui_name = _native_window_gui() or ""
 
     if shell_port is not None:
         shell_html = _build_inline_shell_html(url, shell_port)
@@ -258,14 +260,14 @@ def _open_webview(
     if inline_html_b64:
         script_lines = [
             "import sys, base64, webview",
-            "u, w, h, icon, html_b64, ready_file = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), sys.argv[4], sys.argv[5], sys.argv[6]",
+            "u, w, h, icon, html_b64, ready_file, gui = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), sys.argv[4], sys.argv[5], sys.argv[6], sys.argv[7]",
             "html = base64.b64decode(html_b64.encode()).decode()",
             "class Api:",
             "    def set_title(self, title):",
             "        try: webview.windows[0].set_title(str(title)[:240])",
             "        except Exception: pass",
             "win = webview.create_window('ArrayView', html=html, width=w, height=h, background_color='#0c0c0c', js_api=Api())",
-            "kw = {'gui': 'qt'} if sys.platform.startswith('linux') else {}",
+            "kw = {'gui': gui} if gui else {}",
             "def _start_func():",
             "    if ready_file:",
             "        try:",
@@ -298,6 +300,7 @@ def _open_webview(
                 icon_path,
                 inline_html_b64,
                 ready_file or "",
+                gui_name,
             ],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.PIPE if capture_stderr else subprocess.DEVNULL,
@@ -306,13 +309,13 @@ def _open_webview(
     # URL mode — direct load (used when shell_port not provided)
     script_lines = [
         "import sys, webview",
-        "u, w, h, icon, ready_file = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), sys.argv[4], sys.argv[5]",
+        "u, w, h, icon, ready_file, gui = sys.argv[1], int(sys.argv[2]), int(sys.argv[3]), sys.argv[4], sys.argv[5], sys.argv[6]",
         "class Api:",
         "    def set_title(self, title):",
         "        try: webview.windows[0].set_title(str(title)[:240])",
         "        except Exception: pass",
         "win = webview.create_window('ArrayView', u, width=w, height=h, background_color='#0c0c0c', js_api=Api())",
-        "kw = {'gui': 'qt'} if sys.platform.startswith('linux') else {}",
+        "kw = {'gui': gui} if gui else {}",
         "def _start_func():",
         "    if ready_file:",
         "        try:",
@@ -344,6 +347,7 @@ def _open_webview(
             str(win_h),
             icon_path,
             ready_file or "",
+            gui_name,
         ],
         stdout=subprocess.DEVNULL,
         stderr=subprocess.PIPE if capture_stderr else subprocess.DEVNULL,
@@ -368,6 +372,7 @@ def _open_webview_with_fallback(
     sockets_before = (
         _session_mod.VIEWER_SOCKETS
     )  # capture count so we detect a NEW connection
+    shell_sockets_before = len(_session_mod.SHELL_SOCKETS)
 
     def _read_stderr():
         try:
@@ -390,14 +395,18 @@ def _open_webview_with_fallback(
                 _open_browser(url, floating=floating)
                 return
 
-        # Phase 2: process is alive — wait up to 8 s for a NEW viewer WebSocket to connect.
-        # We compare against sockets_before so an already-open browser tab doesn't
-        # falsely confirm that the native window launched successfully.
+        # Phase 2: process is alive — wait up to 8 s for a NEW viewer or shell
+        # WebSocket.  The native shell connection proves pywebview is usable;
+        # the embedded viewer iframe can legitimately connect later.
         import arrayview._session as _sm
 
         for _ in range(80):
             time.sleep(0.1)
-            if _sm.VIEWER_SOCKETS > sockets_before:
+            shell_connected = (
+                shell_port is not None
+                and len(_sm.SHELL_SOCKETS) > shell_sockets_before
+            )
+            if _sm.VIEWER_SOCKETS > sockets_before or shell_connected:
                 _vprint("[ArrayView] Native window connected successfully", flush=True)
                 if sys.platform == "darwin":
                     subprocess.Popen(
@@ -530,6 +539,21 @@ def _server_viewer_connections_seen(port: int, timeout: float = 0.5) -> int:
     return 0
 
 
+def _server_shell_sockets_open(port: int, timeout: float = 0.5) -> int:
+    """Return the daemon's current native shell WebSocket count."""
+    url = f"http://{_LOOPBACK_HOST}:{port}/ping"
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as resp:
+            if resp.status != 200:
+                return 0
+            payload = json.loads(resp.read().decode("utf-8"))
+            if payload.get("ok") is True and payload.get("service") == "arrayview":
+                return int(payload.get("shell_sockets") or 0)
+    except Exception:
+        pass
+    return 0
+
+
 def _wait_for_viewer_connection(
     port: int,
     *,
@@ -545,6 +569,23 @@ def _wait_for_viewer_connection(
     return False
 
 
+def _wait_for_native_shell_or_viewer_connection(
+    port: int,
+    *,
+    viewer_before: int,
+    timeout: float = 8.0,
+) -> bool:
+    """Wait until pywebview proves it is alive via shell or viewer WebSocket."""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if _server_viewer_connections_seen(port, timeout=0.3) > viewer_before:
+            return True
+        if _server_shell_sockets_open(port, timeout=0.3) > 0:
+            return True
+        time.sleep(0.1)
+    return False
+
+
 def _terminate_native_process(proc: subprocess.Popen | None) -> None:
     if proc is None or proc.poll() is not None:
         return
@@ -554,6 +595,64 @@ def _terminate_native_process(proc: subprocess.Popen | None) -> None:
         return
 
 
+def _open_cli_native_shell_after_server(
+    *,
+    port: int,
+    sid: str,
+    name: str,
+    compare_sids: "_CompareSids | None",
+    win_w: int,
+    win_h: int,
+) -> bool:
+    """Open a CLI native shell and return whether it is usable."""
+    url_shell = _shell_url(port, sid, name, compare_sids=compare_sids)
+    viewer_before = _server_viewer_connections_seen(port)
+    opened, proc = _open_webview_cli_tracked(url_shell, win_w, win_h)
+    if opened and _wait_for_native_shell_or_viewer_connection(
+        port, viewer_before=viewer_before
+    ):
+        return True
+    if opened:
+        _vprint(
+            "[ArrayView] Native window did not connect to the backend; falling back to browser",
+            flush=True,
+        )
+    _terminate_native_process(proc)
+    return False
+
+
+def _activate_early_cli_native_shell(
+    *,
+    port: int,
+    sid: str,
+    name: str,
+    proc: subprocess.Popen | None,
+) -> bool:
+    """Attach an already-started preload shell to a spawned daemon session."""
+    viewer_before = _server_viewer_connections_seen(port)
+    try:
+        notify_result = _notify_existing_session(
+            port,
+            sid,
+            name,
+            url=_viewer_path(sid),
+            wait=True,
+        )
+        notified = bool(notify_result.get("notified"))
+    except Exception:
+        notified = False
+    if notified and _wait_for_native_shell_or_viewer_connection(
+        port, viewer_before=viewer_before
+    ):
+        return True
+    _vprint(
+        "[ArrayView] Native window did not connect to the backend; falling back to browser",
+        flush=True,
+    )
+    _terminate_native_process(proc)
+    return False
+
+
 # ── Server Port Utilities ─────────────────────────────────────────
 
 
@@ -862,23 +961,21 @@ def _open_cli_existing_server_view(
         _vprint(f"Injected into existing window (port {port})")
         return
     if notify_webview and not notified:
-        url_shell = _shell_url(port, sid, name, compare_sids=compare_sids)
-        seen_before = _server_viewer_connections_seen(port)
-        opened, proc = _open_webview_cli_tracked(url_shell, 1200, 800)
-        if not opened or not _wait_for_viewer_connection(port, before=seen_before):
-            if opened:
-                _vprint(
-                    "[ArrayView] Native window did not connect to the backend; falling back to browser",
-                    flush=True,
-                )
-            _terminate_native_process(proc)
+        native_ready = _open_cli_native_shell_after_server(
+            port=port,
+            sid=sid,
+            name=name,
+            compare_sids=compare_sids,
+            win_w=1200,
+            win_h=800,
+        )
+        if not native_ready:
             _vprint("[ArrayView] Falling back to browser", flush=True)
             _print_viewer_location(url)
             _open_browser(
                 url,
                 blocking=True,
                 title=f"ArrayView: {name}",
-                filepath=base_file,
                 floating=floating,
             )
         return
@@ -889,7 +986,6 @@ def _open_cli_existing_server_view(
         blocking=True,
         force_vscode=(window_mode == "vscode"),
         title=f"ArrayView: {name}",
-        filepath=base_file,
         floating=floating,
     )
 
@@ -1052,11 +1148,11 @@ def _handle_cli_spawned_daemon(
         stdout=subprocess.DEVNULL,
         stderr=subprocess.DEVNULL,
         close_fds=True,
+        start_new_session=(sys.platform != "win32"),
     )
 
     early_webview_opened = False
     early_webview_proc = None
-    early_webview_notified = False
     early_webview_connected = False
     if (
         use_webview
@@ -1083,29 +1179,12 @@ def _handle_cli_spawned_daemon(
         sys.exit(1)
 
     if early_webview_opened:
-        seen_before = _server_viewer_connections_seen(port)
-        try:
-            notify_result = _notify_existing_session(
-                port,
-                sid,
-                name,
-                url=_viewer_path(sid),
-                wait=True,
-            )
-            early_webview_notified = bool(notify_result.get("notified"))
-        except Exception:
-            early_webview_notified = False
-        if early_webview_notified:
-            early_webview_connected = _wait_for_viewer_connection(
-                port,
-                before=seen_before,
-            )
-        if not early_webview_connected:
-            _vprint(
-                "[ArrayView] Native window did not connect to the backend; falling back to browser",
-                flush=True,
-            )
-            _terminate_native_process(early_webview_proc)
+        early_webview_connected = _activate_early_cli_native_shell(
+            port=port,
+            sid=sid,
+            name=name,
+            proc=early_webview_proc,
+        )
 
     should_retry_webview = use_webview and not (
         early_webview_opened and not early_webview_connected
@@ -1154,21 +1233,20 @@ def _open_cli_spawned_view(
     if _should_notify_webview(use_webview, overlay_sid):
         if webview_already_opened:
             return
-        url_shell = _shell_url(port, sid, name, compare_sids=compare_sids)
-        seen_before = _server_viewer_connections_seen(port)
-        opened, proc = _open_webview_cli_tracked(url_shell, 1400, 900)
-        if not opened or not _wait_for_viewer_connection(port, before=seen_before):
-            if opened:
-                _vprint(
-                    "[ArrayView] Native window did not connect to the backend; falling back to browser",
-                    flush=True,
-                )
-            _terminate_native_process(proc)
+        native_ready = _open_cli_native_shell_after_server(
+            port=port,
+            sid=sid,
+            name=name,
+            compare_sids=compare_sids,
+            win_w=1400,
+            win_h=900,
+        )
+        if not native_ready:
             _vprint("[ArrayView] Falling back to browser", flush=True)
             _print_viewer_location(url)
             _open_browser(
                 url,
-                blocking=False,
+                blocking=(window_mode == "vscode"),
                 force_vscode=(window_mode == "vscode"),
                 title=f"ArrayView: {name}",
                 floating=floating,