kernels-data 0.0.1__tar.gz → 0.14.0.dev1__tar.gz

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/Cargo.lock

@@ -1047,7 +1047,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hf-kernel-builder"
-version = "0.13.0-dev0"
+version = "0.14.0-dev1"
 dependencies = [
  "base32",
  "clap",
@@ -1526,7 +1526,7 @@ dependencies = [
 
 [[package]]
 name = "kernel-abi-check"
-version = "0.13.0-dev0"
+version = "0.14.0-dev1"
 dependencies = [
  "clap",
  "color-eyre",
@@ -1541,7 +1541,7 @@ dependencies = [
 
 [[package]]
 name = "kernel-abi-check-python"
-version = "0.13.0-dev0"
+version = "0.14.0-dev1"
 dependencies = [
  "kernel-abi-check",
  "object 0.36.7",
@@ -1550,7 +1550,7 @@ dependencies = [
 
 [[package]]
 name = "kernels-data"
-version = "0.1.0"
+version = "0.14.0-dev1"
 dependencies = [
  "eyre",
  "itertools 0.13.0",
@@ -1564,7 +1564,7 @@ dependencies = [
 
 [[package]]
 name = "kernels-data-python"
-version = "0.0.1"
+version = "0.14.0-dev1"
 dependencies = [
  "kernels-data",
  "pyo3",

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kernels-data
-Version: 0.0.1
+Version: 0.14.0.dev1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Summary: Kernels data structures (Python bindings)

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kernels-data"
-version = "0.1.0"
+version = "0.14.0-dev1"
 edition = "2024"
 description = "Kernels data structures"
 homepage = "https://github.com/huggingface/kernels"

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/bindings/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kernels-data-python"
-version = "0.0.1"
+version = "0.14.0-dev1"
 edition = "2024"
 description = "Kernels data structures (Python bindings)"
 homepage = "https://github.com/huggingface/kernels"

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/bindings/python/kernels_data.pyi

@@ -1,19 +1,23 @@
 """Type stubs for kernels_data module."""
 
-from enum import Enum
-from typing import Optional
 import os
+from enum import Enum
+from typing import Optional, final
+
+__all__ = ["Backend", "BackendInfo", "KernelName", "Metadata", "Version", "__version__"]
 
 __version__: str
 
+@final
 class Backend(Enum):
     """Kernel backend (hardware target)."""
 
+    CANN = "CANN"
     CPU = "CPU"
     CUDA = "CUDA"
-    METAL = "METAL"
-    NEURON = "NEURON"
-    ROCM = "ROCM"
+    Metal = "Metal"
+    Neuron = "Neuron"
+    ROCm = "ROCm"
     XPU = "XPU"
 
     @staticmethod
@@ -21,8 +25,8 @@ class Backend(Enum):
         """Parse a backend name.
 
         Args:
-            s: One of ``"cpu"``, ``"cuda"``, ``"metal"``, ``"neuron"``,
-               ``"rocm"``, ``"xpu"``.
+            s: One of ``"cann"``, ``"cpu"``, ``"cuda"``, ``"metal"``,
+               ``"neuron"``, ``"rocm"``, ``"xpu"``.
 
         Raises:
             ValueError: If the backend name is unknown.
@@ -32,6 +36,23 @@ class Backend(Enum):
     def __str__(self) -> str: ...
     def __repr__(self) -> str: ...
 
+@final
+class BackendInfo:
+    """Backend information."""
+
+    @property
+    def backend_type(self) -> Backend:
+        """Return the backend type."""
+        ...
+
+    @property
+    def archs(self) -> Optional[list[str]]:
+        """Optional list of target architectures."""
+        ...
+
+    def __repr__(self) -> str: ...
+
+@final
 class Version:
     """A dotted numeric version (e.g. ``12.8.0``).
 
@@ -49,17 +70,18 @@ class Version:
 
     def __str__(self) -> str: ...
     def __repr__(self) -> str: ...
-    def __eq__(self, other: object) -> bool: ...
-    def __lt__(self, other: "Version") -> bool: ...
-    def __le__(self, other: "Version") -> bool: ...
-    def __gt__(self, other: "Version") -> bool: ...
-    def __ge__(self, other: "Version") -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __lt__(self, value: "Version", /) -> bool: ...
+    def __le__(self, value: "Version", /) -> bool: ...
+    def __gt__(self, value: "Version", /) -> bool: ...
+    def __ge__(self, value: "Version", /) -> bool: ...
     def __hash__(self) -> int: ...
 
+@final
 class KernelName:
     """A validated kernel name matching ``^[a-z][-a-z0-9]*[a-z0-9]$``."""
 
-    def __init__(self, name: str) -> None:
+    def __new__(cls, name: str) -> "KernelName":
         """Create a new ``KernelName``.
 
         Raises:
@@ -74,20 +96,19 @@ class KernelName:
 
     def __str__(self) -> str: ...
     def __repr__(self) -> str: ...
-    def __eq__(self, other: object) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
 
+@final
 class Metadata:
     """Parsed ``metadata.json`` for a kernel build variant."""
 
     @staticmethod
-    def load_from_variant(variant_path: os.PathLike[str] | str) -> Optional["Metadata"]:
-        """Load ``metadata.json`` from a build variant directory.
-
-        Returns ``None`` if the file does not exist in ``variant_path``.
+    def load(metadata_path: os.PathLike[str] | str) -> "Metadata":
+        """Parse ``metadata.json`` at the given path.
 
         Raises:
-            ValueError: If the file exists but cannot be parsed.
+            ValueError: On any I/O or parse error.
         """
         ...
 
@@ -100,13 +121,5 @@ class Metadata:
     @property
     def python_depends(self) -> list[str]: ...
     @property
-    def backend(self) -> Backend: ...
+    def backend(self) -> BackendInfo: ...
     def __repr__(self) -> str: ...
-
-def parse_metadata(path: os.PathLike[str] | str) -> Metadata:
-    """Parse a kernel ``metadata.json`` file.
-
-    Raises:
-        ValueError: On any I/O or parse error.
-    """
-    ...

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/bindings/python/src/lib.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 use std::str::FromStr;
 
 use kernels_data::config::{Backend, KernelName};
-use kernels_data::metadata::{Metadata, parse_metadata};
+use kernels_data::metadata::{BackendInfo, Metadata, parse_metadata};
 use kernels_data::version::Version;
 use pyo3::Bound as PyBound;
 use pyo3::exceptions::PyValueError;
@@ -72,15 +72,17 @@ impl PyKernelName {
 #[pyclass(name = "Backend", eq, frozen, hash)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 enum PyBackend {
+    #[pyo3(name = "CANN")]
+    Cann,
     #[pyo3(name = "CPU")]
     Cpu,
     #[pyo3(name = "CUDA")]
     Cuda,
-    #[pyo3(name = "METAL")]
+    #[pyo3(name = "Metal")]
     Metal,
-    #[pyo3(name = "NEURON")]
+    #[pyo3(name = "Neuron")]
     Neuron,
-    #[pyo3(name = "ROCM")]
+    #[pyo3(name = "ROCm")]
     Rocm,
     #[pyo3(name = "XPU")]
     Xpu,
@@ -89,6 +91,7 @@ enum PyBackend {
 impl From<Backend> for PyBackend {
     fn from(b: Backend) -> Self {
         match b {
+            Backend::Cann => PyBackend::Cann,
             Backend::Cpu => PyBackend::Cpu,
             Backend::Cuda => PyBackend::Cuda,
             Backend::Metal => PyBackend::Metal,
@@ -102,6 +105,7 @@ impl From<Backend> for PyBackend {
 impl From<PyBackend> for Backend {
     fn from(b: PyBackend) -> Self {
         match b {
+            PyBackend::Cann => Backend::Cann,
             PyBackend::Cpu => Backend::Cpu,
             PyBackend::Cuda => Backend::Cuda,
             PyBackend::Metal => Backend::Metal,
@@ -114,8 +118,8 @@ impl From<PyBackend> for Backend {
 
 #[pymethods]
 impl PyBackend {
-    /// Parse a backend name (`"cpu"`, `"cuda"`, `"metal"`, `"neuron"`,
-    /// `"rocm"`, `"xpu"`).
+    /// Parse a backend name (`"cann"`, `"cpu"`, `"cuda"`, `"metal"`,
+    /// `"neuron"`, `"rocm"`, `"xpu"`).
     #[staticmethod]
     #[pyo3(name = "from_str")]
     fn py_from_str(s: &str) -> PyResult<Self> {
@@ -130,17 +134,56 @@ impl PyBackend {
 
     fn __repr__(&self) -> String {
         let variant = match self {
+            PyBackend::Cann => "CANN",
             PyBackend::Cpu => "CPU",
             PyBackend::Cuda => "CUDA",
-            PyBackend::Metal => "METAL",
-            PyBackend::Neuron => "NEURON",
-            PyBackend::Rocm => "ROCM",
+            PyBackend::Metal => "Metal",
+            PyBackend::Neuron => "Neuron",
+            PyBackend::Rocm => "ROCm",
             PyBackend::Xpu => "XPU",
         };
         format!("Backend.{variant}")
     }
 }
 
+/// Backend information
+#[pyclass(name = "BackendInfo", frozen)]
+#[derive(Clone, Debug)]
+struct PyBackendInfo {
+    backend_type: PyBackend,
+    archs: Option<Vec<String>>,
+}
+
+impl From<BackendInfo> for PyBackendInfo {
+    fn from(backend_info: BackendInfo) -> Self {
+        Self {
+            backend_type: backend_info.backend_type.into(),
+            archs: backend_info.archs,
+        }
+    }
+}
+
+#[pymethods]
+impl PyBackendInfo {
+    fn __repr__(&self) -> String {
+        format!(
+            "BackendInfo(backend_type={}, archs={:?})",
+            self.backend_type.__repr__(),
+            self.archs
+        )
+    }
+
+    #[getter]
+    fn backend_type(&self) -> PyBackend {
+        self.backend_type
+    }
+
+    #[getter]
+    fn archs(&self) -> Option<&[String]> {
+        self.archs.as_deref()
+    }
+}
+
 /// Parsed `metadata.json` for a kernel build variant.
 #[pyclass(name = "Metadata", frozen)]
 #[derive(Clone, Debug)]
@@ -149,7 +192,7 @@ struct PyMetadata {
     license: Option<String>,
     upstream: Option<String>,
     python_depends: Vec<String>,
-    backend: PyBackend,
+    backend: PyBackendInfo,
 }
 
 impl From<Metadata> for PyMetadata {
@@ -159,25 +202,20 @@ impl From<Metadata> for PyMetadata {
             license: m.license,
             upstream: m.upstream.map(|u| u.to_string()),
             python_depends: m.python_depends,
-            backend: m.backend.backend_type.into(),
+            backend: m.backend.into(),
         }
     }
 }
 
 #[pymethods]
 impl PyMetadata {
-    /// Load `metadata.json` from a build variant directory.
+    /// Parse `metadata.json` at the given path.
     ///
-    /// Returns `None` if the file does not exist in the given directory.
-    /// Raises `ValueError` if the file exists but cannot be parsed.
+    /// Raises `ValueError` on any I/O or parse error.
     #[staticmethod]
-    fn load_from_variant(variant_path: PathBuf) -> PyResult<Option<Self>> {
-        let metadata_path = variant_path.join("metadata.json");
-        if !metadata_path.exists() {
-            return Ok(None);
-        }
+    fn load(metadata_path: PathBuf) -> PyResult<Self> {
         parse_metadata(&metadata_path)
-            .map(|m| Some(m.into()))
+            .map(Into::into)
             .map_err(|err| PyValueError::new_err(format!("{err:#}")))
     }
 
@@ -187,23 +225,23 @@ impl PyMetadata {
     }
 
     #[getter]
-    fn license(&self) -> Option<&str> {
-        self.license.as_deref()
+    fn license(&self) -> Option<&String> {
+        self.license.as_ref()
     }
 
     #[getter]
-    fn upstream(&self) -> Option<&str> {
-        self.upstream.as_deref()
+    fn upstream(&self) -> Option<&String> {
+        self.upstream.as_ref()
     }
 
     #[getter]
-    fn python_depends(&self) -> Vec<String> {
-        self.python_depends.clone()
+    fn python_depends(&self) -> &[String] {
+        &self.python_depends
     }
 
     #[getter]
-    fn backend(&self) -> PyBackend {
-        self.backend
+    fn backend(&self) -> PyBackendInfo {
+        self.backend.clone()
     }
 
     fn __repr__(&self) -> String {
@@ -218,23 +256,13 @@ impl PyMetadata {
     }
 }
 
-/// Parse a kernel `metadata.json` file.
-///
-/// Raises `ValueError` on any I/O or parse error.
-#[pyfunction(name = "parse_metadata")]
-fn py_parse_metadata(path: PathBuf) -> PyResult<PyMetadata> {
-    parse_metadata(&path)
-        .map(Into::into)
-        .map_err(|err| PyValueError::new_err(format!("{err:#}")))
-}
-
 #[pyo3::pymodule(name = "kernels_data")]
 fn kernels_data_py(m: &PyBound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyBackend>()?;
+    m.add_class::<PyBackendInfo>()?;
     m.add_class::<PyKernelName>()?;
     m.add_class::<PyMetadata>()?;
     m.add_class::<PyVersion>()?;
-    m.add_function(wrap_pyfunction!(py_parse_metadata, m)?)?;
 
     m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     Ok(())

kernels_data-0.14.0.dev1/kernels-data/bindings/python/stubtest-allowlist.txt

@@ -0,0 +1,3 @@
+# The `.so` submodule `kernels_data.kernels_data` is a pyo3/maturin
+# implementation detail; end users import from the `kernels_data` package.
+kernels_data\.kernels_data

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/bindings/python/tests/test_kernels_data.py

@@ -2,12 +2,11 @@ import json
 
 import pytest
 
-from kernels_data import Backend, KernelName, Metadata, Version, parse_metadata
+from kernels_data import Backend, KernelName, Metadata, Version
 
 
-def _write_metadata(variant_dir, **fields):
-    variant_dir.mkdir(parents=True, exist_ok=True)
-    path = variant_dir / "metadata.json"
+def _write_metadata(path, **fields):
+    path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(json.dumps(fields))
     return path
 
@@ -72,7 +71,21 @@ def test_backend_unknown():
         Backend.from_str("tpu")
 
 
-def test_metadata_parse_full(tmp_path):
+def test_backend_all_variants_and_casing():
+    assert str(Backend.Metal) == "metal"
+    assert repr(Backend.Metal) == "Backend.Metal"
+    assert str(Backend.Neuron) == "neuron"
+    assert repr(Backend.Neuron) == "Backend.Neuron"
+    assert str(Backend.ROCm) == "rocm"
+    assert repr(Backend.ROCm) == "Backend.ROCm"
+    assert repr(Backend.XPU) == "Backend.XPU"
+    assert repr(Backend.CANN) == "Backend.CANN"
+    assert Backend.from_str("cann") == Backend.CANN
+    assert Backend.from_str("ROCM") == Backend.ROCm
+    assert Backend.from_str("metal") == Backend.Metal
+
+
+def test_metadata_load_full(tmp_path):
     path = tmp_path / "metadata.json"
     path.write_text(
         json.dumps(
@@ -81,32 +94,37 @@ def test_metadata_parse_full(tmp_path):
                 "license": "Apache-2.0",
                 "upstream": "https://github.com/example/kernel",
                 "python-depends": ["torch"],
-                "backend": {"type": "cuda"},
+                "backend": {"type": "cuda", "archs": ["9.0", "10.0"]},
             }
         )
     )
-    m = parse_metadata(path)
+    m = Metadata.load(path)
     assert m.version == 1
     assert m.license == "Apache-2.0"
     assert m.upstream == "https://github.com/example/kernel"
     assert m.python_depends == ["torch"]
-    assert m.backend == Backend.CUDA
+    assert m.backend.backend_type == Backend.CUDA
+    assert m.backend.archs == ["9.0", "10.0"]
 
 
-def test_metadata_parse_minimal(tmp_path):
+def test_metadata_load_minimal(tmp_path):
     path = tmp_path / "metadata.json"
-    path.write_text(
-        json.dumps({"python-depends": [], "backend": {"type": "cpu"}})
-    )
-    m = parse_metadata(path)
+    path.write_text(json.dumps({"python-depends": [], "backend": {"type": "cpu"}}))
+    m = Metadata.load(path)
     assert m.version is None
     assert m.license is None
     assert m.upstream is None
     assert m.python_depends == []
-    assert m.backend == Backend.CPU
+    assert m.backend.backend_type == Backend.CPU
+
+
+def test_metadata_load_cann(tmp_path):
+    path = tmp_path / "metadata.json"
+    path.write_text(json.dumps({"python-depends": [], "backend": {"type": "cann"}}))
+    assert Metadata.load(path).backend.backend_type == Backend.CANN
 
 
-def test_metadata_parse_unknown_field_rejected(tmp_path):
+def test_metadata_load_unknown_field_accepted(tmp_path):
     path = tmp_path / "metadata.json"
     path.write_text(
         json.dumps(
@@ -117,32 +135,25 @@ def test_metadata_parse_unknown_field_rejected(tmp_path):
             }
         )
     )
-    with pytest.raises(ValueError):
-        parse_metadata(path)
+    Metadata.load(path)
 
 
-def test_metadata_parse_malformed(tmp_path):
+def test_metadata_load_malformed(tmp_path):
     path = tmp_path / "metadata.json"
     path.write_text("{not json")
     with pytest.raises(ValueError):
-        parse_metadata(path)
+        Metadata.load(path)
 
 
-def test_metadata_load_from_variant(tmp_path):
-    _write_metadata(
-        tmp_path / "variant",
+def test_metadata_load(tmp_path):
+    path = _write_metadata(
+        tmp_path / "variant" / "metadata.json",
         **{"python-depends": ["torch"], "backend": {"type": "cuda"}},
     )
-    m = Metadata.load_from_variant(tmp_path / "variant")
-    assert m is not None
-    assert m.backend == Backend.CUDA
-
-
-def test_metadata_load_from_variant_missing(tmp_path):
-    (tmp_path / "empty-variant").mkdir()
-    assert Metadata.load_from_variant(tmp_path / "empty-variant") is None
+    m = Metadata.load(path)
+    assert m.backend.backend_type == Backend.CUDA
 
 
-def test_metadata_parse_missing_file(tmp_path):
+def test_metadata_load_missing_file(tmp_path):
     with pytest.raises(ValueError):
-        parse_metadata(tmp_path / "does-not-exist.json")
+        Metadata.load(tmp_path / "does-not-exist.json")

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/src/config/mod.rs

@@ -53,6 +53,10 @@ impl Build {
         self.kernels.is_empty()
     }
 
+    pub fn branch(&self) -> Option<&str> {
+        self.general.hub.as_ref().and_then(|h| h.branch.as_deref())
+    }
+
     pub fn repo_id(&self) -> Option<&str> {
         self.general.hub.as_ref().and_then(|h| h.repo_id.as_deref())
     }
@@ -286,6 +290,7 @@ impl Kernel {
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub enum Backend {
+    Cann,
     Cpu,
     Cuda,
     Metal,
@@ -295,8 +300,9 @@ pub enum Backend {
 }
 
 impl Backend {
-    pub const fn all() -> [Backend; 6] {
+    pub const fn all() -> [Backend; 7] {
         [
+            Backend::Cann,
             Backend::Cpu,
             Backend::Cuda,
             Backend::Metal,
@@ -308,6 +314,7 @@ impl Backend {
 
     pub const fn as_str(&self) -> &'static str {
         match self {
+            Backend::Cann => "cann",
             Backend::Cpu => "cpu",
             Backend::Cuda => "cuda",
             Backend::Metal => "metal",
@@ -321,6 +328,7 @@ impl Backend {
 impl Display for Backend {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Backend::Cann => write!(f, "cann"),
             Backend::Cpu => write!(f, "cpu"),
             Backend::Cuda => write!(f, "cuda"),
             Backend::Metal => write!(f, "metal"),
@@ -336,6 +344,7 @@ impl FromStr for Backend {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_lowercase().as_str() {
+            "cann" => Ok(Backend::Cann),
             "cpu" => Ok(Backend::Cpu),
             "cuda" => Ok(Backend::Cuda),
             "metal" => Ok(Backend::Metal),

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/src/config/v1.rs

@@ -83,6 +83,7 @@ impl TryFrom<Build> for super::Build {
 
         let backends = if universal {
             vec![
+                Backend::Cann,
                 Backend::Cpu,
                 Backend::Cuda,
                 Backend::Metal,

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/src/config/v2.rs

@@ -129,6 +129,7 @@ impl TryFrom<Build> for super::Build {
 
         let backends = if build.general.universal {
             vec![
+                Backend::Cann,
                 Backend::Cpu,
                 Backend::Cuda,
                 Backend::Metal,

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/src/config/v3.rs

@@ -149,6 +149,7 @@ pub enum Kernel {
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub enum Backend {
+    Cann,
     Cpu,
     Cuda,
     Metal,
@@ -256,6 +257,7 @@ impl From<TvmFfi> for super::TvmFfi {
 impl From<Backend> for super::Backend {
     fn from(backend: Backend) -> Self {
         match backend {
+            Backend::Cann => super::Backend::Cann,
             Backend::Cpu => super::Backend::Cpu,
             Backend::Cuda => super::Backend::Cuda,
             Backend::Metal => super::Backend::Metal,
@@ -437,6 +439,7 @@ impl From<super::TvmFfi> for TvmFfi {
 impl From<super::Backend> for Backend {
     fn from(backend: super::Backend) -> Self {
         match backend {
+            super::Backend::Cann => Backend::Cann,
             super::Backend::Cpu => Backend::Cpu,
             super::Backend::Cuda => Backend::Cuda,
             super::Backend::Metal => Backend::Metal,

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/kernels-data/src/metadata.rs

@@ -10,11 +10,15 @@ use crate::config::Backend;
 pub struct BackendInfo {
     #[serde(rename = "type")]
     pub backend_type: Backend,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub archs: Option<Vec<String>>,
 }
 
+/// Kernel metadata.
 #[derive(Debug, Deserialize, Serialize)]
-#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+#[serde(rename_all = "kebab-case")]
 pub struct Metadata {
+    pub id: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub version: Option<usize>,
     #[serde(skip_serializing_if = "Option::is_none")]

{kernels_data-0.0.1 → kernels_data-0.14.0.dev1}/pyproject.toml

@@ -18,6 +18,7 @@ build-backend = "maturin"
 [dependency-groups]
 dev = [
   "pytest>=8",
+  "mypy>=1.11",
 ]
 
 [tool.maturin]