kernels 0.13.0__tar.gz → 0.14.0.dev0__tar.gz

{kernels-0.13.0 → kernels-0.14.0.dev0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: kernels
-Version: 0.13.0
+Version: 0.14.0.dev0
 Summary: Download compute kernels
 Author-email: Daniel de Kok <daniel@huggingface.co>, David Holtz <david@huggingface.co>
 License: Apache-2.0
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: huggingface_hub<2.0,>=1.3.0
+Requires-Dist: huggingface-hub>=1.10.0
 Requires-Dist: packaging>=20.0
 Requires-Dist: pyyaml>=6
 Requires-Dist: tomli>=2.0; python_version < "3.11"

{kernels-0.13.0 → kernels-0.14.0.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kernels"
-version = "0.13.0"
+version = "0.14.0.dev0"
 description = "Download compute kernels"
 authors = [
   { name = "Daniel de Kok", email = "daniel@huggingface.co" },
@@ -8,9 +8,9 @@ authors = [
 ]
 license = { text = "Apache-2.0" }
 readme = "README.md"
-requires-python = ">= 3.9"
+requires-python = ">= 3.10"
 dependencies = [
-  "huggingface_hub>=1.3.0,<2.0",
+  "huggingface-hub>=1.10.0",
   "packaging>=20.0",
   "pyyaml>=6",
   "tomli>=2.0; python_version<'3.11'",
@@ -56,11 +56,10 @@ kernels = "kernels.cli:main"
 [tool.setuptools.package-data]
 kernels = ["python_depends.json"]
 
-[tool.isort]
-profile = "black"
-line_length = 119
-
 [tool.ruff]
+# If the version is changed, apply the change in the Nix overlay
+# as well.
+required-version = "==0.15.10"
 exclude = [
   ".eggs",
   ".git",
@@ -85,4 +84,6 @@ line-length = 119
 # Ignored rules:
 # "E501" -> line length violation
 lint.ignore = ["E501"]
-lint.select = ["E", "F", "W"]
+lint.select = ["E", "F", "I", "W"]
+
+[tool.ruff.format]

{kernels-0.13.0 → kernels-0.14.0.dev0}/src/kernels/__init__.py

@@ -23,6 +23,7 @@ from kernels.layer import (
 )
 from kernels.utils import (
     get_kernel,
+    get_loaded_kernels,
     get_local_kernel,
     get_locked_kernel,
     has_kernel,
@@ -45,6 +46,7 @@ __all__ = [
     "LockedLayerRepository",
     "Mode",
     "get_kernel",
+    "get_loaded_kernels",
     "get_local_kernel",
     "get_locked_kernel",
     "has_kernel",

kernels-0.14.0.dev0/src/kernels/_versions.py

@@ -0,0 +1,72 @@
+import logging
+import warnings
+
+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
+
+    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 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:
+        raise ValueError(
+            f"Version {version_spec} not found, available versions: {', '.join(sorted(str(v) for v in 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.")
+
+    if revision is not None:
+        return revision
+    elif version is not None:
+        return resolve_version_spec_as_ref(repo_id, version).target_commit
+
+    warnings.warn(
+        "Future versions of `kernels` (>=0.15) will require specifying a kernel version or revision. "
+        "See: https://huggingface.co/docs/kernels/migration",
+        FutureWarning,
+        stacklevel=2,
+    )
+
+    return "main"

{kernels-0.13.0 → kernels-0.14.0.dev0}/src/kernels/backends.py

@@ -241,9 +241,7 @@ def _select_backend(backend: str | None) -> Backend:
     if backend in supported:
         return supported[backend]
 
-    raise ValueError(
-        f"Invalid backend '{backend}', system supported backends: {', '.join(sorted(supported.keys()))}"
-    )
+    raise ValueError(f"Invalid backend '{backend}', system supported backends: {', '.join(sorted(supported.keys()))}")
 
 
 def _supported_backends() -> dict[str, Backend]:
@@ -267,9 +265,7 @@ def _get_cuda() -> Optional[CUDA]:
     runtime_version = ctypes.c_int(0)
     result = libcudart.cudaRuntimeGetVersion(ctypes.byref(runtime_version))
     if result != 0:
-        warnings.warn(
-            "System has CUDA runtime library, but cannot get runtime version."
-        )
+        warnings.warn("System has CUDA runtime library, but cannot get runtime version.")
         return None
 
     # cudaRuntimeGetVersion encodes the version as (major * 1000 + minor * 10).

{kernels-0.13.0 → kernels-0.14.0.dev0}/src/kernels/benchmarks/attention.py

@@ -14,9 +14,7 @@ def _reference_attention(query, key, value, causal=False):
     """Reference implementation using PyTorch SDPA."""
     query, key, value = (x.transpose(1, 2).contiguous() for x in (query, key, value))
     with torch.nn.attention.sdpa_kernel(torch.nn.attention.SDPBackend.MATH):
-        out = torch.nn.functional.scaled_dot_product_attention(
-            query, key, value, is_causal=causal
-        )
+        out = torch.nn.functional.scaled_dot_product_attention(query, key, value, is_causal=causal)
     return out.transpose(1, 2).contiguous()
 
 
@@ -24,9 +22,7 @@ def _varlen_reference_attention(q, k, v, cu_seqlens_q, cu_seqlens_k, causal=Fals
     """Reference implementation for variable length attention."""
     batch_size = cu_seqlens_q.shape[0] - 1
     total_tokens_q = q.shape[0]
-    out = torch.zeros(
-        (total_tokens_q, q.shape[1], q.shape[2]), device=q.device, dtype=q.dtype
-    )
+    out = torch.zeros((total_tokens_q, q.shape[1], q.shape[2]), device=q.device, dtype=q.dtype)
 
     for b in range(batch_size):
         start_q, end_q = cu_seqlens_q[b], cu_seqlens_q[b + 1]
@@ -54,9 +50,7 @@ class FlashAttentionBenchmark(Benchmark):
         self.out = torch.empty(B, S, H, D, device="cuda", dtype=torch.float16)
 
     def benchmark_small(self):
-        self.out = _extract_output(
-            self.kernel.flash_attn_func(self.q, self.k, self.v, causal=False)
-        )
+        self.out = _extract_output(self.kernel.flash_attn_func(self.q, self.k, self.v, causal=False))
 
     def verify_small(self) -> torch.Tensor:
         return _reference_attention(self.q, self.k, self.v, causal=False)
@@ -70,9 +64,7 @@ class FlashAttentionBenchmark(Benchmark):
         self.out = torch.empty(B, S, H, D, device="cuda", dtype=torch.float16)
 
     def benchmark_medium(self):
-        self.out = _extract_output(
-            self.kernel.flash_attn_func(self.q, self.k, self.v, causal=False)
-        )
+        self.out = _extract_output(self.kernel.flash_attn_func(self.q, self.k, self.v, causal=False))
 
     def verify_medium(self) -> torch.Tensor:
         return _reference_attention(self.q, self.k, self.v, causal=False)
@@ -86,9 +78,7 @@ class FlashAttentionBenchmark(Benchmark):
         self.out = torch.empty(B, S, H, D, device="cuda", dtype=torch.float16)
 
     def benchmark_large(self):
-        self.out = _extract_output(
-            self.kernel.flash_attn_func(self.q, self.k, self.v, causal=False)
-        )
+        self.out = _extract_output(self.kernel.flash_attn_func(self.q, self.k, self.v, causal=False))
 
     def verify_large(self) -> torch.Tensor:
         return _reference_attention(self.q, self.k, self.v, causal=False)
@@ -106,9 +96,7 @@ class FlashAttentionCausalBenchmark(Benchmark):
         self.out = torch.empty(B, S, H, D, device="cuda", dtype=torch.float16)
 
     def benchmark_small(self):
-        self.out = _extract_output(
-            self.kernel.flash_attn_func(self.q, self.k, self.v, causal=True)
-        )
+        self.out = _extract_output(self.kernel.flash_attn_func(self.q, self.k, self.v, causal=True))
 
     def verify_small(self) -> torch.Tensor:
         return _reference_attention(self.q, self.k, self.v, causal=True)
@@ -122,9 +110,7 @@ class FlashAttentionCausalBenchmark(Benchmark):
         self.out = torch.empty(B, S, H, D, device="cuda", dtype=torch.float16)
 
     def benchmark_medium(self):
-        self.out = _extract_output(
-            self.kernel.flash_attn_func(self.q, self.k, self.v, causal=True)
-        )
+        self.out = _extract_output(self.kernel.flash_attn_func(self.q, self.k, self.v, causal=True))
 
     def verify_medium(self) -> torch.Tensor:
         return _reference_attention(self.q, self.k, self.v, causal=True)
@@ -138,9 +124,7 @@ class FlashAttentionCausalBenchmark(Benchmark):
         self.out = torch.empty(B, S, H, D, device="cuda", dtype=torch.float16)
 
     def benchmark_large(self):
-        self.out = _extract_output(
-            self.kernel.flash_attn_func(self.q, self.k, self.v, causal=True)
-        )
+        self.out = _extract_output(self.kernel.flash_attn_func(self.q, self.k, self.v, causal=True))
 
     def verify_large(self) -> torch.Tensor:
         return _reference_attention(self.q, self.k, self.v, causal=True)
@@ -180,9 +164,7 @@ class FlashAttentionVarlenBenchmark(Benchmark):
         )
 
     def verify_small(self) -> torch.Tensor:
-        return _varlen_reference_attention(
-            self.q, self.k, self.v, self.cu_seqlens, self.cu_seqlens, causal=False
-        )
+        return _varlen_reference_attention(self.q, self.k, self.v, self.cu_seqlens, self.cu_seqlens, causal=False)
 
     # Workload: medium (5 sequences, max_seqlen=256)
     def setup_medium(self):
@@ -214,9 +196,7 @@ class FlashAttentionVarlenBenchmark(Benchmark):
         )
 
     def verify_medium(self) -> torch.Tensor:
-        return _varlen_reference_attention(
-            self.q, self.k, self.v, self.cu_seqlens, self.cu_seqlens, causal=False
-        )
+        return _varlen_reference_attention(self.q, self.k, self.v, self.cu_seqlens, self.cu_seqlens, causal=False)
 
     # Workload: large (8 sequences, max_seqlen=512)
     def setup_large(self):
@@ -248,6 +228,4 @@ class FlashAttentionVarlenBenchmark(Benchmark):
         )
 
     def verify_large(self) -> torch.Tensor:
-        return _varlen_reference_attention(
-            self.q, self.k, self.v, self.cu_seqlens, self.cu_seqlens, causal=False
-        )
+        return _varlen_reference_attention(self.q, self.k, self.v, self.cu_seqlens, self.cu_seqlens, causal=False)

{kernels-0.13.0 → kernels-0.14.0.dev0}/src/kernels/benchmarks/layer_norm.py

@@ -129,9 +129,7 @@ class LayerNormBenchmark(Benchmark):
         )[0].view(self.B, self.S, self.D)
 
     def verify_small(self) -> torch.Tensor:
-        return torch.nn.functional.layer_norm(
-            self.x, [self.D], self.weight, eps=self.eps
-        )
+        return torch.nn.functional.layer_norm(self.x, [self.D], self.weight, eps=self.eps)
 
     # Workload: medium (B=4, S=512, D=2048)
     def setup_medium(self):
@@ -160,9 +158,7 @@ class LayerNormBenchmark(Benchmark):
         )[0].view(self.B, self.S, self.D)
 
     def verify_medium(self) -> torch.Tensor:
-        return torch.nn.functional.layer_norm(
-            self.x, [self.D], self.weight, eps=self.eps
-        )
+        return torch.nn.functional.layer_norm(self.x, [self.D], self.weight, eps=self.eps)
 
     # Workload: large (B=8, S=1024, D=4096)
     def setup_large(self):
@@ -191,6 +187,4 @@ class LayerNormBenchmark(Benchmark):
         )[0].view(self.B, self.S, self.D)
 
     def verify_large(self) -> torch.Tensor:
-        return torch.nn.functional.layer_norm(
-            self.x, [self.D], self.weight, eps=self.eps
-        )
+        return torch.nn.functional.layer_norm(self.x, [self.D], self.weight, eps=self.eps)

{kernels-0.13.0 → kernels-0.14.0.dev0}/src/kernels/cli/__init__.py

@@ -4,8 +4,6 @@ import json
 import sys
 from pathlib import Path
 
-from kernels.cli.skills import add_skill
-from kernels.cli.upload import upload_kernels_dir
 from kernels.cli.versions import print_kernel_versions
 from kernels.compat import tomllib
 from kernels.lockfile import KernelLock, get_kernel_locks
@@ -16,9 +14,7 @@ from kernels.utils import (
 
 
 def main():
-    parser = argparse.ArgumentParser(
-        prog="kernel", description="Manage compute kernels"
-    )
+    parser = argparse.ArgumentParser(prog="kernel", description="Manage compute kernels")
     subparsers = parser.add_subparsers(required=True)
 
     check_parser = subparsers.add_parser("check", help="Check a kernel for compliance")
@@ -30,12 +26,8 @@ def 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.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,
@@ -63,80 +55,6 @@ def main():
     versions_parser.add_argument("repo_id", type=str, help="The kernel repo ID")
     versions_parser.set_defaults(func=kernel_versions)
 
-    upload_parser = subparsers.add_parser(
-        "upload",
-        help="(Deprecated) Upload kernels to the Hub. Use `kernel-builder upload` instead.",
-    )
-    upload_parser.add_argument(
-        "kernel_dir",
-        type=Path,
-        help="Directory of the kernel build",
-    )
-    upload_parser.add_argument(
-        "--repo-id",
-        type=str,
-        required=True,
-        help="Repository ID to use to upload to the Hugging Face Hub",
-    )
-    upload_parser.add_argument(
-        "--branch",
-        type=str,
-        default=None,
-        help="If set, the upload will be made to a particular branch of the provided `repo-id`.",
-    )
-    upload_parser.add_argument(
-        "--private",
-        action="store_true",
-        help="If the repository should be private.",
-    )
-    upload_parser.set_defaults(func=upload_kernels)
-
-    skills_parser = subparsers.add_parser(
-        "skills",
-        help="Install kernels specific skills for agents like Claude, Codex, and OpenCode",
-    )
-    skills_subparsers = skills_parser.add_subparsers(required=True)
-    skills_add_parser = skills_subparsers.add_parser(
-        "add",
-        help="Install the cuda-kernels skill for an AI assistant",
-    )
-    skills_add_parser.add_argument(
-        "--claude",
-        action="store_true",
-        help="Install for Claude.",
-    )
-    skills_add_parser.add_argument(
-        "--codex",
-        action="store_true",
-        help="Install for Codex.",
-    )
-    skills_add_parser.add_argument(
-        "--opencode",
-        action="store_true",
-        help="Install for OpenCode.",
-    )
-    skills_add_parser.add_argument(
-        "--global",
-        "-g",
-        dest="global_",
-        action="store_true",
-        help=(
-            "Install globally (user-level) instead of in the current project directory."
-        ),
-    )
-    skills_add_parser.add_argument(
-        "--dest",
-        type=Path,
-        default=None,
-        help="Install into a custom destination (path to skills directory).",
-    )
-    skills_add_parser.add_argument(
-        "--force",
-        action="store_true",
-        help="Overwrite existing skills in the destination.",
-    )
-    skills_add_parser.set_defaults(func=add_skill)
-
     lock_parser = subparsers.add_parser("lock", help="Lock kernel revisions")
     lock_parser.add_argument(
         "project_dir",
@@ -154,12 +72,8 @@ def main():
         type=str,
         help="Kernel repo ID (e.g., kernels-community/activation)",
     )
-    benchmark_parser.add_argument(
-        "--branch", type=str, help="Kernel branch to benchmark"
-    )
-    benchmark_parser.add_argument(
-        "--version", type=int, help="Kernel version to benchmark"
-    )
+    benchmark_parser.add_argument("--branch", type=str, help="Kernel branch to benchmark")
+    benchmark_parser.add_argument("--version", type=int, help="Kernel version to benchmark")
     benchmark_parser.add_argument(
         "--output",
         type=str,
@@ -211,14 +125,14 @@ def download_kernels(args):
         if args.all_variants:
             install_kernel_all_variants(
                 kernel_lock.repo_id,
-                kernel_lock.sha,
+                revision=kernel_lock.sha,
                 variant_locks=kernel_lock.variants,
             )
         else:
             try:
                 install_kernel(
                     kernel_lock.repo_id,
-                    kernel_lock.sha,
+                    revision=kernel_lock.sha,
                     variant_locks=kernel_lock.variants,
                 )
             except FileNotFoundError as e:
@@ -247,29 +161,6 @@ def lock_kernels(args):
         json.dump(all_locks, f, cls=_JSONEncoder, indent=2)
 
 
-def upload_kernels(args):
-    import warnings
-
-    warnings.warn(
-        "`kernels upload` is deprecated and will be removed in version 0.14. "
-        "Please use `kernel-builder upload` instead.",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-    # Also print to stderr for visibility in CLI usage
-    print(
-        "Warning: `kernels upload` is deprecated and will be removed in version 0.14.\n"
-        "Please use `kernel-builder upload` instead.\n",
-        file=sys.stderr,
-    )
-    upload_kernels_dir(
-        Path(args.kernel_dir).resolve(),
-        repo_id=args.repo_id,
-        branch=args.branch,
-        private=args.private,
-    )
-
-
 class _JSONEncoder(json.JSONEncoder):
     def default(self, o):
         if dataclasses.is_dataclass(o):
@@ -277,9 +168,7 @@ class _JSONEncoder(json.JSONEncoder):
         return super().default(o)
 
 
-def check_kernel(
-    *, macos: str, manylinux: str, python_abi: str, repo_id: str, revision: str
-):
+def check_kernel(*, macos: str, manylinux: str, python_abi: str, repo_id: str, revision: str):
     try:
         from kernels.cli import check
     except ImportError:

{kernels-0.13.0 → kernels-0.14.0.dev0}/src/kernels/cli/benchmark.py

@@ -91,9 +91,7 @@ class TimingResults:
 
     def validate_timing_range(self):
         if self.min_ms > self.max_ms:
-            raise ValueError(
-                f"min_ms ({self.min_ms}) must be <= max_ms ({self.max_ms})"
-            )
+            raise ValueError(f"min_ms ({self.min_ms}) must be <= max_ms ({self.max_ms})")
 
 
 @strict
@@ -302,9 +300,7 @@ def _get_macos_gpu() -> tuple[str | None, int | None]:
         from ctypes import POINTER, byref, c_char_p, c_int, c_int64, c_uint32, c_void_p
 
         iokit = ctypes.CDLL("/System/Library/Frameworks/IOKit.framework/IOKit")
-        cf = ctypes.CDLL(
-            "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"
-        )
+        cf = ctypes.CDLL("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation")
 
         iokit.IOServiceMatching.restype = c_void_p
         iokit.IOServiceMatching.argtypes = [c_char_p]
@@ -365,9 +361,7 @@ def _get_macos_gpu() -> tuple[str | None, int | None]:
             cf.CFRelease(key)
 
         # Get GPU core count
-        key = cf.CFStringCreateWithCString(
-            None, b"gpu-core-count", kCFStringEncodingUTF8
-        )
+        key = cf.CFStringCreateWithCString(None, b"gpu-core-count", kCFStringEncodingUTF8)
         if key:
             prop = iokit.IORegistryEntryCreateCFProperty(service, key, None, 0)
             if prop:
@@ -408,9 +402,7 @@ def collect_machine_info() -> MachineInfo:
             if hasattr(torch.version, "hip") and torch.version.hip:
                 backend_type = f"ROCm {torch.version.hip}"
             else:
-                backend_type = (
-                    f"CUDA {torch.version.cuda}" if torch.version.cuda else "CUDA"
-                )
+                backend_type = f"CUDA {torch.version.cuda}" if torch.version.cuda else "CUDA"
         elif backend_name == "xpu":
             gpu = torch.xpu.get_device_name(0)
             backend_type = "XPU"
@@ -462,9 +454,7 @@ def run_benchmark_class(
 
     # Find all benchmark_* methods
     benchmark_methods = [
-        name
-        for name in dir(benchmark_cls)
-        if name.startswith("benchmark_") and callable(getattr(benchmark_cls, name))
+        name for name in dir(benchmark_cls) if name.startswith("benchmark_") and callable(getattr(benchmark_cls, name))
     ]
 
     if not benchmark_methods:
@@ -646,9 +636,7 @@ def run_benchmark_script(
         raise RuntimeError(f"No Benchmark subclasses found in {script_path}")
 
     machine_info = collect_machine_info()
-    gpu_cores_str = (
-        f" ({machine_info.gpu_cores} cores)" if machine_info.gpu_cores else ""
-    )
+    gpu_cores_str = f" ({machine_info.gpu_cores} cores)" if machine_info.gpu_cores else ""
     print(file=sys.stderr)
     print(f"  GPU      {machine_info.gpu}{gpu_cores_str}", file=sys.stderr)
     print(f"  CPU      {machine_info.cpu}", file=sys.stderr)
@@ -721,8 +709,7 @@ def run_benchmark(
     if is_local:
         if repo_id.count("/") == 1 and not repo_id.startswith(("./", "../")):
             warnings.warn(
-                f"'{repo_id}' exists locally but looks like a repo_id. "
-                f"Use './{repo_id}' to be explicit.",
+                f"'{repo_id}' exists locally but looks like a repo_id. Use './{repo_id}' to be explicit.",
                 stacklevel=2,
             )
         branch = "local"
@@ -753,9 +740,7 @@ def run_benchmark(
     if is_local:
         repo_path = repo_id_path.resolve()
     else:
-        repo_path = Path(
-            str(_get_hf_api().snapshot_download(repo_id=repo_id, revision=revision))
-        )
+        repo_path = Path(str(_get_hf_api().snapshot_download(repo_id=repo_id, revision=revision)))
 
     scripts = discover_benchmark_scripts(repo_id, repo_path)