arrayview 0.43.0__py3-none-any.whl → 0.43.2__py3-none-any.whl

arrayview/_diagnostics.py

@@ -96,7 +96,8 @@ _DIAGNOSES: list[tuple[str, str, str, str]] = [
     (r"did not start the viewer script", ACTION,
      "VS Code opened an integrated-browser tab, but the tab did not navigate "
      "to the ArrayView page.",
-     _RETRY + "  If it repeats, reload the VS Code window."),
+     _RELOAD + "  Retrying without reloading sends the next launch to the "
+     "same stuck browser."),
     (r"did not render a frame|did not become ready",
      ACTION,
      "The viewer opened but showed no frame before the deadline — usually a "

arrayview/_extra_ports.py

@@ -18,24 +18,23 @@ A port that has never been forwarded does not have that problem.  So a cold
 launch is served from a fresh port, which VS Code forwards for the first time.
 This module adds that port to the process that is *already* running, rather than
 starting another server: same process, same loaded arrays, nothing extra to shut
-down, and repeat opens keep using the original port.
+down, and overlapping opens share the same private viewer port.
 
 Lifetime
 --------
 
-An extra port is closed as soon as no viewer is connected **on that port**.
-Viewers report the port they arrived on, so a port is released the moment its
-own viewer goes away, rather than waiting for every viewer everywhere to close —
-otherwise one cold start early in a session would leave a port listening for the
-rest of the day.
+Every launch leases the singleton viewer port before its URL is handed off.
+The port is closed only when no viewer is connected **and** no launch still has
+a live lease.  This prevents the last old viewer from closing the port while a
+new viewer is between URL handoff and WebSocket connection.
 
 It must not be closed while a viewer loaded from it is alive: the viewer keeps
 using HTTP on its own origin long after the page has rendered, so pulling the
 port out from under it would break the viewer rather than tidy up after it.
 
-A port that never receives a viewer at all — the launch failed, or the user
-closed the tab before it loaded — is closed after ``UNUSED_GRACE_S``.  Without
-that, a failed cold start would leak a port with nothing to trigger its release.
+A launch that never receives a viewer loses its lease after a bounded timeout.
+Without that, a failed handoff would leak a port with nothing to trigger its
+release.
 """
 
 from __future__ import annotations
@@ -47,19 +46,20 @@ import time
 import arrayview._session as _session_mod
 from arrayview._session import _vprint
 
-# Cold starts are rare — one per session in practice, because the first launch
-# leaves a viewer open and every launch after that is warm.  The cap is a guard
-# against a pathological caller, not an expected working set.
-MAX_EXTRA_PORTS = 3
-
-# How long a freshly opened port may sit with no viewer on it before it is
-# reclaimed.  This is the leak guard for a launch that never produced a viewer;
-# it has to outlast a slow array load, because the port is opened before the
-# page is even requested and a large file can take a while to reach its socket.
-UNUSED_GRACE_S = 180.0
-
-# port -> {"socket", "server", "task", "viewers", "opened_at"}
+# A lease must be long enough for a slow or temporarily wedged VS Code handoff,
+# but a caller may not keep a private port alive without bound.
+MIN_LEASE_TTL_MS = 1
+MAX_LEASE_TTL_MS = 300_000
+# Keep the origin alive across the viewer's ordinary reconnect window.  The
+# correlated session uses the same 30-second default before it treats a lost
+# WebSocket as a closed tab; closing the listener sooner would make that
+# recovery impossible even though the server and session are still healthy.
+VIEWER_RECONNECT_GRACE_S = 30.0
+
+# port -> {"socket", "server", "task", "viewers", "opened_at", "leases",
+#          "idle_until", "idle_generation"}
 _EXTRA_PORTS: dict[int, dict] = {}
+_PORT_LOCK = asyncio.Lock()
 
 
 def extra_ports() -> list[int]:
@@ -76,18 +76,8 @@ def _bind_free_port() -> socket.socket:
     return sock
 
 
-async def open_extra_port() -> int | None:
-    """Serve the running app on one more, never-before-used port.
-
-    Returns the port, or ``None`` if one could not be added.  Never raises: a
-    launch that cannot get a fresh port is still a working launch on the main
-    port, only with the cold-start flicker it would have had anyway.
-    """
-    if len(_EXTRA_PORTS) >= MAX_EXTRA_PORTS:
-        _vprint(
-            f"[ArrayView] not adding another port; {len(_EXTRA_PORTS)} already open"
-        )
-        return None
+def _start_extra_port() -> tuple[int, dict] | None:
+    """Start the singleton extra listener; caller holds ``_PORT_LOCK``."""
     try:
         import uvicorn
 
@@ -105,57 +95,169 @@ async def open_extra_port() -> int | None:
         )
         server = uvicorn.Server(config)
         task = asyncio.create_task(server.serve(sockets=[sock]))
-        _EXTRA_PORTS[port] = {
+        entry = {
             "socket": sock,
             "server": server,
             "task": task,
             "viewers": 0,
             "opened_at": time.monotonic(),
+            "leases": {},
+            "idle_until": 0.0,
+            "idle_generation": 0,
         }
-        asyncio.create_task(_close_if_unused(port))
         # The socket is already listening and accepting before serve() runs, so
         # a client that connects immediately is queued rather than refused.
-        _vprint(f"[ArrayView] serving a cold-start port on {port}")
-        return port
+        _vprint(f"[ArrayView] serving the private viewer port on {port}")
+        return port, entry
     except Exception as exc:  # pragma: no cover - defensive
-        _vprint(f"[ArrayView] could not add a cold-start port: {exc}")
+        _vprint(f"[ArrayView] could not add the private viewer port: {exc}")
         return None
 
 
-def viewer_connected(port: int | None) -> None:
-    """Note that a viewer arrived on *port*, if it is one of ours."""
-    entry = _EXTRA_PORTS.get(port)
-    if entry is not None:
-        entry["viewers"] += 1
-
+async def acquire_viewer_port(request_id: str, ttl_ms: int) -> tuple[int | None, bool]:
+    """Lease the singleton private viewer port for one launch.
 
-async def viewer_disconnected(port: int | None) -> None:
-    """Note a viewer left *port*, and release the port if it was the last one."""
+    The selection and lease insertion are one event-loop transaction, so two
+    launches arriving before either viewer connects cannot create two ports.
+    """
+    ttl_ms = max(MIN_LEASE_TTL_MS, min(MAX_LEASE_TTL_MS, int(ttl_ms)))
+    retired: list[tuple[int, dict]] = []
+    async with _PORT_LOCK:
+        now = time.monotonic()
+        for port, entry in list(_EXTRA_PORTS.items()):
+            leases = entry.setdefault("leases", {})
+            for lease_id, expires_at in list(leases.items()):
+                if expires_at <= now:
+                    leases.pop(lease_id, None)
+            if (
+                entry["viewers"] == 0
+                and not leases
+                and float(entry.get("idle_until", 0.0)) <= now
+            ):
+                _EXTRA_PORTS.pop(port, None)
+                retired.append((port, entry))
+        reused = bool(_EXTRA_PORTS)
+        if reused:
+            port = next(iter(_EXTRA_PORTS))
+            entry = _EXTRA_PORTS[port]
+        else:
+            started = _start_extra_port()
+            if started is None:
+                for retired_port, retired_entry in retired:
+                    asyncio.create_task(
+                        _shutdown_entry(retired_port, retired_entry)
+                    )
+                return None, False
+            port, entry = started
+            _EXTRA_PORTS[port] = entry
+        expires_at = now + ttl_ms / 1000.0
+        entry.setdefault("leases", {})[request_id] = expires_at
+        entry["idle_until"] = 0.0
+        entry["idle_generation"] = int(entry.get("idle_generation", 0)) + 1
+        asyncio.create_task(_expire_lease(port, request_id, expires_at))
+    for retired_port, retired_entry in retired:
+        asyncio.create_task(_shutdown_entry(retired_port, retired_entry))
+    return port, reused
+
+
+def viewer_connected(port: int | None, request_id: str | None = None) -> None:
+    """Note that a viewer arrived and consume only its correlated lease."""
     entry = _EXTRA_PORTS.get(port)
     if entry is None:
         return
-    entry["viewers"] = max(0, entry["viewers"] - 1)
-    if entry["viewers"] == 0:
-        await _close_port(port)
-
-
-async def _close_if_unused(port: int) -> None:
-    """Reclaim a port that never got a viewer.
+    leases = entry.setdefault("leases", {})
+    if request_id:
+        consumed = leases.pop(request_id, None)
+        # Opener 0.15.47 asks for the port before it knows how to lease it.
+        # The endpoint gives that request a bounded compatibility lease so a
+        # package update does not force an immediate window reload. Consume one
+        # such lease only when no exact lease exists.
+        if consumed is None:
+            compatibility_lease = next(
+                (
+                    lease_id
+                    for lease_id in leases
+                    if lease_id.startswith("compat-")
+                ),
+                None,
+            )
+            if compatibility_lease is not None:
+                leases.pop(compatibility_lease, None)
+    entry["viewers"] += 1
+    entry["idle_until"] = 0.0
+    entry["idle_generation"] = int(entry.get("idle_generation", 0)) + 1
 
-    Its own release is driven by the viewer that loaded from it, so a launch
-    that never produced one would otherwise leave the port listening forever.
-    """
-    await asyncio.sleep(UNUSED_GRACE_S)
-    entry = _EXTRA_PORTS.get(port)
-    if entry is not None and entry["viewers"] == 0:
-        _vprint(f"[ArrayView] cold-start port {port} was never used")
-        await _close_port(port)
 
-
-async def _close_port(port: int) -> None:
-    entry = _EXTRA_PORTS.pop(port, None)
-    if entry is None:
-        return
+async def viewer_disconnected(port: int | None) -> None:
+    """Release a port only after its last viewer and last handoff lease."""
+    close_after: tuple[int, float] | None = None
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if entry is None:
+            return
+        entry["viewers"] = max(0, entry["viewers"] - 1)
+        if entry["viewers"] == 0:
+            entry["idle_generation"] = int(entry.get("idle_generation", 0)) + 1
+            generation = entry["idle_generation"]
+            idle_until = time.monotonic() + VIEWER_RECONNECT_GRACE_S
+            entry["idle_until"] = idle_until
+            close_after = (generation, idle_until)
+    if close_after is not None:
+        generation, idle_until = close_after
+        asyncio.create_task(_close_after_reconnect_grace(port, generation, idle_until))
+
+
+async def _close_after_reconnect_grace(
+    port: int, generation: int, idle_until: float
+) -> None:
+    """Close only if no reconnect or new launch superseded this disconnect."""
+    await asyncio.sleep(max(0.0, idle_until - time.monotonic()))
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if (
+            entry is None
+            or int(entry.get("idle_generation", 0)) != generation
+            or entry["viewers"] > 0
+            or entry.get("leases")
+        ):
+            return
+    await _close_port(port, only_if_idle=True)
+
+
+async def _expire_lease(port: int, request_id: str, expires_at: float) -> None:
+    """Expire one exact launch lease and reclaim an otherwise idle port."""
+    await asyncio.sleep(max(0.0, expires_at - time.monotonic()))
+    should_close = False
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if entry is None:
+            return
+        leases = entry.setdefault("leases", {})
+        if leases.get(request_id) != expires_at:
+            return
+        leases.pop(request_id, None)
+        should_close = entry["viewers"] == 0 and not leases
+    if should_close:
+        _vprint(f"[ArrayView] viewer-port lease expired for {request_id[:12]}")
+        await _close_port(port, only_if_idle=True)
+
+
+async def _close_port(port: int, *, only_if_idle: bool = False) -> None:
+    async with _PORT_LOCK:
+        entry = _EXTRA_PORTS.get(port)
+        if entry is None:
+            return
+        if only_if_idle:
+            if entry["viewers"] > 0 or entry.get("leases"):
+                return
+            if float(entry.get("idle_until", 0.0)) > time.monotonic():
+                return
+        _EXTRA_PORTS.pop(port, None)
+    await _shutdown_entry(port, entry)
+
+
+async def _shutdown_entry(port: int, entry: dict) -> None:
+    """Stop one listener already removed from the selectable port registry."""
     try:
         entry["server"].should_exit = True
         await asyncio.wait_for(entry["task"], timeout=5)
@@ -166,7 +268,7 @@ async def _close_port(port: int) -> None:
             entry["socket"].close()
         except Exception:
             pass
-    _vprint(f"[ArrayView] released cold-start port {port}")
+    _vprint(f"[ArrayView] released private viewer port {port}")
 
 
 async def close_extra_ports() -> None:
@@ -178,4 +280,4 @@ async def close_extra_ports() -> None:
     if not _EXTRA_PORTS or _session_mod.VIEWER_SOCKETS > 0:
         return
     for port in list(_EXTRA_PORTS):
-        await _close_port(port)
+        await _close_port(port, only_if_idle=True)

arrayview/_routes_loading.py

@@ -137,32 +137,33 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
         staging_dir = validated_staging_directory(abs_path, claimed_staging)
         if claimed_staging and staging_dir is None:
             raise HTTPException(status_code=400, detail="invalid source staging directory")
-        unsafe_mount = direct_network_mount(abs_path)
-        if unsafe_mount is not None:
-            return {
-                "error": (
-                    f"Direct server access to network mount {unsafe_mount.mountpoint!r} "
-                    "is refused. Launch the file through the arrayview CLI so it can "
-                    "be staged safely."
-                )
-            }
-        nested_source_mount = network_mount_below(abs_path)
-        if nested_source_mount is not None:
-            return {
-                "error": (
-                    f"Source discovery would enter network mount "
-                    f"{nested_source_mount.mountpoint!r}; copy the collection locally first."
-                )
-            }
-        if source_may_require_sibling_discovery(abs_path):
-            nested_sibling_mount = network_mount_below(os.path.dirname(abs_path))
-            if nested_sibling_mount is not None:
+        if os.environ.get("ARRAYVIEW_SKIP_SOURCE_STAGING", "1") == "0":
+            unsafe_mount = direct_network_mount(abs_path)
+            if unsafe_mount is not None:
+                return {
+                    "error": (
+                        f"Direct server access to network mount {unsafe_mount.mountpoint!r} "
+                        "is refused. Launch the file through the arrayview CLI so it can "
+                        "be staged safely."
+                    )
+                }
+            nested_source_mount = network_mount_below(abs_path)
+            if nested_source_mount is not None:
                 return {
                     "error": (
-                        f"Related-file discovery would enter network mount "
-                        f"{nested_sibling_mount.mountpoint!r}; copy the series locally first."
+                        f"Source discovery would enter network mount "
+                        f"{nested_source_mount.mountpoint!r}; copy the collection locally first."
                     )
                 }
+            if source_may_require_sibling_discovery(abs_path):
+                nested_sibling_mount = network_mount_below(os.path.dirname(abs_path))
+                if nested_sibling_mount is not None:
+                    return {
+                        "error": (
+                            f"Related-file discovery would enter network mount "
+                            f"{nested_sibling_mount.mountpoint!r}; copy the series locally first."
+                        )
+                    }
         for pattern in dir_patterns or []:
             pattern_path = lexical_abspath(str(pattern))
             scan_root = scan_root_before_magic(pattern_path)
@@ -831,7 +832,10 @@ def register_loading_routes(app, *, notify_shells, setup_rgb) -> None:
             )
             if require_display_ack:
                 if not signal_request:
-                    raise RuntimeError("VS Code display request could not be written")
+                    raise RuntimeError(
+                        signal_request.failure_reason
+                        or "VS Code display request could not be written"
+                    )
                 ack = await asyncio.to_thread(
                     _wait_for_vscode_ack,
                     signal_request,

arrayview/_routes_rendering.py

@@ -23,7 +23,7 @@ from arrayview._render import (
     render_rgb_rgba,
     render_rgba,
 )
-from arrayview._session import HEAVY_OP_LIMIT_BYTES, SESSIONS
+from arrayview._session import HEAVY_OP_LIMIT_BYTES, SESSIONS, _schedule_prefetch
 from arrayview._synthetic_mri import (
     _qmri_adjust_vmin_vmax,
     qmri_display_slice,
@@ -276,6 +276,21 @@ def register_rendering_routes(app, *, get_session_or_404) -> None:
                     mosaic_cols,
                 )
         render_ms = (time.perf_counter() - render_t0) * 1000.0
+        # This endpoint is what compare mode polls per scroll step (the live
+        # WS path has its own prefetch call). Without this, a second array
+        # open puts every pane on the request-then-wait path with nothing
+        # warmed ahead, which is a much bigger hit than the extra data alone.
+        # No per-request direction field here (stateless HTTP), so infer it
+        # from the index this session last rendered, mirroring the WS guard.
+        if slice_dim >= 0 and dim_z < 0:
+            prev_idx = getattr(session, "_http_prefetch_prev_idx", None)
+            direction = 1
+            if prev_idx is not None and len(prev_idx) == len(idx_tuple):
+                delta = idx_tuple[slice_dim] - prev_idx[slice_dim]
+                if delta:
+                    direction = 1 if delta > 0 else -1
+            session._http_prefetch_prev_idx = idx_tuple
+            _schedule_prefetch(session, dim_x, dim_y, list(idx_tuple), slice_dim, direction)
         encode_t0 = time.perf_counter()
         img = _pil_image().fromarray(rgba[:, :, :3], mode="RGB")
         buf = io.BytesIO()

arrayview/_routes_vectorfield.py

@@ -79,26 +79,27 @@ def register_vectorfield_routes(app) -> None:
         staging_dir = validated_staging_directory(filepath, claimed_staging)
         if claimed_staging and staging_dir is None:
             raise HTTPException(status_code=400, detail="invalid source staging directory")
-        unsafe_mount = direct_network_mount(filepath)
-        if unsafe_mount is not None:
-            return {
-                "error": (
-                    f"Direct server access to network mount {unsafe_mount.mountpoint!r} "
-                    "is refused; launch through the arrayview CLI."
-                )
-            }
-        nested_mount = network_mount_below(filepath)
-        if source_may_require_sibling_discovery(filepath):
-            nested_mount = nested_mount or network_mount_below(
-                os.path.dirname(filepath)
-            )
-        if nested_mount is not None:
-            return {
-                "error": (
-                    f"Vector-field discovery would enter network mount "
-                    f"{nested_mount.mountpoint!r}; copy it locally first."
+        if os.environ.get("ARRAYVIEW_SKIP_SOURCE_STAGING", "1") == "0":
+            unsafe_mount = direct_network_mount(filepath)
+            if unsafe_mount is not None:
+                return {
+                    "error": (
+                        f"Direct server access to network mount {unsafe_mount.mountpoint!r} "
+                        "is refused; launch through the arrayview CLI."
+                    )
+                }
+            nested_mount = network_mount_below(filepath)
+            if source_may_require_sibling_discovery(filepath):
+                nested_mount = nested_mount or network_mount_below(
+                    os.path.dirname(filepath)
                 )
-            }
+            if nested_mount is not None:
+                return {
+                    "error": (
+                        f"Vector-field discovery would enter network mount "
+                        f"{nested_mount.mountpoint!r}; copy it locally first."
+                    )
+                }
         components_dim = body.get("components_dim")
         session = SESSIONS.get(sid)
         if not session:

arrayview/_routes_websocket.py

@@ -369,7 +369,7 @@ def register_websocket_routes(app) -> None:
         try:
             from arrayview import _extra_ports
 
-            _extra_ports.viewer_connected(arrived_on)
+            _extra_ports.viewer_connected(arrived_on, launch_request_id)
         except Exception:
             pass
         _session_mod.VIEWER_SID_COUNTS[sid] = (

arrayview/_server.py

@@ -293,20 +293,55 @@ def get_shell():
 
 
 @app.post("/cold-start-port")
-async def cold_start_port():
+async def cold_start_port(payload: dict):
     """Serve this same server on one more, never-before-forwarded port.
 
-    Asked for only when no viewer is connected.  A forward VS Code has just
-    created does not drop its first requests, while one that has sat idle does,
-    and that is what makes a cold launch flicker.  The port is released as soon
-    as no viewer is connected anywhere.
+    A forward VS Code has just created does not drop its first requests, while
+    one that has sat idle for tens of seconds drops the first two to four.  So
+    the viewer page is served from an extra port rather than the main one: a
+    fresh port for the first launch, then that same port is leased to later
+    launches.  A lease keeps the route alive between handoff and connection,
+    including when the previous viewer closes during that gap.  The port is
+    released only after its last viewer and its last bounded lease are gone.
     """
     from arrayview import _extra_ports
 
-    if _session_mod.VIEWER_SOCKETS > 0:
-        return {"port": None, "reason": "a viewer is already connected"}
-    port = await _extra_ports.open_extra_port()
-    return {"port": port}
+    request_id = payload.get("requestId")
+    ttl_ms = payload.get("ttlMs")
+    expected_server_id = payload.get("expectedServerId")
+    compatibility_request = not payload
+    if compatibility_request:
+        # Opener 0.15.47 shipped before correlated leases. Keep that already-
+        # loaded host working after the Python package updates, so users are
+        # not forced to reload a VS Code window merely to open the next array.
+        request_id = f"compat-{uuid.uuid4().hex}"
+        ttl_ms = 240_000
+        expected_server_id = _session_mod.SERVER_RUNTIME.instance_id
+    if not isinstance(request_id, str) or not request_id.strip():
+        raise HTTPException(status_code=400, detail="requestId is required")
+    if isinstance(ttl_ms, bool) or not isinstance(ttl_ms, int) or ttl_ms <= 0:
+        raise HTTPException(status_code=400, detail="ttlMs must be a positive integer")
+    if not isinstance(expected_server_id, str) or not expected_server_id:
+        raise HTTPException(status_code=400, detail="expectedServerId is required")
+    actual_server_id = _session_mod.SERVER_RUNTIME.instance_id
+    if expected_server_id != actual_server_id:
+        raise HTTPException(
+            status_code=409,
+            detail="The requested ArrayView backend no longer owns this port",
+        )
+    port, reused = await _extra_ports.acquire_viewer_port(request_id, ttl_ms)
+    if port is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Could not prepare the private VS Code viewer connection",
+        )
+    return {
+        "port": port,
+        "reused": reused,
+        "ttlMs": min(ttl_ms, _extra_ports.MAX_LEASE_TTL_MS),
+        "compatibility": compatibility_request,
+        "requestId": request_id,
+    }
 
 
 @app.get("/ping")

arrayview/_session.py

@@ -141,14 +141,22 @@ _OVERLAY_PREFETCH_POOL = None
 _PREFETCH_LOCK = threading.Lock()
 
 
+_PREFETCH_WORKERS: int = max(2, min(4, os.cpu_count() or 2))
+
+
 def _get_prefetch_pool():
     global _PREFETCH_POOL
     with _PREFETCH_LOCK:
         if _PREFETCH_POOL is None or _PREFETCH_POOL._shutdown:
             import concurrent.futures
 
+            # One pool is shared by every open session (see _schedule_prefetch).
+            # A single worker meant a second open array serialized behind the
+            # first array's lookahead, so scrolling any pane lagged. Size like
+            # _RENDER_WORKERS so a handful of concurrently open arrays each get
+            # a lane.
             _PREFETCH_POOL = concurrent.futures.ThreadPoolExecutor(
-                max_workers=1, thread_name_prefix="arrayview-prefetch"
+                max_workers=_PREFETCH_WORKERS, thread_name_prefix="arrayview-prefetch"
             )
         return _PREFETCH_POOL
 
@@ -674,6 +682,7 @@ __all__ = [
     "_render",
     # Prefetch
     "_PREFETCH_POOL",
+    "_PREFETCH_WORKERS",
     "_OVERLAY_PREFETCH_POOL",
     "_PREFETCH_LOCK",
     "_get_prefetch_pool",

arrayview/_source_safety.py

@@ -713,6 +713,14 @@ def prepare_source(path: str, *, timeout: float | None = None) -> PreparedSource
     """Preflight and, for a network file, make a bounded local snapshot."""
     absolute = lexical_abspath(path)
     mount = mount_for_path(absolute)
+    if os.environ.get("ARRAYVIEW_SKIP_SOURCE_STAGING", "1") != "0":
+        # Network-source staging is opt-in, not the default: use the source
+        # path directly, exactly like a local file. This is the pre-staging
+        # behavior (fast open, but a dropped network mount while the file is
+        # memory-mapped can wedge the process in a way not even `kill -9`
+        # recovers from — see docs/loading.md). Set
+        # ARRAYVIEW_SKIP_SOURCE_STAGING=0 to restore the safety copy.
+        return PreparedSource(absolute, absolute, None, mount)
     if mount is None or mount.filesystem not in _NETWORK_FILESYSTEMS:
         unsafe_discovery = discovery_network_mount(absolute)
         if unsafe_discovery is not None: