kernels 0.14.0.dev0__tar.gz → 0.14.0.dev1__tar.gz

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

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

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

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

{kernels-0.14.0.dev0 → kernels-0.14.0.dev1}/src/kernels/utils.py

@@ -52,7 +52,42 @@ _loaded_kernels: dict[Path, LoadedKernel] = {}
 
 
 def get_loaded_kernels() -> list[LoadedKernel]:
-    """Returns a copy of the loaded kernels registry (see `kernels.utils.LoadedKernel` NamedTuple)."""
+    """
+    Return a snapshot of every kernel that has been loaded into the current process.
+
+    Each entry is a `kernels.utils.LoadedKernel` dataclass with fields:
+
+    - `kernel_id` (`str`): unique identifier used as the `sys.modules` key
+      for this variant (either `metadata.id` or a hash-suffixed module name).
+    - `module` (`ModuleType`): the imported kernel module.
+    - `module_name` (`str`): the kernel's module name.
+    - `repo_infos` (`kernels.utils.RepoInfos | None`): populated only for
+      kernels loaded via `get_kernel`. Loaders that work from a local path
+      (`get_local_kernel`) or a lockfile (`get_locked_kernel`, `load_kernel`)
+      leave this as `None`.
+
+    `RepoInfos` has `repo_id`, `revision`, and `backend` fields. `backend`
+    reflects the value passed by the caller — it is `None` when the caller
+    relied on backend auto-detection.
+
+    The returned list is a new list; mutating it does not affect the registry.
+
+    > [!NOTE]
+    > These arguments might be renamed / changed a bit.
+
+    Returns:
+        `list[LoadedKernel]`: one entry per distinct kernel variant path
+        loaded in this process.
+
+    Example:
+        ```python
+        from kernels import get_kernel, get_loaded_kernels
+
+        get_kernel("kernels-community/activation", version=1)
+        for loaded in get_loaded_kernels():
+            print(loaded.module_name, loaded.repo_infos)
+        ```
+    """
     return list(_loaded_kernels.values())
 
 

{kernels-0.14.0.dev0 → kernels-0.14.0.dev1}/src/kernels.egg-info/PKG-INFO

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

{kernels-0.14.0.dev0 → kernels-0.14.0.dev1}/src/kernels.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ tests/test_func.py
 tests/test_interval_tree.py
 tests/test_kernel_locking.py
 tests/test_layer.py
+tests/test_loaded_kernels.py
 tests/test_status.py
 tests/test_tvm_ffi.py
 tests/test_user_agent.py

{kernels-0.14.0.dev0 → kernels-0.14.0.dev1}/tests/test_basic.py

@@ -152,9 +152,9 @@ def test_version_old():
 
 def test_version():
     kernel = get_kernel("kernels-test/versions", version=1)
-    assert kernel.version() == "1"
+    assert kernel.version() == 1
     kernel = get_kernel("kernels-test/versions", version=2)
-    assert kernel.version() == "2"
+    assert kernel.version() == 2
 
     with pytest.raises(ValueError, match="Version 0 not found, available versions: 1, 2.*"):
         kernel = get_kernel("kernels-test/versions", version=0)
@@ -163,13 +163,13 @@ def test_version():
 def test_version_outdated_warning(caplog):
     with caplog.at_level(logging.WARNING, logger="kernels._versions"):
         kernel = get_kernel("kernels-test/versions", version=1)
-    assert kernel.version() == "1"
+    assert kernel.version() == 1
     assert "You are using version 1 of 'kernels-test/versions', but version 2 is available." in caplog.text
 
     caplog.clear()
     with caplog.at_level(logging.WARNING, logger="kernels._versions"):
         kernel = get_kernel("kernels-test/versions", version=2)
-    assert kernel.version() == "2"
+    assert kernel.version() == 2
     assert "but version" not in caplog.text
 
 

{kernels-0.14.0.dev0 → kernels-0.14.0.dev1}/tests/test_layer.py

@@ -1108,7 +1108,7 @@ def test_layer_versions(device):
         }
     ):
         version = kernelize(version, device=device, mode=Mode.INFERENCE)
-        assert version() == "0.2.0"
+        assert version() == 2
 
     with use_kernel_mapping(
         {
@@ -1122,7 +1122,7 @@ def test_layer_versions(device):
         }
     ):
         version = kernelize(version, device=device, mode=Mode.INFERENCE)
-        assert version() == "1"
+        assert version() == 1
 
     with use_kernel_mapping(
         {
@@ -1136,7 +1136,7 @@ def test_layer_versions(device):
         }
     ):
         version = kernelize(version, device=device, mode=Mode.INFERENCE)
-        assert version() == "2"
+        assert version() == 2
 
     with use_kernel_mapping(
         {

kernels-0.14.0.dev1/tests/test_loaded_kernels.py

@@ -0,0 +1,102 @@
+from dataclasses import fields
+
+import pytest
+
+from kernels import get_kernel, get_loaded_kernels, get_local_kernel, install_kernel
+from kernels.utils import LoadedKernel, RepoInfos, _loaded_kernels
+
+_REPO_ID = "kernels-community/relu"
+_PACKAGE_NAME = "relu"
+_VERSION = 1
+
+
+@pytest.fixture
+def fresh_registry():
+    """Snapshot the process-wide registry, run the test with a clean one, restore on teardown."""
+    saved = _loaded_kernels.copy()
+    _loaded_kernels.clear()
+    yield
+    _loaded_kernels.clear()
+    _loaded_kernels.update(saved)
+
+
+def test_dataclass_shape():
+    assert tuple(f.name for f in fields(LoadedKernel)) == (
+        "kernel_id",
+        "module",
+        "module_name",
+        "repo_infos",
+    )
+    assert tuple(f.name for f in fields(RepoInfos)) == (
+        "repo_id",
+        "revision",
+        "backend",
+    )
+
+
+def test_get_loaded_kernels_returns_copy(fresh_registry):
+    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    snapshot = get_loaded_kernels()
+    assert len(snapshot) == 1
+
+    snapshot.clear()
+    snapshot.append("garbage")  # type: ignore[arg-type]
+
+    again = get_loaded_kernels()
+    assert len(again) == 1
+    assert again[0].module is kernel
+
+
+def test_get_kernel_registers_loaded_kernel(fresh_registry):
+    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    loaded = get_loaded_kernels()
+    assert len(loaded) == 1
+
+    entry = loaded[0]
+    assert entry.module is kernel
+    assert entry.module_name == _PACKAGE_NAME
+    assert entry.repo_infos is not None
+    assert entry.repo_infos.repo_id == _REPO_ID
+    assert isinstance(entry.repo_infos.revision, str) and entry.repo_infos.revision
+    assert entry.repo_infos.backend == "cpu"
+
+
+def test_repeated_get_kernel_is_cached(fresh_registry):
+    first = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    second = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    assert first is second
+    assert len(get_loaded_kernels()) == 1
+
+
+def test_get_local_kernel_registers_with_null_repo_infos(fresh_registry):
+    # Populate the HF cache via get_kernel, grab the variant path it registered,
+    # then clear the registry and exercise get_local_kernel against that path.
+    get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    (variant_path,) = list(_loaded_kernels.keys())
+
+    _loaded_kernels.clear()
+
+    kernel = get_local_kernel(variant_path, _PACKAGE_NAME, backend="cpu")
+
+    loaded = get_loaded_kernels()
+    assert len(loaded) == 1
+
+    entry = loaded[0]
+    assert entry.module is kernel
+    assert entry.module_name == _PACKAGE_NAME
+    assert entry.repo_infos is None
+
+
+def test_install_kernel_plus_import_does_not_set_repo_infos(fresh_registry):
+    # install_kernel alone does not import; it returns a path. Any loader
+    # that does not go through get_kernel must leave repo_infos as None.
+    package_name, variant_path = install_kernel(_REPO_ID, revision="main", backend="cpu")
+    assert package_name == _PACKAGE_NAME
+    assert get_loaded_kernels() == []
+
+    get_local_kernel(variant_path, package_name, backend="cpu")
+    (entry,) = get_loaded_kernels()
+    assert entry.repo_infos is None