arrayview 0.49.0__tar.gz → 0.49.1__tar.gz

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

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

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

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

{arrayview-0.49.0 → arrayview-0.49.1}/src/arrayview/_instance_registry.py

@@ -70,7 +70,10 @@ def runtime_directory() -> Path:
         return Path(base) / "arrayview"
     if hasattr(os, "getuid"):
         return Path(tempfile.gettempdir()) / f"arrayview-{os.getuid()}"
-    return Path(tempfile.gettempdir()) / f"arrayview-{os.getpid()}"
+    # Windows: no uid, but the temp folder is already per user. One shared
+    # name lets every command see the servers the others started.
+    user = "".join(c for c in os.environ.get("USERNAME", "") if c.isalnum() or c in "-_.")
+    return Path(tempfile.gettempdir()) / f"arrayview-{user or 'user'}"
 
 
 def process_start_identity(pid: int) -> str | None:

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

@@ -503,7 +503,7 @@ def read_gzip_file_parallel(filepath):
     """
     try:
         size = os.path.getsize(filepath)
-        fd = os.open(filepath, os.O_RDONLY)
+        fd = os.open(filepath, _O_RDONLY_BINARY)
     except OSError:
         return None
     buf = bytearray(size)
@@ -518,7 +518,7 @@ def read_gzip_file_parallel(filepath):
         pos = start
         try:
             while pos < stop:
-                n = os.preadv(fd, [view[pos:stop]], pos)
+                n = _pread_into(fd, view[pos:stop], pos)
                 if n <= 0:
                     raise OSError("unexpected end of file")
                 pos += n
@@ -624,10 +624,21 @@ def _mapped_slice_is_scattered(view) -> bool:
     return nbytes > 4 * view.nbytes and nbytes > _REGION_READ_CHUNK_BYTES
 
 
+# Windows has neither pread nor preadv: reads there seek and read under one
+# lock, so they are correct but no longer run in parallel.
+_SEEK_READ_LOCK = threading.Lock()
+_O_RDONLY_BINARY = os.O_RDONLY | getattr(os, "O_BINARY", 0)
+
+
 def _pread_into(fd, buf, offset):
     if hasattr(os, "preadv"):
         return os.preadv(fd, [buf], offset)
-    data = os.pread(fd, len(buf), offset)
+    if hasattr(os, "pread"):
+        data = os.pread(fd, len(buf), offset)
+    else:
+        with _SEEK_READ_LOCK:
+            os.lseek(fd, offset, os.SEEK_SET)
+            data = os.read(fd, len(buf))
     buf[: len(data)] = data
     return len(data)
 
@@ -646,7 +657,7 @@ def read_mapped_region(view, progress=None):
     mv = memoryview(buf)
     lock = threading.Lock()
     done = [0]
-    fd = os.open(filename, os.O_RDONLY)
+    fd = os.open(filename, _O_RDONLY_BINARY)
     try:
 
         def _read(start):
@@ -681,9 +692,9 @@ class _ScatteredRegionMixin:
     map of a 4D one. When a requested slice would be scattered across its
     region, the region is read in one go (see ``read_mapped_region``) and kept;
     every later slice of it, in any direction, is then served from memory.
-    Afterwards the case's other regions and the neighbouring case are read in
-    the background, so the next step — another map, the next patient — is
-    usually already there.
+    Whichever way the case is first viewed, its regions and the neighbouring
+    case's are then read in the background, so the next step — scrolling,
+    another map, a crossing view, the next patient — is usually already there.
     """
 
     def _init_region_cache(self):
@@ -793,6 +804,9 @@ class _ScatteredRegionMixin:
         if region is None:
             try:
                 if not _mapped_slice_is_scattered(mapped[tuple(spatial_key)]):
+                    # Cheap to read now, but the next scroll steps and any
+                    # switch to a crossing view are not: load the case anyway.
+                    self._schedule_region_warm(p_idx, m_idx, rest, spatial_key)
                     return None
                 view = self._region_view(mapped, rest)
                 if view.nbytes > self._region_cache_max_bytes // 2:
@@ -825,11 +839,6 @@ class _ScatteredRegionMixin:
         else:
             step = -1 if last is not None and last[0] > p_idx else 1
             neighbours = [(p_idx + step, m_idx), (p_idx - step, m_idx)]
-        # Which axes are on screen is all that carries over to another case;
-        # the indices along the others may not fit a differently-sized one.
-        probe = tuple(
-            slice(None) if isinstance(k, slice) else 0 for k in spatial_key[: min(3, len(spatial_key))]
-        )
         plan = [(p_idx, m_idx)] + [
             (p, m) for p, m in neighbours if 0 <= p < n_p and 0 <= m < n_m
         ]
@@ -845,7 +854,7 @@ class _ScatteredRegionMixin:
                     if self._file_matrix[p][m] is None:
                         continue
                     mapped = self._mapped_volume(p, m, self._get_volume(p, m))
-                    if mapped is None or not _mapped_slice_is_scattered(mapped[probe + first_rest]):
+                    if mapped is None:
                         continue
                     n_sp = min(3, mapped.ndim)
                     rests = list(np.ndindex(*mapped.shape[n_sp:])) or [()]
@@ -2213,7 +2222,7 @@ def prefetch_slice_pages(mapped, filepath, dims, index, progress=None) -> bool:
         return False
 
     try:
-        fd = os.open(filepath, os.O_RDONLY)
+        fd = os.open(filepath, _O_RDONLY_BINARY)
     except OSError:
         return False
     try:
@@ -2323,13 +2332,13 @@ def read_npy_into_ram(mapped, progress=None):
     lock = threading.Lock()
     done = [0]
 
-    fd = os.open(mapped.filename, os.O_RDONLY)
+    fd = os.open(mapped.filename, _O_RDONLY_BINARY)
     try:
         def _read(start):
             stop = min(start + _NPY_READ_CHUNK_BYTES, total)
             pos = start
             while pos < stop:
-                n = os.preadv(fd, [dst[pos:stop]], offset + pos)
+                n = _pread_into(fd, dst[pos:stop], offset + pos)
                 if n <= 0:
                     raise OSError(f"unexpected end of file reading {mapped.filename!r}")
                 pos += n

{arrayview-0.49.0 → arrayview-0.49.1}/src/arrayview/_launch_trace.py

@@ -151,7 +151,8 @@ def emit_launch_event(event: str, **attrs: object) -> None:
                 encoded = (json.dumps(payload, separators=(",", ":")) + "\n").encode()
             fd = os.open(_path, os.O_APPEND | os.O_CREAT | os.O_WRONLY, 0o600)
             try:
-                os.fchmod(fd, 0o600)
+                if hasattr(os, "fchmod"):  # Windows has none before Python 3.13
+                    os.fchmod(fd, 0o600)
                 os.write(fd, encoded)
             finally:
                 os.close(fd)

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

@@ -74,10 +74,15 @@ def _detached_child_kwargs() -> dict[str, object]:
     control event raised for that group reaches *every* process attached to it,
     so a child being shut down can deliver a KeyboardInterrupt to the process
     that spawned it — under pytest, to the test runner itself.  Both branches
-    state the same intent: the child gets its own group.
+    state the same intent: the child gets its own group.  On Windows it also
+    gets no console of its own: started from a notebook or a GUI app, a
+    background server would otherwise pop up an empty black console window.
     """
     if sys.platform == "win32":
-        return {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}
+        return {
+            "creationflags": subprocess.CREATE_NEW_PROCESS_GROUP
+            | subprocess.CREATE_NO_WINDOW
+        }
     return {"start_new_session": True}
 
 
@@ -391,6 +396,19 @@ def _build_inline_shell_html(url: str, shell_port: int) -> str | None:
         return None
 
 
+def _set_listen_reuse(sock: "socket.socket") -> None:
+    """Let a restarted server rebind its port at once, without sharing it.
+
+    On Windows ``SO_REUSEADDR`` lets a second process bind a port another
+    listener already holds, so two servers could answer on one port; the
+    exclusive option there is what the POSIX flag means elsewhere.
+    """
+    if sys.platform == "win32":
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+    else:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+
 def _make_loopback_socket(port: int) -> "socket.socket":
     """Bind a single TCP listener on the same loopback host the viewer URLs use."""
     for family, socktype, proto, _, sockaddr in socket.getaddrinfo(
@@ -401,7 +419,7 @@ def _make_loopback_socket(port: int) -> "socket.socket":
         sock = None
         try:
             sock = socket.socket(family, socktype, proto)
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            _set_listen_reuse(sock)
             sock.bind(sockaddr)
             sock.listen(128)
             sock.set_inheritable(True)
@@ -439,7 +457,7 @@ def _make_loopback_sockets(port: int) -> list["socket.socket"]:
         sock = None
         try:
             sock = socket.socket(family, socktype, proto)
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            _set_listen_reuse(sock)
             # On Linux, binding ::1 first then 127.0.0.1 on the same port is
             # fine (different addresses). IPV6_V6ONLY stays default (off on
             # Linux) which is harmless since we bind explicit addresses.
@@ -5652,8 +5670,26 @@ def _handle_management_command(argv: list[str]) -> bool:
     return True
 
 
+def _replace_unprintable_output() -> None:
+    """Keep messages with arrows or ticks from crashing a Windows console.
+
+    Output redirected to a file or pipe on Windows uses an old code page that
+    cannot encode such characters, so printing them raised instead of showing
+    the message. The servers this command starts inherit the same setting.
+    """
+    if os.name != "nt":
+        return
+    os.environ.setdefault("PYTHONIOENCODING", ":replace")
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(errors="replace")
+        except (AttributeError, ValueError):
+            pass
+
+
 def arrayview():
     """Command Line Interface Entry Point."""
+    _replace_unprintable_output()
     # Handle "arrayview config ..." subcommand before argparse
     if len(sys.argv) > 1 and sys.argv[1] == "config":
         _handle_config_command(sys.argv[2:])

{arrayview-0.49.0 → arrayview-0.49.1}/src/arrayview/_routes_export.py

@@ -1,5 +1,6 @@
 import asyncio
 import io
+import re
 
 import numpy as np
 from fastapi import Body, Depends, Request, Response
@@ -8,6 +9,12 @@ from fastapi.responses import JSONResponse
 from arrayview._render import render_rgba
 
 
+def _safe_filename(name: str, default: str) -> str:
+    """A bare file name every OS accepts: no folders, no reserved characters."""
+    name = re.sub(r'[\\/:*?"<>|\x00-\x1f\s]+', "_", str(name or "")).strip("._")
+    return name or default
+
+
 def register_export_routes(app, *, get_session_or_404, pil_image) -> None:
     @app.get("/export_array/{sid}")
     def export_array(
@@ -20,8 +27,7 @@ def register_export_routes(app, *, get_session_or_404, pil_image) -> None:
         buf = io.BytesIO()
         np.save(buf, data)
         buf.seek(0)
-        name_stem = (session.name or "array").replace(" ", "_").replace("/", "_")
-        filename = f"{name_stem}.npy"
+        filename = f"{_safe_filename(session.name, 'array')}.npy"
         if save_to_downloads:
             import pathlib
 
@@ -39,7 +45,7 @@ def register_export_routes(app, *, get_session_or_404, pil_image) -> None:
     async def save_file(request: Request):
         """Save a client-generated file to the Downloads folder."""
         body = await request.json()
-        filename = body.get("filename", "arrayview_export")
+        filename = _safe_filename(body.get("filename"), "arrayview_export")
         data_b64 = body.get("data", "")
         if "," in data_b64:
             data_b64 = data_b64.split(",", 1)[1]

{arrayview-0.49.0 → arrayview-0.49.1}/src/arrayview/_routes_loading.py

@@ -618,6 +618,18 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
         )
         return {"sid": session.sid, "name": name, "notified": notified}
 
+    @app.post("/reveal/{sid}")
+    async def reveal_session_tab(sid: str):
+        """Bring the VS Code browser tab already showing *sid* forward."""
+        from arrayview._routes_websocket import viewer_tab_reveal_target
+        from arrayview._vscode_signal import _request_vscode_tab_reveal
+
+        target = viewer_tab_reveal_target(sid)
+        if target is None:
+            return {"sid": sid, "revealed": False}
+        revealed = await asyncio.to_thread(_request_vscode_tab_reveal, *target)
+        return {"sid": sid, "revealed": revealed}
+
     @app.post("/release/{sid}")
     def release_viewer_session(sid: str, request: Request):
         """Release a session when its owning viewer tab/window closes."""

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

@@ -289,6 +289,32 @@ async def _send_json_quietly(ws, payload):
 # a small socket budget, so linking must not open connections of its own.
 _LINKED_VIEWER_SOCKETS: set = set()
 
+# Where each live VS Code browser tab currently is: ws → (sid, path, window_id).
+# The file picker uses it to bring an already-open array's tab forward.
+_VIEWER_TAB_ADDRESSES: dict = {}
+
+
+def _handle_tab_address_message(ws, sid: str, msg: dict) -> None:
+    path = msg.get("path")
+    window_id = msg.get("window_id")
+    if not isinstance(path, str) or not path.startswith("/") or len(path) > 2048:
+        return
+    if not isinstance(window_id, str) or not window_id or len(window_id) > 128:
+        return
+    _VIEWER_TAB_ADDRESSES[ws] = (sid, path, window_id)
+
+
+def viewer_tab_reveal_target(sid: str) -> tuple[str, str] | None:
+    """(window_id, VS Code reuseUrlFilter) of a live tab showing *sid*."""
+    from urllib.parse import urlsplit
+
+    for tab_sid, path, window_id in reversed(list(_VIEWER_TAB_ADDRESSES.values())):
+        parts = urlsplit(path)
+        # A bare "/" is shared by every tab; only a query tells them apart.
+        if tab_sid == sid and parts.query:
+            return window_id, f"{parts.path}?{parts.query}"
+    return None
+
 
 def _handle_link_message(ws, msg: dict) -> None:
     action = msg.get("action")
@@ -531,6 +557,9 @@ def register_websocket_routes(app) -> None:
                         # displaces (or is displaced by) a pending render.
                         _handle_link_message(ws, msg)
                         continue
+                    if isinstance(msg, dict) and msg.get("type") == "tab-address":
+                        _handle_tab_address_message(ws, sid, msg)
+                        continue
                     try:
                         _pending.get_nowait()
                     except asyncio.QueueEmpty:
@@ -933,6 +962,7 @@ def register_websocket_routes(app) -> None:
             except ValueError:
                 pass
             _LINKED_VIEWER_SOCKETS.discard(ws)
+            _VIEWER_TAB_ADDRESSES.pop(ws, None)
             try:
                 from arrayview import _extra_ports