Untangle kernel loading, part2

kernels/src/kernels/__init__.py

@@ -6,6 +6,7 @@
 
 from kernels._windows import _add_additional_dll_paths
 from kernels.benchmark import Benchmark
+from kernels.hf_hub import RepoInfo
 from kernels.layer import (
     CUDAProperties,
     Device,
@@ -27,7 +28,6 @@
 )
 from kernels.utils import (
     LoadedKernel,
-    RepoInfo,
     get_kernel,
     get_kernel_variants,
     get_loaded_kernels,

kernels/src/kernels/_versions.py

@@ -11,7 +11,7 @@
 
 def _get_available_versions(repo_id: str) -> dict[int, GitRefInfo]:
     """Get kernel versions that are available in the repository."""
-    from kernels.utils import _get_hf_api
+    from kernels.hf_hub import _get_hf_api
 
     if constants.HF_HUB_OFFLINE:
         return _get_available_versions_from_cache(repo_id)

kernels/src/kernels/cli/benchmark.py

@@ -21,7 +21,8 @@
 )
 
 from kernels.benchmark import Benchmark
-from kernels.utils import _backend, _get_hf_api
+from kernels.hf_hub import _get_hf_api
+from kernels.utils import _backend
 
 MISSING_DEPS: list[str] = []
 

kernels/src/kernels/cli/info.py

@@ -6,7 +6,7 @@
 from kernels_data import Metadata
 
 from kernels._versions import _get_available_versions, resolve_version_spec_as_ref
-from kernels.utils import CACHE_DIR, _get_hf_api
+from kernels.hf_hub import CACHE_DIR, _get_hf_api
 from kernels.variants import (
     ArchVariant,
     Variant,

kernels/src/kernels/cli/versions.py

@@ -1,5 +1,5 @@
 from kernels._versions import _get_available_versions
-from kernels.utils import _get_hf_api
+from kernels.hf_hub import _get_hf_api
 from kernels.variants import (
     get_variants,
     resolve_variants,

kernels/src/kernels/hf_hub.py

@@ -0,0 +1,148 @@
+import os
+import platform
+import warnings
+from dataclasses import dataclass
+
+from huggingface_hub import HfApi, constants
+
+from kernels._system import glibc_version
+from kernels.backends import _select_backend
+from kernels.compat import has_torch, has_tvm_ffi
+
+
+def _platform() -> str:
+    cpu = platform.machine()
+    os = platform.system().lower()
+
+    if os == "darwin":
+        cpu = "aarch64" if cpu == "arm64" else cpu
+    elif os == "windows":
+        cpu = "x86_64" if cpu == "AMD64" else cpu
+
+    return f"{cpu}-{os}"
+
+
+def _get_hf_api(user_agent: str | dict | None = None) -> HfApi:
+    """Returns an instance of HfApi with proper settings."""
+
+    from . import __version__
+
+    user_agent_str = ""
+    if not constants.HF_HUB_DISABLE_TELEMETRY:
+        parts: list[str] = []
+
+        # User-defined info
+        if isinstance(user_agent, dict):
+            parts.extend(f"{k}/{v}" for k, v in user_agent.items())
+        elif isinstance(user_agent, str) and user_agent:
+            parts.append(user_agent)
+
+        # System info
+        python = ".".join(platform.python_version_tuple()[:2])
+        backend = _select_backend(None).variant_str
+        parts.extend(
+            [
+                f"kernels/{__version__}",
+                f"python/{python}",
+                f"backend/{backend}",
+                f"platform/{_platform()}",
+                "file_type/kernel",
+            ]
+        )
+
+        if has_torch:
+            import torch
+
+            parts.append(f"torch/{torch.__version__}")
+        if has_tvm_ffi:
+            import tvm_ffi
+
+            parts.append(f"tvm-ffi/{tvm_ffi.__version__}")
+
+        # Add glibc version if available
+        glibc = glibc_version()
+        if glibc is not None:
+            parts.append(f"glibc/{glibc}")
+
+        user_agent_str = "; ".join(parts)
+
+    return HfApi(library_name="kernels", library_version=__version__, user_agent=user_agent_str)
+
+
+def _get_cache_dir() -> str | None:
+    """Returns the kernels cache directory."""
+    return os.environ.get("KERNELS_CACHE", None)
+
+
+CACHE_DIR: str | None = _get_cache_dir()
+
+
+@dataclass(frozen=True)
+class RepoInfo:
+    """
+    This dataclass stores the origin of the kernel.
+
+    The following fields are available:
+
+    - `repo_id` (`str`): the Hub repository containing the kernel.
+    - `revision` (`str`): the specific revision of the kernel.
+    """
+
+    repo_id: str
+    revision: str
+
+
+def _check_trust_remote_code(repo_id: str, trust_remote_code: bool | list[str]) -> None:
+    """Check whether a kernel repository is trusted.
+
+    When ``trust_remote_code`` is ``False`` (the default), only repositories
+    whose publisher organization has ``trustedKernelPublisher`` enabled on the
+    Hub are allowed. Repositories from untrusted publishers will raise a
+    ``ValueError``.
+
+    When ``trust_remote_code`` is ``True``, all repositories are allowed.
+
+    When ``trust_remote_code`` is a list of strings, it is treated as a list
+    of signing identities to verify against.  Signing verification is not yet
+    implemented, so passing a list currently emits a warning and falls back
+    to the default trust check (i.e. only trusted publishers are allowed).
+    """
+    if trust_remote_code is True:
+        return
+
+    if isinstance(trust_remote_code, list):
+        warnings.warn(
+            "Signing identity verification is not yet implemented. "
+            "The provided signing identities will be ignored and the "
+            "kernel will be treated as untrusted. Use trust_remote_code=True "
+            "to bypass trust checks.",
+            stacklevel=3,
+        )
+
+    if constants.HF_HUB_OFFLINE:
+        # Publisher trust cannot be verified offline. The user opted into
+        # offline mode and the kernel must already be in the local cache,
+        # so trust was established when it was originally downloaded.
+        warnings.warn(
+            f"Skipping publisher trust check for '{repo_id}' because Hugging Face Hub is in offline mode.",
+            stacklevel=3,
+        )
+        return
+
+    publisher = repo_id.split("/", 1)[0]
+
+    try:
+        info = _get_hf_api().get_organization_overview(publisher)
+    except Exception:
+        raise ValueError(
+            f"Kernel repository '{repo_id}' could not verify publisher trust status. "
+            "Set trust_remote_code=True to allow loading kernels from untrusted sources."
+        )
+
+    if getattr(info, "trustedKernelPublisher", False):
+        return
+
+    raise ValueError(
+        f"Kernel repository '{repo_id}' is not from a trusted publisher. "
+        "Set trust_remote_code=True to allow loading kernels from untrusted sources."
+    )

kernels/src/kernels/locking.py

@@ -39,7 +39,7 @@ def get_kernel_locks(repo_id: str, version_spec: int) -> KernelLock:
     """
     Get the locks for a kernel with the given version.
     """
-    from kernels.utils import _get_hf_api
+    from kernels.hf_hub import _get_hf_api
 
     api = _get_hf_api()