@@ -13,7 +13,11 @@
 import shlex
 import subprocess
 import sys
+import time
+from datetime import datetime, timezone
+from http.server import BaseHTTPRequestHandler, HTTPServer
 from pathlib import Path
+from threading import Thread
 from types import SimpleNamespace
 
 import pytest
@@ -128,6 +132,158 @@ def test_existing_hf_download_accepts_matching_hash(tmp_path, monkeypatch):
     ) == str(tmp_path)
 
 
+@pytest.mark.parametrize(
+    "headers, expected_wait",
+    [
+        (
+            {
+                "RateLimit": '"api";r=0;t=36',
+                "RateLimit-Policy": '"fixed window";"api";q=500;w=300',
+            },
+            37,
+        ),
+        ({"Retry-After": "36"}, 37),
+        ({"Retry-After": "Mon, 19 Oct 2026 17:50:36 GMT"}, 37),
+        ({"RateLimit": '"api";r=0;t=36', "Retry-After": "50"}, 51),
+        ({"RateLimit": '"api";r=0;t=36', "Retry-After": "invalid"}, 37),
+        ({"RateLimit": '"api";r=10;t=900', "Retry-After": "36"}, 37),
+    ],
+)
+def test_hf_snapshot_retries_rate_limited_repo_tree(
+    tmp_path, monkeypatch, capsys, headers, expected_wait
+):
+    from huggingface_hub import HfApi
+
+    module = load_existing_module("examples/models/llama/hf_download.py")
+    requests = []
+    calls = []
+    waits = []
+    monkeypatch.setenv("NO_PROXY", "127.0.0.1,localhost")
+    monkeypatch.setattr(time, "sleep", waits.append)
+    monkeypatch.setattr(
+        time,
+        "time",
+        lambda: datetime(2026, 10, 19, 17, 50, tzinfo=timezone.utc).timestamp(),
+    )
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            requests.append(self.path)
+            self.send_response(429 if len(requests) == 1 else 200)
+            if len(requests) == 1:
+                for name, value in headers.items():
+                    self.send_header(name, value)
+            self.send_header("Content-Type", "application/json")
+            self.end_headers()
+            self.wfile.write(
+                b'{"error": "Rate limited"}' if len(requests) == 1 else b"[]"
+            )
+
+        def log_message(self, *args):
+            pass
+
+    server = HTTPServer(("127.0.0.1", 0), Handler)
+    thread = Thread(target=server.serve_forever)
+    thread.start()
+    api = HfApi(endpoint=f"http://127.0.0.1:{server.server_port}")
+
+    def snapshot(**kwargs):
+        calls.append(kwargs)
+        list(
+            api.list_repo_tree(
+                kwargs["repo_id"],
+                revision=kwargs["revision"],
+                token=kwargs["token"],
+                recursive=True,
+            )
+        )
+        return str(tmp_path)
+
+    monkeypatch.setattr(module, "snapshot_download", snapshot)
+    try:
+        assert module.download_hf_snapshot("test/model", "r" * 40) == str(tmp_path)
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join()
+    assert len(requests) == 2 and requests[0] == requests[1]
+    assert (
+        calls
+        == [
+            {
+                "repo_id": "test/model",
+                "revision": "r" * 40,
+                "allow_patterns": ["*.safetensors", "*.json"],
+                "token": False,
+            }
+        ]
+        * 2
+    )
+    assert waits == [expected_wait]
+    output = capsys.readouterr()
+    assert output.out == ""
+    assert str(expected_wait) in output.err
+
+
+@pytest.mark.parametrize(
+    "headers", [{}, {"Retry-After": "invalid"}, {"RateLimit": '"api";r=10;t=900'}]
+)
+def test_hf_snapshot_rate_limit_retry_exhaustion(monkeypatch, headers):
+    import httpx
+    from huggingface_hub.errors import HfHubHTTPError
+
+    module = load_existing_module("examples/models/llama/hf_download.py")
+    response = httpx.Response(
+        429,
+        headers=headers,
+        request=httpx.Request("GET", "https://example.com"),
+    )
+    error = HfHubHTTPError("Rate limited", response=response)
+    calls = []
+    waits = []
+
+    def rate_limited(**kwargs):
+        calls.append(kwargs)
+        raise error
+
+    monkeypatch.setattr(module, "snapshot_download", rate_limited)
+    monkeypatch.setattr(time, "sleep", waits.append)
+    with pytest.raises(HfHubHTTPError) as raised:
+        module.download_hf_snapshot("test/model", "r" * 40)
+    assert raised.value is error
+    assert len(calls) == 6
+    assert waits == [60, 120, 240, 300, 300]
+
+
+@pytest.mark.parametrize("status", [401, 404, 503, None])
+def test_hf_snapshot_does_not_retry_other_http_errors(monkeypatch, status):
+    import httpx
+    from huggingface_hub.errors import HfHubHTTPError
+
+    module = load_existing_module("examples/models/llama/hf_download.py")
+    response = httpx.Response(
+        status or 429,
+        request=httpx.Request("GET", "https://example.com"),
+    )
+    error = HfHubHTTPError("Download failed", response=response)
+    if status is None:
+        error.response = None
+    calls = []
+    waits = []
+
+    def failed(**kwargs):
+        calls.append(kwargs)
+        raise error
+
+    monkeypatch.setattr(module, "snapshot_download", failed)
+    monkeypatch.setattr(time, "sleep", waits.append)
+    with pytest.raises(HfHubHTTPError) as raised:
+        module.download_hf_snapshot("test/model", "r" * 40)
+    assert raised.value is error
+    assert len(calls) == 1
+    assert waits == []
+
+
 def test_snapshot_cli_exposes_pinned_download_and_checksum(
     tmp_path, monkeypatch, capsys
 ):
 
@@ -1,7 +1,7 @@
 #!/bin/bash
 # Copyright (c) Meta Platforms, Inc. and affiliates.
 # All rights reserved.
-# Copyright 2024 Arm Limited and/or its affiliates.
+# Copyright 2024,2026 Arm Limited and/or its affiliates.
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
@@ -50,8 +50,9 @@ dedupe_macos_loader_path_rpaths() {
   fi
 
   local torch_lib_dir
+  local python_executable=${PYTHON_EXECUTABLE:-python}
   pushd ..
-  torch_lib_dir=$(python -c "import importlib.util; print(importlib.util.find_spec('torch').submodule_search_locations[0])")/lib
+  torch_lib_dir=$("${python_executable}" -c "import importlib.util; print(importlib.util.find_spec('torch').submodule_search_locations[0])")/lib
   popd
 
   if [[ -z "${torch_lib_dir}" || ! -d "${torch_lib_dir}" ]]; then
@@ -83,12 +84,16 @@ dedupe_macos_loader_path_rpaths() {
 }
 
 install_domains() {
+  local python_executable=${PYTHON_EXECUTABLE:-python}
   echo "Install torchvision and torchaudio"
-  pip install --no-build-isolation --user "git+https://github.com/pytorch/audio.git@${TORCHAUDIO_VERSION}"
-  pip install --no-build-isolation --user "git+https://github.com/pytorch/vision.git@${TORCHVISION_VERSION}"
+  "${python_executable}" -m pip install --no-build-isolation \
+    "git+https://github.com/pytorch/audio.git@${TORCHAUDIO_VERSION}"
+  "${python_executable}" -m pip install --no-build-isolation \
+    "git+https://github.com/pytorch/vision.git@${TORCHVISION_VERSION}"
 }
 
 install_pytorch_and_domains() {
+  local python_executable=${PYTHON_EXECUTABLE:-python}
   pushd .ci/docker || return
   TORCH_VERSION=$(cat ci_commit_pins/pytorch.txt)
   popd || return
@@ -101,9 +106,9 @@ install_pytorch_and_domains() {
 
   local system_name=$(uname)
   if [[ "${system_name}" == "Darwin" ]]; then
-    local platform=$(python -c 'import sysconfig; import platform; v=platform.mac_ver()[0].split(".")[0]; platform=sysconfig.get_platform().split("-"); platform[1]=f"{v}_0"; print("_".join(platform))')
+    local platform=$("${python_executable}" -c 'import sysconfig; import platform; v=platform.mac_ver()[0].split(".")[0]; platform=sysconfig.get_platform().split("-"); platform[1]=f"{v}_0"; print("_".join(platform))')
   fi
-  local python_version=$(python -c 'import platform; v=platform.python_version_tuple(); print(f"{v[0]}{v[1]}")')
+  local python_version=$("${python_executable}" -c 'import platform; v=platform.python_version_tuple(); print(f"{v[0]}{v[1]}")')
   local torch_release=$(cat version.txt)
   # Download key must match the upload key below (basename of dist/*.whl,
   # which always carries the build's resolved +gitHASH). Branch-ref pins
@@ -118,7 +123,7 @@ install_pytorch_and_domains() {
   # of the Docker image
   local torch_wheel_not_found=0
   if [[ "${system_name}" == "Darwin" ]]; then
-    pip install "${cached_torch_wheel}" || torch_wheel_not_found=1
+    "${python_executable}" -m pip install "${cached_torch_wheel}" || torch_wheel_not_found=1
   else
     torch_wheel_not_found=1
   fi
@@ -138,14 +143,14 @@ install_pytorch_and_domains() {
     # Keep in sync with pytorch/pyproject.toml [build-system].requires.
     local build_venv=/tmp/pytorch-build-venv
     rm -rf "${build_venv}"
-    python -m venv --system-site-packages "${build_venv}"
+    "${python_executable}" -m venv --system-site-packages "${build_venv}"
     "${build_venv}/bin/pip" install build "scikit-build-core>=1.0" ninja \
       "packaging>=24.2" "typing-extensions>=4.10.0" pyyaml six numpy
     USE_DISTRIBUTED=1 "${build_venv}/bin/python" -m build --wheel --no-isolation
     rm -rf "${build_venv}"
-    pip install "$(echo dist/*.whl)"
+    "${python_executable}" -m pip install "$(echo dist/*.whl)"
     # A build with no BLAS succeeds silently, so check rather than assume.
-    (cd / && python -c "
+    (cd / && "${python_executable}" -c "
 import torch
 assert torch._C.has_lapack, 'built without LAPACK'
 torch.linalg.qr(torch.randn(4, 4))
 
@@ -143,6 +143,27 @@ def test_cuda_libraries_resolve_relatively() -> None:
         print(f"✓ {name} resolves the CUDA runtime relatively ({relative[0]})")
 
 
+def test_no_library_needs_cuda_torch() -> None:
+    """No shipped library may record a dependency on PyTorch's own CUDA libraries.
+
+    The CUDA delegate needs only the CUDA runtime. A library that names libtorch_cuda or
+    libc10_cuda cannot load next to a CPU-only torch, so the whole wheel then fails to import
+    there even though nothing in it calls into those libraries.
+    """
+    package_dir = _package_dir()
+    cuda_torch = {"libtorch_cuda.so", "libc10_cuda.so"}
+    offenders = {}
+    for library in test_shared_libraries._shipped_shared_objects(package_dir):
+        needed = test_shared_libraries._recorded_dependencies(library) & cuda_torch
+        if needed:
+            offenders[str(library.relative_to(package_dir))] = sorted(needed)
+    assert not offenders, (
+        f"these libraries depend on PyTorch's CUDA libraries, so the wheel cannot be imported "
+        f"with a CPU-only torch: {offenders}"
+    )
+    print("✓ no shipped library depends on PyTorch's CUDA libraries")
+
+
 def _row_architectures() -> list[str]:
     """The architectures this row claims, from the same script the build uses.
 
@@ -586,6 +607,7 @@ def test_a_model_runs_through_the_delegate() -> None:
     test_cuda_libraries_are_shipped()
     test_cuda_runtime_is_declared()
     test_cuda_libraries_resolve_relatively()
+    test_no_library_needs_cuda_torch()
     test_device_code_covers_the_row()
     test_portable_device_code_is_present()
     test_the_delegate_registers()
 
@@ -168,7 +168,7 @@ jobs:
           source backends/qualcomm/scripts/qnn_config.sh
           export QNN_SDK_ROOT="/tmp/qnn/${QNN_VERSION}"
           export ANDROID_ABIS=arm64-v8a
-          GRADLE_ARGS+=" -DqnnVersion=2.50.0"
+          GRADLE_ARGS+=" -DqnnVersion=${QNN_VERSION%.*}"
         fi
 
         # Build AAR Package