kernels 0.14.0.dev1__tar.gz → 0.15.1__tar.gz

{kernels-0.14.0.dev1 → kernels-0.15.1}/PKG-INFO

@@ -1,18 +1,17 @@
 Metadata-Version: 2.4
 Name: kernels
-Version: 0.14.0.dev1
+Version: 0.15.1
 Summary: Download compute kernels
 Author-email: Daniel de Kok <daniel@huggingface.co>, David Holtz <david@huggingface.co>
 License: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: huggingface-hub>=1.10.0
+Requires-Dist: kernels-data>=0.14.0.dev1
 Requires-Dist: packaging>=20.0
 Requires-Dist: pyyaml>=6
 Requires-Dist: tomli>=2.0; python_version < "3.11"
 Requires-Dist: tomlkit>=0.13.3
-Provides-Extra: abi-check
-Requires-Dist: kernel-abi-check<0.7.0,>=0.6.2; extra == "abi-check"
 Provides-Extra: benchmark
 Requires-Dist: matplotlib>=3.7.0; extra == "benchmark"
 Requires-Dist: numpy>=2.0.2; extra == "benchmark"
@@ -73,3 +72,13 @@ the Hub.
 ## 📚 Documentation
 
 Read the [documentation of kernels](https://huggingface.co/docs/kernels/).
+
+## Test coverage
+
+To reproduce the coverage number reported on PRs locally:
+
+```bash
+uv run pytest --cov=kernels --cov-report=term-missing tests
+```
+
+CI measures coverage on a single canonical matrix cell (Python 3.10 / Torch 2.12.0) and posts a sticky comment on the PR; the threshold is 80% (warn-only — the check stays green either way).

{kernels-0.14.0.dev1 → kernels-0.15.1}/README.md

@@ -48,3 +48,13 @@ the Hub.
 ## 📚 Documentation
 
 Read the [documentation of kernels](https://huggingface.co/docs/kernels/).
+
+## Test coverage
+
+To reproduce the coverage number reported on PRs locally:
+
+```bash
+uv run pytest --cov=kernels --cov-report=term-missing tests
+```
+
+CI measures coverage on a single canonical matrix cell (Python 3.10 / Torch 2.12.0) and posts a sticky comment on the PR; the threshold is 80% (warn-only — the check stays green either way).

{kernels-0.14.0.dev1 → kernels-0.15.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kernels"
-version = "0.14.0.dev1"
+version = "0.15.1"
 description = "Download compute kernels"
 authors = [
   { name = "Daniel de Kok", email = "daniel@huggingface.co" },
@@ -11,6 +11,7 @@ readme = "README.md"
 requires-python = ">= 3.10"
 dependencies = [
   "huggingface-hub>=1.10.0",
+  "kernels-data>=0.14.0.dev1",
   "packaging>=20.0",
   "pyyaml>=6",
   "tomli>=2.0; python_version<'3.11'",
@@ -25,9 +26,11 @@ build-backend = "setuptools.build_meta"
 dev = [
   "mktestdocs>=0.2.5",
   "mypy>=1.15.0",
+  "pre-commit",
   "pytest>=8",
   # Whatever version is compatible with pytest.
   "pytest-benchmark",
+  "pytest-cov>=5",
   "torch>=2.5",
   "apache-tvm-ffi>=0.1.9,<0.2.0",
   "types-pyyaml",
@@ -35,7 +38,6 @@ dev = [
 ]
 
 [project.optional-dependencies]
-abi-check = ["kernel-abi-check>=0.6.2,<0.7.0"]
 benchmark = [
   "matplotlib>=3.7.0",
   "numpy>=2.0.2",
@@ -87,3 +89,18 @@ lint.ignore = ["E501"]
 lint.select = ["E", "F", "I", "W"]
 
 [tool.ruff.format]
+
+[tool.coverage.run]
+source = ["kernels"]
+branch = false
+relative_files = true
+omit = [
+  "*/benchmarks/*",
+  "*/benchmark.py",
+  "*/cli/*",
+  "*/_windows.py",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/__init__.py

@@ -2,6 +2,8 @@ import importlib.metadata
 
 __version__ = importlib.metadata.version("kernels")
 
+from kernels_data import Metadata
+
 from kernels._windows import _add_additional_dll_paths
 from kernels.benchmark import Benchmark
 from kernels.layer import (
@@ -14,6 +16,7 @@ from kernels.layer import (
     LockedFuncRepository,
     LockedLayerRepository,
     Mode,
+    ROCMProperties,
     kernelize,
     register_kernel_mapping,
     replace_kernel_forward_from_hub,
@@ -22,7 +25,10 @@ from kernels.layer import (
     use_kernel_mapping,
 )
 from kernels.utils import (
+    LoadedKernel,
+    RepoInfo,
     get_kernel,
+    get_kernel_variants,
     get_loaded_kernels,
     get_local_kernel,
     get_locked_kernel,
@@ -30,6 +36,10 @@ from kernels.utils import (
     install_kernel,
     load_kernel,
 )
+from kernels.variants import (
+    VariantAccepted,
+    VariantRejected,
+)
 
 _add_additional_dll_paths()
 
@@ -38,14 +48,21 @@ __all__ = [
     "Benchmark",
     "CUDAProperties",
     "Device",
+    "ROCMProperties",
     "FuncRepository",
     "LayerRepository",
+    "LoadedKernel",
     "LocalFuncRepository",
     "LocalLayerRepository",
     "LockedFuncRepository",
     "LockedLayerRepository",
+    "Metadata",
     "Mode",
+    "RepoInfo",
+    "VariantAccepted",
+    "VariantRejected",
     "get_kernel",
+    "get_kernel_variants",
     "get_loaded_kernels",
     "get_local_kernel",
     "get_locked_kernel",

kernels-0.15.1/src/kernels/_versions.py

@@ -0,0 +1,110 @@
+import logging
+import os
+from pathlib import Path
+
+from huggingface_hub import constants
+from huggingface_hub.file_download import repo_folder_name
+from huggingface_hub.hf_api import GitRefInfo
+
+logger = logging.getLogger(__name__)
+
+
+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
+
+    if constants.HF_HUB_OFFLINE:
+        return _get_available_versions_from_cache(repo_id)
+
+    refs = _get_hf_api().list_repo_refs(repo_id=repo_id, repo_type="kernel")
+
+    versions = {}
+    for branch in refs.branches:
+        if not branch.name.startswith("v"):
+            continue
+        try:
+            versions[int(branch.name[1:])] = branch
+        except ValueError:
+            continue
+
+    return versions
+
+
+def _get_available_versions_from_cache(repo_id: str) -> dict[int, GitRefInfo]:
+    """Get kernel versions from the local Hugging Face cache."""
+    cache_dir = os.environ.get("KERNELS_CACHE") or constants.HF_HUB_CACHE
+
+    versions: dict[int, GitRefInfo] = {}
+    # Tolerate both layouts: the "kernel" repo type used by newer
+    # huggingface_hub, and the legacy "model" prefix that older caches use.
+    for repo_type in ("kernel", "model"):
+        refs_dir = Path(cache_dir) / repo_folder_name(repo_id=repo_id, repo_type=repo_type) / "refs"
+        if not refs_dir.is_dir():
+            continue
+        for ref_path in refs_dir.iterdir():
+            if not ref_path.is_file():
+                continue
+            ref_name = ref_path.name
+            if not ref_name.startswith("v"):
+                continue
+            try:
+                version = int(ref_name[1:])
+            except ValueError:
+                continue
+            try:
+                commit = ref_path.read_text().strip()
+            except OSError:
+                continue
+            versions[version] = GitRefInfo(name=ref_name, ref=ref_name, target_commit=commit)
+
+    return versions
+
+
+def resolve_version_spec_as_ref(repo_id: str, version_spec: int) -> GitRefInfo:
+    """
+    Get the ref for a kernel with the given version.
+    """
+    versions = _get_available_versions(repo_id)
+
+    ref = versions.get(version_spec, None)
+    if ref is None:
+        if constants.HF_HUB_OFFLINE and not versions:
+            raise ValueError(
+                f"Version {version_spec} of '{repo_id}' is not available in the local cache "
+                "and Hugging Face Hub is in offline mode. Download the kernel "
+                "while online first, or pass an explicit `revision=<commit>`."
+            )
+        raise ValueError(
+            f"Version {version_spec} not found, available versions: {', '.join(str(v) for v in sorted(versions.keys()))}"
+        )
+
+    latest_version = max(versions.keys())
+    if version_spec < latest_version:
+        logger.warning(
+            "You are using version %d of '%s', but version %d is available.",
+            version_spec,
+            repo_id,
+            latest_version,
+        )
+
+    return ref
+
+
+def select_revision_or_version(
+    repo_id: str,
+    *,
+    revision: str | None,
+    version: int | None,
+) -> str:
+    if revision is not None and version is not None:
+        raise ValueError("Only one of `revision` or `version` must be specified.")
+    elif revision is not None:
+        return revision
+    elif version is not None:
+        return resolve_version_spec_as_ref(repo_id, version).target_commit
+    else:
+        raise ValueError(
+            "A kernel version or revision must be specified. "
+            "Use `version=<major>` for a stable kernel API version or `revision=<branch/tag/commit>` "
+            "for an explicit Hub revision. See: https://huggingface.co/docs/kernels/migration"
+        )

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/cli/__init__.py

@@ -18,25 +18,8 @@ def main():
     subparsers = parser.add_subparsers(required=True)
 
     check_parser = subparsers.add_parser("check", help="Check a kernel for compliance")
-    check_parser.add_argument("repo_id", type=str, help="The kernel repo ID")
-    check_parser.add_argument(
-        "--revision",
-        type=str,
-        default="main",
-        help="The kernel revision (branch, tag, or commit SHA, defaults to 'main')",
-    )
-    check_parser.add_argument("--macos", type=str, help="macOS version", default="15.0")
-    check_parser.add_argument("--manylinux", type=str, help="Manylinux version", default="manylinux_2_28")
-    check_parser.add_argument("--python-abi", type=str, help="Python ABI version", default="3.9")
-    check_parser.set_defaults(
-        func=lambda args: check_kernel(
-            macos=args.macos,
-            manylinux=args.manylinux,
-            python_abi=args.python_abi,
-            repo_id=args.repo_id,
-            revision=args.revision,
-        )
-    )
+    check_parser.add_argument("repo_id", type=str, nargs="?")
+    check_parser.set_defaults(func=_check_moved)
 
     download_parser = subparsers.add_parser("download", help="Download locked kernels")
     download_parser.add_argument(
@@ -168,23 +151,12 @@ class _JSONEncoder(json.JSONEncoder):
         return super().default(o)
 
 
-def check_kernel(*, macos: str, manylinux: str, python_abi: str, repo_id: str, revision: str):
-    try:
-        from kernels.cli import check
-    except ImportError:
-        print(
-            "`kernels check` requires the `kernel-abi-check` package: pip install kernel-abi-check",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    check.check_kernel(
-        macos=macos,
-        manylinux=manylinux,
-        python_abi=python_abi,
-        repo_id=repo_id,
-        revision=revision,
+def _check_moved(_args):
+    print(
+        "`kernels check` has moved to `kernel-builder check-abi`",
+        file=sys.stderr,
     )
+    sys.exit(1)
 
 
 def run_benchmark(args):

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/cli/benchmark.py

@@ -464,7 +464,7 @@ def run_benchmark_class(
     from kernels import get_kernel, get_local_kernel
 
     if is_local:
-        kernel = get_local_kernel(Path(repo_id), "activation")
+        kernel = get_local_kernel(Path(repo_id))
     else:
         kernel = get_kernel(repo_id, revision=revision)
 

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/cli/versions.py

@@ -3,6 +3,7 @@ from kernels.utils import _get_hf_api
 from kernels.variants import (
     get_variants,
     resolve_variants,
+    variants_trace_str,
 )
 
 
@@ -15,16 +16,5 @@ def print_kernel_versions(repo_id: str):
 
     for version, ref in sorted(versions.items(), key=lambda x: x[0]):
         variants = get_variants(api, repo_id=repo_id, revision=ref.ref)
-        resolved = resolve_variants(variants, None)
-        best = resolved[0] if resolved else None
-        resolved_set = set(resolved)
-        print(f"Version {version}: ", end="")
-        variant_strs = [
-            (
-                f"✅ {variant.variant_str} ({'compatible, preferred' if variant == best else 'compatible'})"
-                if variant in resolved_set
-                else f"{variant.variant_str}"
-            )
-            for variant in variants
-        ]
-        print(", ".join(variant_strs))
+        _, status = resolve_variants(variants, None)
+        print(f"Version {version}:\n\n{variants_trace_str(status)}")

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/layer/__init__.py

@@ -1,4 +1,4 @@
-from .device import CUDAProperties, Device
+from .device import CUDAProperties, Device, ROCMProperties
 from .func import (
     FuncRepository,
     LocalFuncRepository,
@@ -22,6 +22,7 @@ from .mode import Mode
 __all__ = [
     "CUDAProperties",
     "Device",
+    "ROCMProperties",
     "FuncRepository",
     "LayerRepository",
     "LocalFuncRepository",

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/layer/device.py

@@ -141,12 +141,15 @@ class Device:
     """
 
     type: str
-    properties: CUDAProperties | None = None
+    properties: CUDAProperties | ROCMProperties | None = None
 
     def __post_init__(self):
         if self.properties is not None and isinstance(self.properties, CUDAProperties):
             if self.type != "cuda":
                 raise ValueError("CUDAProperties is only supported for 'cuda' devices.")
+        if self.properties is not None and isinstance(self.properties, ROCMProperties):
+            if self.type != "rocm":
+                raise ValueError("ROCMProperties is only supported for 'rocm' devices.")
 
     def __eq__(self, other):
         if not isinstance(other, Device):

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/layer/func.py

@@ -33,10 +33,11 @@ class FuncRepository:
             The Hub repository containing the layer.
         func_name (`str`):
             The name of the function within the kernel repository.
-        revision (`str`, *optional*, defaults to `"main"`):
+        revision (`str`, *optional*):
             The specific revision (branch, tag, or commit) to download. Cannot be used together with `version`.
         version (`int`, *optional*):
             The kernel version to download. Cannot be used together with `revision`.
+            Either `version` or `revision` must be specified.
 
     Example:
         ```python
@@ -46,6 +47,7 @@ class FuncRepository:
         layer_repo = FuncRepository(
             repo_id="kernels-community/activation",
             func_name="silu_and_mul",
+            revision="main",
         )
 
         # Reference a layer by version
@@ -64,12 +66,16 @@ class FuncRepository:
         func_name: str,
         revision: str | None = None,
         version: int | None = None,
+        trust_remote_code: bool | list[str] = False,
     ):
         if revision is not None and version is not None:
             raise ValueError("Either a revision or a version must be specified, not both.")
+        if revision is None and version is None:
+            raise ValueError("Either a revision or a version must be specified.")
 
         self._repo_id = repo_id
         self.func_name = func_name
+        self._trust_remote_code = trust_remote_code
 
         # We are going to resolve these lazily, since we do not want
         # to do a network request for every registered FuncRepository.
@@ -85,7 +91,9 @@ class FuncRepository:
         )
 
     def load(self) -> Type["nn.Module"]:
-        kernel = get_kernel(self._repo_id, revision=self._resolve_revision())
+        kernel = get_kernel(
+            self._repo_id, revision=self._resolve_revision(), trust_remote_code=self._trust_remote_code
+        )
         return _get_kernel_func(self, kernel)
 
     def __eq__(self, other):
@@ -95,10 +103,11 @@ class FuncRepository:
             and self._repo_id == other._repo_id
             and self._revision == other._revision
             and self._version == other._version
+            and self._trust_remote_code == other._trust_remote_code
         )
 
     def __hash__(self):
-        return hash((self.func_name, self._repo_id, self._revision, self._version))
+        return hash((self.func_name, self._repo_id, self._revision, self._version, self._trust_remote_code))
 
     def __str__(self) -> str:
         return f"`{self._repo_id}` (revision: {self._resolve_revision()}), function `{self.func_name}`"
@@ -111,8 +120,6 @@ class LocalFuncRepository:
     Args:
         repo_path (`Path`):
             The local repository containing the layer.
-        package_name (`str`):
-            Package name of the kernel.
         func_name (`str`):
             The name of the function within the kernel repository.
 
@@ -125,7 +132,6 @@ class LocalFuncRepository:
         # Reference a specific layer by revision
         layer_repo = LocalFuncRepository(
             repo_path=Path("/home/daniel/kernels/activation"),
-            package_name="activation",
             func_name="silu_and_mul",
         )
         ```
@@ -135,15 +141,13 @@ class LocalFuncRepository:
         self,
         repo_path: Path,
         *,
-        package_name: str,
         func_name: str,
     ):
         self._repo_path = repo_path
-        self._package_name = package_name
         self.func_name = func_name
 
     def load(self) -> Type["nn.Module"]:
-        kernel = get_local_kernel(self._repo_path, self._package_name)
+        kernel = get_local_kernel(self._repo_path)
         return _get_kernel_func(self, kernel)
 
     def __eq__(self, other):
@@ -151,14 +155,13 @@ class LocalFuncRepository:
             isinstance(other, LocalFuncRepository)
             and self.func_name == other.func_name
             and self._repo_path == other._repo_path
-            and self._package_name == other._package_name
         )
 
     def __hash__(self):
-        return hash((self.func_name, self._repo_path, self._package_name))
+        return hash((self.func_name, self._repo_path))
 
     def __str__(self) -> str:
-        return f"`{self._repo_path}` (package: {self._package_name}), layer `{self.func_name}`"
+        return f"`{self._repo_path}` (layer `{self.func_name}`"
 
 
 def use_kernel_func_from_hub(func_name: str):
@@ -230,6 +233,7 @@ class LockedFuncRepository:
         *,
         lockfile: Path | None = None,
         func_name: str,
+        trust_remote_code: bool | list[str] = False,
     ):
         """
         Construct a function repository.
@@ -239,10 +243,13 @@ class LockedFuncRepository:
             lockfile (`Path`, *optional*): Path to the lockfile. If not provided,
                 the lockfile will be inferred from the caller's context.
             func_name (`str`): The name of the function within the kernel repository.
+            trust_remote_code (`bool`, *optional*, defaults to `False`):
+                Whether to allow loading kernels from untrusted organisations.
         """
         self._repo_id = repo_id
         self._lockfile = lockfile
         self.func_name = func_name
+        self._trust_remote_code = trust_remote_code
         self._revision = self._resolve_revision()
 
     def _resolve_revision(self) -> str:
@@ -258,7 +265,7 @@ class LockedFuncRepository:
         return locked_sha
 
     def load(self) -> Type["nn.Module"]:
-        kernel = get_kernel(repo_id=self._repo_id, revision=self._revision)
+        kernel = get_kernel(repo_id=self._repo_id, revision=self._revision, trust_remote_code=self._trust_remote_code)
         return _get_kernel_func(self, kernel)
 
     def __eq__(self, other):
@@ -267,10 +274,11 @@ class LockedFuncRepository:
             and self.func_name == other.func_name
             and self._repo_id == other._repo_id
             and self._revision == other._revision
+            and self._trust_remote_code == other._trust_remote_code
         )
 
     def __hash__(self):
-        return hash((self.func_name, self._repo_id, self._revision))
+        return hash((self.func_name, self._repo_id, self._revision, self._trust_remote_code))
 
     def __str__(self) -> str:
         return f"`{self._repo_id}` (revision: {self._revision}), function `{self.func_name}`"

{kernels-0.14.0.dev1 → kernels-0.15.1}/src/kernels/layer/kernelize.py

@@ -139,12 +139,12 @@ def register_kernel_mapping(
             "MultiHeadAttention": {
                 "cuda": {
                     Mode.TRAINING: LayerRepository(
-                        repo_id="username/training-kernels",
+                        repo_id="kernels-community/training-kernels",
                         layer_name="TrainingAttention",
                         version=1,
                     ),
                     Mode.INFERENCE: LayerRepository(
-                        repo_id="username/inference-kernels",
+                        repo_id="kernels-community/inference-kernels",
                         layer_name="FastAttention",
                         version=1,
                     ),
@@ -206,7 +206,7 @@ def kernelize(
         import torch
         import torch.nn as nn
 
-        from kernels import kernelize, Mode, register_kernel_mapping, LayerRepository
+        from kernels import kernelize, Mode, use_kernel_mapping, LayerRepository
         from kernels import use_kernel_forward_from_hub
 
         @use_kernel_forward_from_hub("SiluAndMul")
@@ -220,10 +220,10 @@ def kernelize(
                 "cuda": LayerRepository(
                     repo_id="kernels-community/activation",
                     layer_name="SiluAndMul",
+                    version=1,
                 )
             }
         }
-        register_kernel_mapping(mapping)
 
         # Create and kernelize a model
         model = nn.Sequential(
@@ -232,7 +232,8 @@ def kernelize(
         )
 
         # Kernelize for inference
-        kernelized_model = kernelize(model, mode=Mode.TRAINING | Mode.TORCH_COMPILE)
+        with use_kernel_mapping(mapping):
+            kernelized_model = kernelize(model, mode=Mode.TRAINING | Mode.TORCH_COMPILE)
         ```
     """