kernels 0.16.0__tar.gz → 0.16.2__tar.gz

{kernels-0.16.0 → kernels-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kernels
-Version: 0.16.0
+Version: 0.16.2
 Summary: Download compute kernels
 Author-email: Daniel de Kok <daniel@huggingface.co>, David Holtz <david@huggingface.co>
 License: Apache-2.0

{kernels-0.16.0 → kernels-0.16.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kernels"
-version = "0.16.0"
+version = "0.16.2"
 description = "Download compute kernels"
 authors = [
   { name = "Daniel de Kok", email = "daniel@huggingface.co" },

kernels-0.16.2/src/kernels/archs.py

@@ -0,0 +1,115 @@
+from kernels_data import Backend, Metadata
+
+from kernels.compat import has_torch
+
+
+def _parse_cuda_arch(arch: str) -> tuple[int, int, str, bool] | None:
+    """Parse a CUDA arch into its capability, suffix, and PTX flag.
+
+    CUDA archs are compute capabilities like `9.0`, optionally with an
+    architecture-specific (`9.0a`) or family-specific (`10.0f`) suffix
+    and/or a `+PTX` flag (`9.0+PTX`). Returns `None` when the arch string
+    is not in this format.
+    """
+    ptx = False
+    if arch.endswith("+PTX"):
+        ptx = True
+        arch = arch[: -len("+PTX")]
+
+    suffix = ""
+    if arch.endswith(("a", "f")):
+        suffix = arch[-1]
+        arch = arch[:-1]
+
+    arch_major, sep, arch_minor = arch.partition(".")
+    if not sep or not arch_major.isdigit() or not arch_minor.isdigit():
+        return None
+
+    return int(arch_major), int(arch_minor), suffix, ptx
+
+
+def _cuda_arch_supports(arch: str, capability: tuple[int, int]) -> bool | None:
+    """Check whether a single declared CUDA arch supports a compute capability.
+
+    Returns `None` when the arch string is not in a known format.
+    """
+    parsed = _parse_cuda_arch(arch)
+    if parsed is None:
+        return None
+
+    arch_major, arch_minor, suffix, ptx = parsed
+    major, minor = capability
+
+    if suffix == "a":
+        # Architecture-specific builds only run on that exact capability.
+        return (major, minor) == (arch_major, arch_minor)
+
+    if suffix == "f":
+        # Family-specific builds run on capabilities of the same generation
+        # with the same or a newer minor version.
+        return major == arch_major and minor >= arch_minor
+
+    if ptx:
+        # PTX is JIT-compiled for the current device, so the build also runs
+        # on any newer capability.
+        return (major, minor) >= (arch_major, arch_minor)
+
+    # Base builds run on capabilities of the same generation with the same
+    # or a newer minor version.
+    return major == arch_major and minor >= arch_minor
+
+
+def _supports_cuda_capability(archs: list[str], capability: tuple[int, int]) -> bool:
+    supports = [_cuda_arch_supports(arch, capability) for arch in archs]
+    if all(support is None for support in supports):
+        # None of the arch strings are in a known format (e.g. produced by a
+        # newer kernel-builder), so compatibility cannot be determined.
+        return True
+    return any(supports)
+
+
+def _check_arch_incompatibility(metadata: Metadata, variant: str) -> None:
+    """Check a kernel build against the architecture of the current device.
+
+    Raises `RuntimeError` when the build does not support the device.
+    """
+    archs = metadata.backend.archs
+    if not archs or not has_torch:
+        return
+
+    import torch
+
+    reason = None
+    backend_type = metadata.backend.backend_type
+    if backend_type == Backend.CUDA:
+        if torch.version.cuda is None or not torch.cuda.is_available():
+            return
+        major, minor = torch.cuda.get_device_capability()
+        if not _supports_cuda_capability(archs, (major, minor)):
+            reason = (
+                f"CUDA capability {major}.{minor} of the current device is not "
+                f"supported by the architectures of the build: {', '.join(archs)}"
+            )
+    elif backend_type == Backend.ROCm:
+        if torch.version.hip is None or not torch.cuda.is_available():
+            return
+        gcn_arch = torch.cuda.get_device_properties(torch.cuda.current_device()).gcnArchName
+        # Strip feature flags, e.g. `gfx90a:sramecc+:xnack-` -> `gfx90a`.
+        gcn_arch = gcn_arch.split(":")[0]
+        if gcn_arch not in archs:
+            reason = (
+                f"ROCm arch {gcn_arch} of the current device is not supported "
+                f"by the architectures of the build: {', '.join(archs)}"
+            )
+
+    if reason is None:
+        return
+
+    raise RuntimeError(
+        f"Kernel '{metadata.name}' variant '{variant}' does not support the "
+        f"current device: {reason}. The declared architectures can be "
+        "incomplete (e.g. when a kernel has a Triton fallback), pass "
+        "`check_arch=False` to skip this check. Warning: the kernel may "
+        "fail or crash the process at run time when it does not support "
+        "the device."
+    )

kernels-0.16.2/src/kernels/minver.py

@@ -0,0 +1,69 @@
+import json
+import warnings
+from pathlib import Path
+
+from kernels_data import Metadata, Version
+from packaging.version import InvalidVersion, parse
+
+
+def _read_kernels_minver(variant_path: Path) -> Version | None:
+    """The minimum `kernels` version required by a build variant."""
+
+    # Note, for kernels >= 0.17, we read the version from the metadata,
+    # but to minimize the impact in the backport, we are reading from
+    # metadata.json here directly.
+
+    try:
+        with open(variant_path / "metadata.json", "rb") as f:
+            minver = json.load(f).get("kernels-minver")
+    except (OSError, ValueError):
+        return None
+
+    if not isinstance(minver, str):
+        return None
+
+    try:
+        return Version.from_str(minver)
+    except ValueError:
+        return None
+
+
+def _installed_version() -> Version | None:
+    """The installed `kernels` version as a numeric version."""
+    # Avoid an import cycle.
+    from kernels import __version__
+
+    try:
+        release = parse(__version__).release
+    except InvalidVersion:
+        return None
+
+    # packaging < 22 returns a LegacyVersion with `release = None` for
+    # non-PEP 440 versions instead of raising `InvalidVersion`.
+    if release is None:
+        return None
+
+    return Version.from_str(".".join(str(part) for part in release))
+
+
+def _warn_if_below_minver(metadata: Metadata, variant_path: Path) -> None:
+    """Warn when the installed `kernels` library is older than the minimum
+    version required by a kernel.
+    """
+    minver = _read_kernels_minver(variant_path)
+    if minver is None:
+        return
+
+    installed = _installed_version()
+    if installed is not None and installed < minver:
+        # Report the verbatim installed version, not the normalized one used
+        # for comparison, so the message matches what `pip show` reports.
+        from kernels import __version__
+
+        warnings.warn(
+            f"Kernel '{metadata.name}' variant '{variant_path.name}' requires "
+            f"kernels>={minver}, but version {__version__} is installed. "
+            "The kernel may not load or work correctly; upgrade with: "
+            "pip install --upgrade kernels",
+            stacklevel=3,
+        )

{kernels-0.16.0 → kernels-0.16.2}/src/kernels/utils.py

@@ -14,15 +14,17 @@ from pathlib import Path
 from types import ModuleType
 
 from huggingface_hub import HfApi, constants
-from huggingface_hub.errors import LocalEntryNotFoundError
+from huggingface_hub.errors import EntryNotFoundError, LocalEntryNotFoundError
 from kernels_data import Metadata
 
 from kernels._system import glibc_version
 from kernels._versions import select_revision_or_version
+from kernels.archs import _check_arch_incompatibility
 from kernels.backends import _backend, _select_backend
 from kernels.compat import has_torch, has_tvm_ffi
 from kernels.deps import validate_dependencies
 from kernels.lockfile import KernelLock, VariantLock
+from kernels.minver import _warn_if_below_minver
 from kernels.status import resolve_status
 from kernels.variants import (
     Decision,
@@ -209,6 +211,7 @@ def _import_from_path(variant_path: Path, repo_info: RepoInfo | None = None) ->
         return loaded_kernel.module
 
     metadata = Metadata.read_from_file(variant_path / "metadata.json")
+    _warn_if_below_minver(metadata, variant_path)
     module_name = metadata.name.python_name
 
     file_path = variant_path / "__init__.py"
@@ -455,6 +458,7 @@ def get_kernel(
     backend: str | None = None,
     user_agent: str | dict | None = None,
     trust_remote_code: bool | list[str] = False,
+    check_arch: bool = True,
 ) -> ModuleType:
     """
     Load a kernel from the kernel hub.
@@ -481,6 +485,12 @@ def get_kernel(
             repositories are allowed. A list of strings will be used to verify signing
             identities in a future release; for now it emits a warning and falls
             back to the default trust check.
+        check_arch (`bool`, *optional*, defaults to `True`):
+            Whether to check that the kernel build supports the architecture
+            (e.g. CUDA compute capability) of the current device. Kernels can
+            support more architectures than they declare (e.g. through a
+            Triton fallback), `check_arch=False` skips the check for such
+            kernels.
 
     Returns:
         `ModuleType`: The imported kernel module.
@@ -514,6 +524,9 @@ def get_kernel(
         user_agent=user_agent,
         validate_dependencies=True,
     )
+    if check_arch:
+        metadata = Metadata.read_from_file(variant_path / "metadata.json")
+        _check_arch_incompatibility(metadata, variant_path.name)
     return _import_from_path(variant_path, repo_info=repo_info)
 
 
@@ -558,6 +571,7 @@ def has_kernel(
     revision: str | None = None,
     version: int | None = None,
     backend: str | None = None,
+    check_arch: bool = True,
 ) -> bool:
     """
     Check whether a kernel build exists for the current environment (Torch version and compute framework).
@@ -573,6 +587,12 @@ def has_kernel(
         backend (`str`, *optional*):
             The backend to load the kernel for. Can only be `cpu` or the backend that Torch is compiled for.
             The backend will be detected automatically if not provided.
+        check_arch (`bool`, *optional*, defaults to `True`):
+            Whether to check that the kernel build supports the architecture
+            (e.g. CUDA compute capability) of the current device. Kernels can
+            support more architectures than they declare (e.g. through a
+            Triton fallback), `check_arch=False` skips the check for such
+            kernels.
 
     Returns:
         `bool`: `True` if a kernel is available for the current environment.
@@ -586,12 +606,31 @@ def has_kernel(
     if variant is None:
         return False
 
-    return api.file_exists(
-        repo_id,
-        repo_type="kernel",
-        revision=revision,
-        filename=f"build/{variant.variant_str}/metadata.json",
-    )
+    if not check_arch:
+        return api.file_exists(
+            repo_id,
+            repo_type="kernel",
+            revision=revision,
+            filename=f"build/{variant.variant_str}/metadata.json",
+        )
+
+    try:
+        metadata_path = api.hf_hub_download(
+            repo_id,
+            repo_type="kernel",
+            revision=revision,
+            filename=f"build/{variant.variant_str}/metadata.json",
+            cache_dir=CACHE_DIR,
+        )
+    except EntryNotFoundError:
+        return False
+
+    try:
+        _check_arch_incompatibility(Metadata.read_from_file(metadata_path), variant.variant_str)
+    except RuntimeError:
+        return False
+
+    return True
 
 
 def get_kernel_variants(

{kernels-0.16.0 → kernels-0.16.2}/src/kernels.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kernels
-Version: 0.16.0
+Version: 0.16.2
 Summary: Download compute kernels
 Author-email: Daniel de Kok <daniel@huggingface.co>, David Holtz <david@huggingface.co>
 License: Apache-2.0

{kernels-0.16.0 → kernels-0.16.2}/src/kernels.egg-info/SOURCES.txt

@@ -4,11 +4,13 @@ src/kernels/__init__.py
 src/kernels/_system.py
 src/kernels/_versions.py
 src/kernels/_windows.py
+src/kernels/archs.py
 src/kernels/backends.py
 src/kernels/benchmark.py
 src/kernels/compat.py
 src/kernels/deps.py
 src/kernels/lockfile.py
+src/kernels/minver.py
 src/kernels/python_depends.json
 src/kernels/status.py
 src/kernels/utils.py
@@ -38,6 +40,7 @@ src/kernels/layer/kernelize.py
 src/kernels/layer/layer.py
 src/kernels/layer/mode.py
 src/kernels/layer/repos.py
+tests/test_archs.py
 tests/test_basic.py
 tests/test_benchmarks.py
 tests/test_deps.py
@@ -47,6 +50,7 @@ tests/test_interval_tree.py
 tests/test_kernel_locking.py
 tests/test_layer.py
 tests/test_loaded_kernels.py
+tests/test_minver.py
 tests/test_status.py
 tests/test_tvm_ffi.py
 tests/test_user_agent.py

kernels-0.16.2/tests/test_archs.py

@@ -0,0 +1,158 @@
+import json
+
+import pytest
+import torch
+from kernels_data import Metadata
+
+from kernels import get_kernel, has_kernel, install_kernel
+from kernels.archs import _check_arch_incompatibility, _supports_cuda_capability
+
+
+def make_metadata(backend_type: str, archs: list[str] | None) -> Metadata:
+    return Metadata.from_bytes(
+        json.dumps(
+            {
+                "name": "test-kernel",
+                "id": "test_id",
+                "version": 1,
+                "license": "mit",
+                "python-depends": [],
+                "backend": {"type": backend_type, "archs": archs},
+            }
+        ).encode("utf-8")
+    )
+
+
+@pytest.mark.parametrize(
+    "archs,capability,supported",
+    [
+        # Base archs run on the same generation with the same or a newer
+        # minor capability.
+        (["8.0"], (8, 0), True),
+        (["8.0"], (8, 6), True),
+        (["8.6"], (8, 0), False),
+        (["8.0"], (7, 5), False),
+        (["8.0"], (9, 0), False),
+        (["8.0", "9.0"], (9, 0), True),
+        # Architecture-specific archs only run on that exact capability.
+        (["9.0a"], (9, 0), True),
+        (["9.0a"], (9, 1), False),
+        (["8.0", "9.0a"], (10, 0), False),
+        # Family-specific archs run on the same generation with the same or
+        # a newer minor capability.
+        (["10.0f"], (10, 0), True),
+        (["10.0f"], (10, 3), True),
+        (["10.0f"], (12, 0), False),
+        # PTX is JIT-compiled for the current device, so builds with `+PTX`
+        # also run on any newer capability.
+        (["9.0+PTX"], (9, 0), True),
+        (["9.0+PTX"], (9, 1), True),
+        (["9.0+PTX"], (10, 0), True),
+        (["9.0+PTX"], (12, 1), True),
+        (["9.0+PTX"], (8, 6), False),
+        # ...but the `a` and `f` suffixes keep their own semantics.
+        (["9.0a+PTX"], (9, 0), True),
+        (["9.0a+PTX"], (10, 0), False),
+        (["10.0f+PTX"], (10, 3), True),
+        (["10.0f+PTX"], (12, 0), False),
+        # Arch strings in an unknown format do not count as a match...
+        (["garbage", "8.0"], (9, 0), False),
+        # ...but when no arch string can be parsed, compatibility cannot be
+        # determined and the build is not rejected.
+        (["garbage"], (9, 0), True),
+    ],
+)
+def test_supports_cuda_capability(archs, capability, supported):
+    assert _supports_cuda_capability(archs, capability) == supported
+
+
+@pytest.fixture
+def fake_cuda_device(monkeypatch):
+    monkeypatch.setattr(torch.version, "cuda", "12.8", raising=False)
+    monkeypatch.setattr(torch.version, "hip", None, raising=False)
+    monkeypatch.setattr(torch.cuda, "is_available", lambda: True)
+    monkeypatch.setattr(torch.cuda, "get_device_capability", lambda device=None: (10, 0))
+
+
+@pytest.fixture
+def fake_rocm_device(monkeypatch):
+    class FakeProperties:
+        gcnArchName = "gfx90a:sramecc+:xnack-"
+
+    monkeypatch.setattr(torch.version, "cuda", None, raising=False)
+    monkeypatch.setattr(torch.version, "hip", "6.4.0", raising=False)
+    monkeypatch.setattr(torch.cuda, "is_available", lambda: True)
+    monkeypatch.setattr(torch.cuda, "current_device", lambda: 0)
+    monkeypatch.setattr(torch.cuda, "get_device_properties", lambda device: FakeProperties())
+
+
+def test_cuda_incompatible_arch_is_rejected(fake_cuda_device):
+    with pytest.raises(RuntimeError) as exc_info:
+        _check_arch_incompatibility(make_metadata("cuda", ["8.0", "9.0a"]), "test-variant")
+    assert "test-variant" in str(exc_info.value)
+    assert "CUDA capability 10.0" in str(exc_info.value)
+    assert "8.0, 9.0a" in str(exc_info.value)
+
+
+def test_cuda_compatible_arch_is_accepted(fake_cuda_device):
+    for archs in (["8.0", "10.0"], ["10.0a"], ["10.0f"]):
+        _check_arch_incompatibility(make_metadata("cuda", archs), "test-variant")
+
+
+def test_noarch_build_is_accepted(fake_cuda_device):
+    # Backends that support archs (e.g. CUDA) can have builds that do not
+    # declare any (noarch kernels, e.g. pure Triton builds). Such builds are
+    # never rejected.
+    _check_arch_incompatibility(make_metadata("cuda", None), "test-variant")
+    _check_arch_incompatibility(make_metadata("cuda", []), "test-variant")
+
+
+def test_rocm_arch_check(fake_rocm_device):
+    _check_arch_incompatibility(make_metadata("rocm", ["gfx90a", "gfx942"]), "test-variant")
+    _check_arch_incompatibility(make_metadata("rocm", None), "test-variant")
+    with pytest.raises(RuntimeError) as exc_info:
+        _check_arch_incompatibility(make_metadata("rocm", ["gfx942"]), "test-variant")
+    assert "ROCm arch gfx90a" in str(exc_info.value)
+    assert "gfx942" in str(exc_info.value)
+
+
+def test_check_skipped_without_device(monkeypatch):
+    monkeypatch.setattr(torch.version, "cuda", "12.8", raising=False)
+    monkeypatch.setattr(torch.cuda, "is_available", lambda: False)
+    _check_arch_incompatibility(make_metadata("cuda", ["8.0"]), "test-variant")
+
+
+def test_check_skipped_for_backends_without_archs(fake_cuda_device):
+    # Archs of other backends cannot be checked against the current device.
+    _check_arch_incompatibility(make_metadata("cpu", None), "test-variant")
+    _check_arch_incompatibility(make_metadata("metal", ["applegpu_g13"]), "test-variant")
+
+
+def test_issue_707_fa3_on_b200(fake_cuda_device):
+    # https://github.com/huggingface/kernels/issues/707: flash-attn3 only
+    # declares sm_80/sm_90a archs, but loading it on a B200 (capability 10.0)
+    # succeeded and the first launch exited the process. The declared archs
+    # must be rejected for this device.
+    metadata = make_metadata("cuda", ["8.0", "9.0a"])
+    with pytest.raises(RuntimeError, match="does not support the current device"):
+        _check_arch_incompatibility(metadata, "test-variant")
+
+
+@pytest.mark.cuda_only
+def test_get_kernel_rejects_unsupported_capability(monkeypatch):
+    variant_path = install_kernel("kernels-community/relu", revision="v1")
+    metadata = Metadata.read_from_file(variant_path / "metadata.json")
+    if not metadata.backend.archs:
+        pytest.skip("kernel build does not declare archs")
+
+    # ReLU kernel supports PTX, so we need an old version.
+    monkeypatch.setattr(torch.cuda, "get_device_capability", lambda device=None: (1, 0))
+
+    with pytest.raises(RuntimeError, match="does not support the current device"):
+        get_kernel("kernels-community/relu", version=1)
+    assert not has_kernel("kernels-community/relu", version=1)
+
+    # The opt-out only checks that a compatible build variant exists.
+    assert has_kernel("kernels-community/relu", version=1, check_arch=False)
+    kernel = get_kernel("kernels-community/relu", version=1, check_arch=False)
+    assert kernel is not None

kernels-0.16.2/tests/test_minver.py

@@ -0,0 +1,112 @@
+import json
+import re
+
+import pytest
+from kernels_data import Metadata, Version
+
+import kernels
+from kernels.minver import _installed_version, _warn_if_below_minver
+from kernels.utils import _import_from_path, _loaded_kernels
+
+
+def _write_variant(tmp_path, minver):
+    variant_dir = tmp_path / "build" / "torch28-cxx11-cu128-x86_64-linux"
+    variant_dir.mkdir(parents=True)
+    metadata = {
+        "id": "activation_1_cuda",
+        "name": "activation",
+        "version": 1,
+        "license": "Apache-2.0",
+        "python-depends": ["torch"],
+        "backend": {"type": "cuda"},
+    }
+    if minver is not None:
+        metadata["kernels-minver"] = minver
+    (variant_dir / "metadata.json").write_text(json.dumps(metadata))
+    return variant_dir
+
+
+@pytest.mark.parametrize("minver", [None, "0.0.1"])
+def test_no_warning_when_minver_met(tmp_path, recwarn, minver):
+    variant_dir = _write_variant(tmp_path, minver)
+    metadata = Metadata.read_from_file(variant_dir / "metadata.json")
+    _warn_if_below_minver(metadata, variant_dir)
+    assert len(recwarn) == 0
+
+
+def test_no_warning_for_dev_version_of_required_release(tmp_path, recwarn, monkeypatch):
+    # A development version implements the release it leads up to, so
+    # `0.17.0.dev0` must satisfy a `0.17.0` requirement.
+    monkeypatch.setattr(kernels, "__version__", "0.17.0.dev0")
+    variant_dir = _write_variant(tmp_path, "0.17.0")
+    metadata = Metadata.read_from_file(variant_dir / "metadata.json")
+    _warn_if_below_minver(metadata, variant_dir)
+    assert len(recwarn) == 0
+
+
+@pytest.mark.parametrize(
+    "installed",
+    ["0.17.0.dev0", "0.17.0rc1", "0.17.0.post1", "0.17.0+cu121", "0.17"],
+)
+def test_installed_version_uses_release_segment(monkeypatch, installed):
+    monkeypatch.setattr(kernels, "__version__", installed)
+    assert _installed_version() == Version.from_str("0.17.0")
+
+
+def test_installed_version_is_none_for_non_pep440_version(monkeypatch):
+    monkeypatch.setattr(kernels, "__version__", "0.17.0-dirty")
+    assert _installed_version() is None
+
+
+def test_unparseable_installed_version_does_not_fail_load(tmp_path, recwarn, monkeypatch):
+    # A version that cannot be compared must not turn this advisory check into
+    # a hard failure.
+    monkeypatch.setattr(kernels, "__version__", "0.17.0-dirty")
+    variant_dir = _write_variant(tmp_path, "999.1.0")
+    metadata = Metadata.read_from_file(variant_dir / "metadata.json")
+    _warn_if_below_minver(metadata, variant_dir)
+    assert len(recwarn) == 0
+
+
+@pytest.mark.parametrize("minver", [42, "", "not-a-version"])
+def test_invalid_minver_is_ignored(tmp_path, recwarn, minver):
+    # A `kernels-minver` that cannot be parsed (e.g. written by a future
+    # version that changed the format) must not fail the load.
+    variant_dir = _write_variant(tmp_path, minver)
+    metadata = Metadata.read_from_file(variant_dir / "metadata.json")
+    _warn_if_below_minver(metadata, variant_dir)
+    assert len(recwarn) == 0
+
+
+def test_version_ordering_is_numeric_not_lexicographic():
+    # `0.9 < 0.10` only holds for numeric comparison; string comparison would
+    # get this backwards.
+    assert Version.from_str("0.9") < Version.from_str("0.10")
+    assert Version.from_str("0.14") == Version.from_str("0.14.0")
+    assert Version.from_str("0.14.0") < Version.from_str("0.14.1")
+
+
+def test_warns_when_minver_not_met(tmp_path):
+    variant_dir = _write_variant(tmp_path, "999.1.0")
+    metadata = Metadata.read_from_file(variant_dir / "metadata.json")
+    with pytest.warns(UserWarning, match="requires kernels>=999.1"):
+        _warn_if_below_minver(metadata, variant_dir)
+
+
+def test_warning_mentions_installed_version(tmp_path):
+    variant_dir = _write_variant(tmp_path, "999.1.0")
+    metadata = Metadata.read_from_file(variant_dir / "metadata.json")
+    with pytest.warns(UserWarning, match=f"version {re.escape(kernels.__version__)} is installed"):
+        _warn_if_below_minver(metadata, variant_dir)
+
+
+def test_import_from_path_warns_on_unmet_minver(tmp_path):
+    variant_dir = _write_variant(tmp_path, "999.1.0")
+    (variant_dir / "__init__.py").write_text("value = 42\n")
+    _loaded_kernels.pop(variant_dir, None)
+    try:
+        with pytest.warns(UserWarning, match="requires kernels>=999.1"):
+            module = _import_from_path(variant_dir)
+        assert module.value == 42
+    finally:
+        _loaded_kernels.pop(variant_dir, None)