web_interface: improve onnxruntime load-failure recovery

- Surface the actual ImportError before any installer prompt.
- Detect VC++ runtime (vcruntime140/msvcp140) before launching the
UAC installer, so users with VC++ already installed aren't asked
to elevate for a fix that wouldn't help.
- Detect AVX2 via IsProcessorFeaturePresent and auto-downgrade to
onnxruntime==1.17.3 (last AVX-only release) on non-AVX2 CPUs.
- Track recovery attempts via env var to avoid infinite re-exec loops.

web_interface/app.py

@@ -49,6 +49,12 @@ PYENV_MARKER = PYENV_DIR / ".bootstrapped"
 # "DLL load failed while importing onnxruntime_pybind11_state".
 VC_REDIST_URL = "https://aka.ms/vs/17/release/vc_redist.x64.exe"
 
+# Last onnxruntime release that ships AVX-only (no-AVX2) wheels. ORT >= 1.18
+# requires AVX2; on older CPUs the import fails with the same generic
+# "DLL load failed" message as a missing VC++ runtime. We pin to this version
+# as an automatic fallback when AVX2 is not detected.
+ORT_NO_AVX2_FALLBACK_VERSION = "1.17.3"
+
 # Default folder if it exists; otherwise the first auto-discovered folder
 # next to this script is used. Override with --model-dir or the UI picker.
 DEFAULT_MODEL_DIR = ROOT / "V1.1_onnx"
@@ -200,19 +206,68 @@ def _bootstrap_portable(force_reinstall: bool) -> None:
 
 
 # ---------------------------------------------------------------------------
-# onnxruntime / Visual C++ runtime recovery
+# onnxruntime / Visual C++ runtime / AVX2 recovery
 # ---------------------------------------------------------------------------
 
-def _looks_like_vcredist_failure(err: BaseException) -> bool:
-    """Heuristic: did onnxruntime fail to load because VC++ runtime DLLs
-    aren't on the box? The exact wording varies slightly by Windows version
-    but always mentions the failed DLL by name."""
+# Tracks which automatic recoveries have already run, propagated to re-execs
+# via the environment so we don't loop forever if a fix doesn't actually fix
+# things (e.g. UAC accepted but the install silently failed).
+_RECOVERY_ATTEMPTS_VAR = "_OPPAI_RECOVERY_ATTEMPTS"
+
+
+def _looks_like_native_load_failure(err: BaseException) -> bool:
+    """Heuristic: did onnxruntime fail at native-DLL load time? Both a
+    missing VC++ runtime and a missing AVX2 instruction set produce the same
+    "DLL load failed while importing onnxruntime_pybind11_state" message, so
+    we leave it to _recover_after_onnxruntime_load_failure to tell them apart."""
     if os.name != "nt":
         return False
     msg = str(err)
     return "DLL load failed" in msg and "onnxruntime_pybind11_state" in msg
 
 
+def _has_vcruntime() -> bool:
+    """True if the VC++ 2015-2022 runtime DLLs are present in System32. We
+    look at vcruntime140.dll and msvcp140.dll because onnxruntime's native
+    code links against both."""
+    if os.name != "nt":
+        return True
+    sys32 = Path(os.environ.get("WINDIR", r"C:\Windows")) / "System32"
+    return (sys32 / "vcruntime140.dll").exists() and (sys32 / "msvcp140.dll").exists()
+
+
+def _has_avx2() -> bool:
+    """True if the OS reports AVX2 support via IsProcessorFeaturePresent
+    (PF_AVX2_INSTRUCTIONS_AVAILABLE = 40). Conservative on error: returns
+    True if the API can't be called, so we don't downgrade ORT spuriously."""
+    if os.name != "nt":
+        return True
+    try:
+        import ctypes
+        return bool(ctypes.windll.kernel32.IsProcessorFeaturePresent(40))
+    except OSError:
+        return True
+
+
+def _onnxruntime_version() -> str | None:
+    try:
+        import importlib.metadata as md
+        return md.version("onnxruntime")
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _recovery_attempted(name: str) -> bool:
+    return name in os.environ.get(_RECOVERY_ATTEMPTS_VAR, "").split(",")
+
+
+def _mark_recovery_attempted(name: str) -> None:
+    cur = [p for p in os.environ.get(_RECOVERY_ATTEMPTS_VAR, "").split(",") if p]
+    if name not in cur:
+        cur.append(name)
+    os.environ[_RECOVERY_ATTEMPTS_VAR] = ",".join(cur)
+
+
 def _install_vcredist_with_uac() -> bool:
     """Download vc_redist.x64.exe and run it elevated. Returns True on
     apparent success (exit 0 or 3010 = success-pending-reboot)."""
@@ -263,34 +318,87 @@ def _install_vcredist_with_uac() -> bool:
     return False
 
 
-def _recover_and_relaunch_after_vcredist() -> None:
-    """Try to install the VC++ redistributable, then re-exec the launcher so
-    the onnxruntime DLL gets a fresh load attempt. Windows caches failed DLL
-    loads within a process, so re-importing in-place doesn't work."""
+def _downgrade_onnxruntime_for_no_avx2() -> bool:
+    """Force-reinstall onnxruntime at the last AVX-only release into the
+    current interpreter. Returns True on apparent pip success."""
+    target = f"onnxruntime=={ORT_NO_AVX2_FALLBACK_VERSION}"
+    print(f"[runtime] Reinstalling {target} (this CPU lacks AVX2) ...")
+    try:
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "--force-reinstall", target]
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"[runtime] pip install failed: {e}")
+        return False
+
+
+def _relaunch_app() -> None:
+    """Re-exec app.py in the same interpreter so onnxruntime gets a fresh
+    DLL-load attempt. Windows caches failed loads within a process, so an
+    in-place re-import never picks up a newly-installed runtime or wheel."""
+    args = [a for a in sys.argv[1:] if a != "--reinstall"]
+    print("\n[runtime] Re-launching the app ...\n")
+    rc = subprocess.call([sys.executable, str(Path(__file__).resolve()), *args])
+    sys.exit(rc)
+
+
+def _recover_after_onnxruntime_load_failure(err: BaseException) -> None:
+    """Diagnose why onnxruntime's native load failed, attempt the matching
+    recovery (install VC++ runtime, or downgrade ORT for non-AVX2 CPUs),
+    then re-exec. Exits 1 with diagnostics if no automatic fix applies."""
+    has_vc = _has_vcruntime()
+    has_avx2 = _has_avx2()
+    ort_ver = _onnxruntime_version()
+
     print()
     print("=" * 60)
     print("  onnxruntime failed to load")
     print("=" * 60)
-    print("This almost always means the Microsoft Visual C++ 2015-2022")
-    print("Redistributable (x64) is missing on this Windows machine.")
-    print("Trying to install it for you now — you'll see a UAC prompt.")
+    print(f"Underlying error: {err}")
+    print(f"  installed onnxruntime:  {ort_ver or 'unknown'}")
+    print(f"  VC++ 2015-2022 runtime: {'present' if has_vc else 'missing'}")
+    print(f"  CPU AVX2 support:       {'yes' if has_avx2 else 'no'}")
     print()
 
-    if not _install_vcredist_with_uac():
+    if not has_vc and not _recovery_attempted("vcredist"):
+        print("VC++ runtime is missing — installing it now.")
+        print("Accept the UAC prompt that appears.")
+        _mark_recovery_attempted("vcredist")
+        if _install_vcredist_with_uac():
+            _relaunch_app()
+            return
         print()
         print("Manual fix:")
         print(f"  1. Download {VC_REDIST_URL}")
         print("  2. Run it (accept the UAC prompt)")
         print("  3. Re-run this script")
+        sys.exit(1)
+
+    if not has_avx2 and not _recovery_attempted("avx2_downgrade"):
+        print("CPU lacks AVX2 — modern onnxruntime wheels require it.")
+        _mark_recovery_attempted("avx2_downgrade")
+        if _downgrade_onnxruntime_for_no_avx2():
+            _relaunch_app()
+            return
         print()
-        print("If install keeps failing, your CPU may lack AVX2 support, which")
-        print("modern onnxruntime wheels require. Most CPUs from 2014+ have it.")
+        print("Manual fix:")
+        print(
+            f"  {sys.executable} -m pip install --force-reinstall "
+            f"onnxruntime=={ORT_NO_AVX2_FALLBACK_VERSION}"
+        )
         sys.exit(1)
 
-    args = [a for a in sys.argv[1:] if a != "--reinstall"]
-    print("\n[runtime] Visual C++ runtime installed. Re-launching the app ...\n")
-    rc = subprocess.call([sys.executable, str(Path(__file__).resolve()), *args])
-    sys.exit(rc)
+    # Either every known recovery has already been tried, or VC++ is present
+    # and AVX2 is reported — the cause is something we can't fix automatically.
+    print("No automatic recovery applies. Likely culprits:")
+    print("  - Antivirus quarantining onnxruntime_pybind11_state.pyd")
+    print(
+        f"  - Corrupt install: {sys.executable} -m pip install "
+        "--force-reinstall onnxruntime"
+    )
+    print("  - 32-bit Python loading 64-bit wheels (or vice versa)")
+    sys.exit(1)
 
 
 # ---------------------------------------------------------------------------
@@ -466,8 +574,8 @@ def _run_app() -> None:
     try:
         import onnxruntime as ort
     except ImportError as e:
-        if _looks_like_vcredist_failure(e):
-            _recover_and_relaunch_after_vcredist()
+        if _looks_like_native_load_failure(e):
+            _recover_after_onnxruntime_load_failure(e)
             sys.exit(1)  # only reached if recover failed without exiting
         raise
     import gradio as gr