Force local_files_only on open_clip's own hf_hub_download reference

Live repro crashed the previous fix's own debug line: AttributeError,
huggingface_hub.constants has no is_offline_mode() on the deployed version —
meaning the whole HF_HUB_OFFLINE/is_offline_mode() approach was built against
the wrong version's internals, explaining why neither prior attempt (78108d3,
035533f) actually stopped the live re-download despite being individually
verified against huggingface_hub 1.23.0 in isolation.

The traceback also showed the @spaces.GPU call running through
anyio.to_thread.run_sync — a worker thread in the same process, not the
separate process the code's own docstrings had suggested — so process
isolation wasn't the blocker either.

Rather than keep chasing which offline-mode attribute the actually-deployed
huggingface_hub version honors, sidestep it: open_clip.pretrained binds its
own local `hf_hub_download` name at import time
(`from huggingface_hub import hf_hub_download`), so monkeypatch that specific
module-level reference to force local_files_only=True on every call. That
parameter's handling (skip the network HEAD call, fall back to whatever's
cached locally under the repo) is a much more fundamental, version-stable
code path than the HF_HUB_OFFLINE constant-freezing chain, and is exactly
what made the earlier isolated repro (scenario_b.py) correctly resolve via
the mirror-snapshot cache without hitting the network.

Also made the debug print defensive (getattr with fallback) so a future
version mismatch degrades gracefully instead of crashing the whole call.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

app.py

@@ -232,46 +232,51 @@ print(f"[startup] main process pid={os.getpid()}")
 
 # Force any later HF Hub call to be cache-only. With every encoder cache
 # pre-populated above from the user's mirror, downstream from_pretrained()
-# calls (CLAP, AudioLDM2, MMAudio's open_clip 'hf-hub:...') resolve from
-# the populated cache instead of networking out to upstream — full
-# upstream-protection mode.
-#
-# Setting only the env var is NOT enough: huggingface_hub.constants.HF_HUB_OFFLINE
-# is computed once from os.environ at *import time* (constants.py), and
-# huggingface_hub was already imported above (line ~32) before this point, so
-# the env var alone never takes effect for the rest of this process. Confirmed
-# live: MMAudio's open_clip CLIP loader (create_model_from_pretrained('hf-hub:
-# apple/DFN5B-CLIP-ViT-H-14-384', ...)) still resolved "main" over the network,
-# didn't match our locally mirrored 'mirror-snapshot' cache entry's fake commit
-# hash, and re-downloaded the full ~4GB checkpoint mid-GPU-call — verified via
-# an isolated repro against the real huggingface_hub package (see scratchpad).
-# Patching the already-imported module's constant directly is what actually
-# gates the HTTP layer (huggingface_hub/utils/_http.py reads it live via
-# constants.is_offline_mode()), which is shared by transformers/diffusers/
-# open_clip alike since they all delegate the actual network call to it.
+# calls (CLAP, AudioLDM2) resolve from the populated cache instead of
+# networking out to upstream. Best-effort: the exact attribute name/shape of
+# huggingface_hub's offline-mode internals has proven to vary by installed
+# version (an is_offline_mode() debug print crashed live with AttributeError,
+# meaning the deployed version's constants.py doesn't match what was tested
+# against locally) — os.environ is the one thing every version reads at
+# *some* point, so set it and best-effort mirror it onto the constant too,
+# but don't rely on this alone (see the open_clip-specific patch below for
+# the one confirmed, reproduced failure).
 os.environ["HF_HUB_OFFLINE"] = "1"
+import huggingface_hub
 import huggingface_hub.constants as _hf_constants
-_hf_constants.HF_HUB_OFFLINE = True
+print(f"[startup] huggingface_hub version={getattr(huggingface_hub, '__version__', '?')}")
+if hasattr(_hf_constants, "HF_HUB_OFFLINE"):
+    _hf_constants.HF_HUB_OFFLINE = True
 
 def _ensure_offline_in_worker():
-    """Re-assert offline mode from inside a @spaces.GPU function's own body.
-
-    The module-level patch above (and an earlier attempt inside _catch_oom's
-    wrapper, which sits *outside* the raw function) both failed to stop
-    MMAudio's open_clip CLIP loader from re-downloading its ~4GB checkpoint
-    live during GPU inference — confirmed via a direct HTTP repro against the
-    deployed Space. This codebase's own docstrings already document that
-    @spaces.GPU functions run in a genuinely separate "GPU worker process"
-    (see e.g. _mmaudio_gpu_infer: "kwargs are silently dropped" / paths must
-    "exist in the GPU worker's process"), so any patch applied by code that
-    merely *wraps* the call — rather than running inside the function body
-    that's actually shipped to and executed by that worker — never reaches
-    it. Calling this as literally the first line of each raw GPU function
-    guarantees it runs wherever that function's own bytecode runs."""
+    """Re-assert offline mode from inside a @spaces.GPU function's own body
+    (called as the first line of all six raw GPU functions) in case the
+    worker thread anyio dispatches @spaces.GPU calls onto doesn't share the
+    same already-mutated module state as the main thread."""
     os.environ["HF_HUB_OFFLINE"] = "1"
-    _hf_constants.HF_HUB_OFFLINE = True
-    print(f"[_ensure_offline_in_worker] pid={os.getpid()} HF_HUB_OFFLINE={_hf_constants.HF_HUB_OFFLINE} "
-          f"is_offline_mode()={_hf_constants.is_offline_mode()}")
+    if hasattr(_hf_constants, "HF_HUB_OFFLINE"):
+        _hf_constants.HF_HUB_OFFLINE = True
+    print(f"[_ensure_offline_in_worker] pid={os.getpid()} "
+          f"HF_HUB_OFFLINE={getattr(_hf_constants, 'HF_HUB_OFFLINE', '?')}")
+
+# The one CONFIRMED, reproduced failure: MMAudio's open_clip CLIP loader
+# (create_model_from_pretrained('hf-hub:apple/DFN5B-CLIP-ViT-H-14-384', ...))
+# re-downloads its ~4GB checkpoint live during GPU inference regardless of the
+# HF_HUB_OFFLINE patches above — verified via a direct HTTP repro against the
+# deployed Space (queue/join straight to _run_mmaudio, bypassing the browser).
+# open_clip.pretrained calls a *bound* local reference to hf_hub_download
+# (`from huggingface_hub import hf_hub_download` at its own import time), so
+# rather than continue chasing which huggingface_hub-internal offline-mode
+# attribute the deployed version actually honors, force the one parameter
+# that unambiguously controls this regardless of version: local_files_only.
+import open_clip.pretrained as _open_clip_pretrained
+_orig_open_clip_hf_hub_download = _open_clip_pretrained.hf_hub_download
+
+def _patched_open_clip_hf_hub_download(*args, **kwargs):
+    kwargs["local_files_only"] = True
+    return _orig_open_clip_hf_hub_download(*args, **kwargs)
+
+_open_clip_pretrained.hf_hub_download = _patched_open_clip_hf_hub_download
 
 # ================================================================== #
 #                     SHARED CONSTANTS / HELPERS                      #