kernel-abi-check 0.1.0__tar.gz → 0.6.2.dev0__tar.gz

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/PKG-INFO

@@ -1,6 +1,8 @@
 Metadata-Version: 2.4
 Name: kernel-abi-check
-Version: 0.1.0
+Version: 0.6.2.dev0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
+Summary: Check the ABI of Hub Kernels
+Home-Page: https://github.com/huggingface/kernel-builder
 Requires-Python: >=3.8

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/bindings/python/Cargo.lock

@@ -271,7 +271,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "kernel-abi-check"
-version = "0.6.1"
+version = "0.6.2-dev0"
 dependencies = [
  "clap",
  "color-eyre",
@@ -286,7 +286,7 @@ dependencies = [
 
 [[package]]
 name = "kernel-abi-check-python"
-version = "0.1.0"
+version = "0.6.2-dev0"
 dependencies = [
  "kernel-abi-check",
  "object",

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/bindings/python/Cargo.toml

@@ -1,7 +1,11 @@
 [package]
 name = "kernel-abi-check-python"
-version = "0.1.0"
+version = "0.6.2-dev0"
 edition = "2024"
+description = "Check the ABI of Hub Kernels"
+homepage = "https://github.com/huggingface/kernel-builder"
+license = "Apache-2.0"
+repository = "https://github.com/huggingface/kernel-builder"
 
 [lib]
 name = "kernel_abi_check"

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/bindings/python/kernel_abi_check.pyi

@@ -1,10 +1,35 @@
 """Type stubs for kernel_abi_check module."""
 
+from enum import Enum
 from typing import List, Union
 import os
 
 __version__: str
 
+class BinaryFormat(Enum):
+    """Binary format of an object file."""
+
+    COFF = "COFF"
+    """COFF (Common Object File Format)"""
+
+    ELF = "ELF"
+    """ELF (Executable and Linkable Format)"""
+
+    MACH_O = "MACH_O"
+    """Mach-O (Mach Object file format)"""
+
+    PE = "PE"
+    """PE (Portable Executable)"""
+
+    WASM = "WASM"
+    """WebAssembly"""
+
+    XCOFF = "XCOFF"
+    """XCOFF (Extended Common Object File Format)"""
+
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+
 class ObjectFile:
     """Object file that can be validated for ABI compatibility."""
 
@@ -19,6 +44,17 @@ class ObjectFile:
         """
         ...
 
+    def format(self) -> BinaryFormat:
+        """Get the binary format of this object file.
+
+        Returns:
+            The binary format of the object file
+
+        Raises:
+            ValueError: If the object file cannot be parsed or has an unsupported format
+        """
+        ...
+
     def check_python_abi(
         self, abi_version: str
     ) -> List[Union[IncompatibleAbi3Symbol, NonAbi3Symbol]]:
@@ -35,7 +71,9 @@ class ObjectFile:
         """
         ...
 
-    def check_manylinux(self, manylinux_version: str) -> List[ManylinuxSymbolViolation]:
+    def check_manylinux(
+        self, manylinux_version: str
+    ) -> List[IncompatibleManylinuxSymbol]:
         """Check manylinux compatibility for this object file.
 
         Args:
@@ -51,7 +89,7 @@ class ObjectFile:
 
     def check_macos(
         self, macos_version: str
-    ) -> List[Union[MissingMinOS, IncompatibleMinOS]]:
+    ) -> List[Union[MissingMacOSVersion, IncompatibleMacOSVersion]]:
         """Check macOS compatibility for this object file.
 
         Args:
@@ -68,6 +106,19 @@ class ObjectFile:
 class IncompatibleAbi3Symbol:
     """ABI3 symbol that is not compatible with the specified Python ABI version."""
 
+    def __init__(self, *, name: str, added: str) -> None:
+        """Create a new IncompatibleAbi3Symbol.
+
+        Args:
+            name: Name of the symbol
+            added: Version when this symbol was added to Python
+
+        Raises:
+            ValueError: If the version string cannot be parsed
+            TypeError: If positional arguments are used
+        """
+        ...
+
     @property
     def name(self) -> str:
         """Name of the symbol."""
@@ -78,6 +129,8 @@ class IncompatibleAbi3Symbol:
         """Version when this symbol was added to Python."""
         ...
 
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
     def __repr__(self) -> str: ...
 
 class NonAbi3Symbol:
@@ -90,9 +143,22 @@ class NonAbi3Symbol:
 
     def __repr__(self) -> str: ...
 
-class ManylinuxSymbolViolation:
+class IncompatibleManylinuxSymbol:
     """Symbol that is not allowed by the manylinux version."""
 
+    def __init__(self, *, name: str, dep: str, version: str) -> None:
+        """Create a new IncompatibleManylinuxSymbol.
+
+        Args:
+            name: Name of the symbol
+            dep: Dependency that contains the symbol
+            version: Version of the symbol
+
+        Raises:
+            TypeError: If positional arguments are used
+        """
+        ...
+
     @property
     def name(self) -> str:
         """Name of the symbol."""
@@ -108,20 +174,42 @@ class ManylinuxSymbolViolation:
         """Version of the symbol."""
         ...
 
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
     def __repr__(self) -> str: ...
 
-class MissingMinOS:
+class MissingMacOSVersion:
     """Object file does not specify minimum OS version."""
 
+    def __init__(self) -> None:
+        """Create a new MissingMacOSVersion."""
+        ...
+
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
     def __repr__(self) -> str: ...
 
-class IncompatibleMinOS:
+class IncompatibleMacOSVersion:
     """The minimum OS version of the object file is higher than the
     specified macOS version."""
 
+    def __init__(self, *, version: str) -> None:
+        """Create a new IncompatibleMacOSVersion.
+
+        Args:
+            version: Minimum OS version of the object file
+
+        Raises:
+            ValueError: If the version string cannot be parsed
+            TypeError: If positional arguments are used
+        """
+        ...
+
     @property
     def version(self) -> str:
         """Minimum OS version of the object file."""
         ...
 
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
     def __repr__(self) -> str: ...

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/bindings/python/src/lib.rs

@@ -1,25 +1,26 @@
-use std::ffi::OsString;
 use std::fs;
+use std::path::PathBuf;
 use std::str::FromStr;
 
 use kernel_abi_check::{
     MacOSViolation, ManylinuxViolation, PythonAbiViolation, Version, check_macos, check_manylinux,
 };
-use object::Object as ObjectTrait;
+use object::{BinaryFormat, Object as ObjectTrait};
 use pyo3::Bound as PyBound;
 use pyo3::exceptions::PyIOError;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
+use pyo3::types::PyTuple;
 
 /// Object file that can be validated.
 #[pyclass(name = "ObjectFile")]
 struct PyObjectFile {
-    filename: OsString,
+    filename: PathBuf,
     data: Vec<u8>,
 }
 
 impl PyObjectFile {
-    fn parse_file(&self) -> PyResult<object::File> {
+    fn parse_file(&self) -> PyResult<object::File<'_>> {
         object::File::parse(&*self.data).map_err(|err| {
             PyValueError::new_err(format!(
                 "Cannot parse object file `{}`: {}",
@@ -34,7 +35,7 @@ impl PyObjectFile {
 impl PyObjectFile {
     /// Create a new `ObjectFile` from a path.
     #[new]
-    fn new(filename: OsString) -> PyResult<Self> {
+    fn new(filename: PathBuf) -> PyResult<Self> {
         let data = fs::read(&filename).map_err(|err| {
             PyIOError::new_err(format!(
                 "Cannot open object file `{}`: {}",
@@ -103,7 +104,7 @@ impl PyObjectFile {
         for violation in violations {
             let py_violation: Py<PyAny> = match violation {
                 ManylinuxViolation::Symbol { name, dep, version } => {
-                    Py::new(py, PyManylinuxSymbolViolation { name, dep, version })?.into()
+                    Py::new(py, PyIncompatibleManylinuxSymbol { name, dep, version })?.into()
                 }
             };
             result.push(py_violation);
@@ -132,18 +133,91 @@ impl PyObjectFile {
         let mut result = Vec::new();
         for violation in violations {
             let py_violation: Py<PyAny> = match violation {
-                MacOSViolation::MissingMinOS => Py::new(py, PyMissingMinOS)?.into(),
+                MacOSViolation::MissingMinOS => Py::new(py, PyMissingMacOSVersion)?.into(),
                 MacOSViolation::IncompatibleMinOS { version } => {
-                    Py::new(py, PyIncompatibleMinOS { version })?.into()
+                    Py::new(py, PyIncompatibleMacOSVersion { version })?.into()
                 }
             };
             result.push(py_violation);
         }
         Ok(result)
     }
+
+    /// Get the binary format of this object file
+    fn format(&self) -> PyResult<PyBinaryFormat> {
+        let file = self.parse_file()?;
+        let binary_format = file.format();
+
+        let py_format = match binary_format {
+            BinaryFormat::Coff => PyBinaryFormat::Coff,
+            BinaryFormat::Elf => PyBinaryFormat::Elf,
+            BinaryFormat::MachO => PyBinaryFormat::MachO,
+            BinaryFormat::Pe => PyBinaryFormat::Pe,
+            BinaryFormat::Wasm => PyBinaryFormat::Wasm,
+            BinaryFormat::Xcoff => PyBinaryFormat::Xcoff,
+            _ => {
+                return Err(PyValueError::new_err(format!(
+                    "Unsupported binary format: {binary_format:?}"
+                )));
+            }
+        };
+
+        Ok(py_format)
+    }
+}
+
+/// Binary format of an object file
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[pyclass(name = "BinaryFormat")]
+pub enum PyBinaryFormat {
+    /// COFF (Common Object File Format)
+    #[pyo3(name = "COFF")]
+    Coff,
+    /// ELF (Executable and Linkable Format)
+    #[pyo3(name = "ELF")]
+    Elf,
+    /// Mach-O (Mach Object file format)
+    #[pyo3(name = "MACH_O")]
+    MachO,
+    /// PE (Portable Executable)
+    #[pyo3(name = "PE")]
+    Pe,
+    /// WebAssembly
+    #[pyo3(name = "WASM")]
+    Wasm,
+    /// XCOFF (Extended Common Object File Format)
+    #[pyo3(name = "XCOFF")]
+    Xcoff,
+}
+
+#[pymethods]
+impl PyBinaryFormat {
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
+
+    fn __repr__(&self) -> String {
+        match self {
+            PyBinaryFormat::Coff => "BinaryFormat.COFF".to_string(),
+            PyBinaryFormat::Elf => "BinaryFormat.ELF".to_string(),
+            PyBinaryFormat::MachO => "BinaryFormat.MACH_O".to_string(),
+            PyBinaryFormat::Pe => "BinaryFormat.PE".to_string(),
+            PyBinaryFormat::Wasm => "BinaryFormat.WASM".to_string(),
+            PyBinaryFormat::Xcoff => "BinaryFormat.XCOFF".to_string(),
+        }
+    }
+
+    fn __str__(&self) -> String {
+        self.__repr__()
+    }
 }
 
 /// Incompatible ABI3 symbol violation
+#[derive(Clone, Debug, Eq, PartialEq)]
 #[pyclass(name = "IncompatibleAbi3Symbol")]
 struct PyIncompatibleAbi3Symbol {
     name: String,
@@ -152,6 +226,22 @@ struct PyIncompatibleAbi3Symbol {
 
 #[pymethods]
 impl PyIncompatibleAbi3Symbol {
+    #[new]
+    #[pyo3(signature = (*py_args, name, added))]
+    fn new(py_args: &Bound<'_, PyTuple>, name: String, added: String) -> PyResult<Self> {
+        if !py_args.is_empty() {
+            return Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+                "All arguments must be provided as keyword arguments",
+            ));
+        }
+        let added = Version::from_str(&added).map_err(|err| {
+            PyValueError::new_err(format!(
+                "Cannot parse the version the symbol was added `{added}`: {err}",
+            ))
+        })?;
+        Ok(Self { name, added })
+    }
+
     #[getter]
     fn name(&self) -> &str {
         &self.name
@@ -162,6 +252,14 @@ impl PyIncompatibleAbi3Symbol {
         self.added.to_string()
     }
 
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
+
     fn __repr__(&self) -> String {
         format!(
             "IncompatibleAbi3Symbol(name='{}', version_added='{}')",
@@ -189,15 +287,32 @@ impl PyNonAbi3Symbol {
 }
 
 /// Manylinux symbol violation
-#[pyclass(name = "ManylinuxSymbolViolation")]
-struct PyManylinuxSymbolViolation {
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[pyclass(name = "IncompatibleManylinuxSymbol")]
+struct PyIncompatibleManylinuxSymbol {
     name: String,
     dep: String,
     version: String,
 }
 
 #[pymethods]
-impl PyManylinuxSymbolViolation {
+impl PyIncompatibleManylinuxSymbol {
+    #[new]
+    #[pyo3(signature = (*py_args, name, dep, version))]
+    fn new(
+        py_args: &Bound<'_, PyTuple>,
+        name: String,
+        dep: String,
+        version: String,
+    ) -> PyResult<Self> {
+        if !py_args.is_empty() {
+            return Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+                "All arguments must be provided as keyword arguments",
+            ));
+        }
+        Ok(Self { name, dep, version })
+    }
+
     #[getter]
     fn name(&self) -> &str {
         &self.name
@@ -213,40 +328,87 @@ impl PyManylinuxSymbolViolation {
         &self.version
     }
 
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
+
     fn __repr__(&self) -> String {
         format!(
-            "ManylinuxSymbolViolation(name='{}', dep='{}', version='{}')",
+            "IncompatibleManylinuxSymbol(name='{}', dep='{}', version='{}')",
             self.name, self.dep, self.version
         )
     }
 }
 
 /// Missing minimum OS version violation
-#[pyclass(name = "MissingMinOS")]
-struct PyMissingMinOS;
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[pyclass(name = "MissingMacOSVersion")]
+struct PyMissingMacOSVersion;
 
 #[pymethods]
-impl PyMissingMinOS {
+impl PyMissingMacOSVersion {
+    #[new]
+    pub fn new() -> Self {
+        Self
+    }
+
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
+
     fn __repr__(&self) -> String {
-        "MissingMinOS()".to_string()
+        "MissingMacOSVersion()".to_string()
     }
 }
 
 /// Incompatible minimum OS version violation
-#[pyclass(name = "IncompatibleMinOS")]
-struct PyIncompatibleMinOS {
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[pyclass(name = "IncompatibleMacOSVersion")]
+struct PyIncompatibleMacOSVersion {
     version: Version,
 }
 
 #[pymethods]
-impl PyIncompatibleMinOS {
+impl PyIncompatibleMacOSVersion {
+    #[new]
+    #[pyo3(signature = (*py_args, version))]
+    fn new(py_args: &Bound<'_, PyTuple>, version: String) -> PyResult<Self> {
+        if !py_args.is_empty() {
+            return Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+                "All arguments must be provided as keyword arguments",
+            ));
+        }
+        let version = Version::from_str(&version).map_err(|err| {
+            PyValueError::new_err(format!(
+                "Cannot parse the version the symbol was added `{version}`: {err}",
+            ))
+        })?;
+        Ok(Self { version })
+    }
+
     #[getter]
     fn version(&self) -> String {
         self.version.to_string()
     }
 
+    fn __eq__(&self, other: &Self) -> bool {
+        self == other
+    }
+
+    fn __ne__(&self, other: &Self) -> bool {
+        self != other
+    }
+
     fn __repr__(&self) -> String {
-        format!("IncompatibleMinOS(version='{}')", self.version)
+        format!("IncompatibleMacOSVersion(version='{}')", self.version)
     }
 }
 
@@ -254,16 +416,19 @@ impl PyIncompatibleMinOS {
 fn kernel_abi_check_py(m: &PyBound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyObjectFile>()?;
 
+    // Binary format enum
+    m.add_class::<PyBinaryFormat>()?;
+
     // Python ABI violation classes
     m.add_class::<PyIncompatibleAbi3Symbol>()?;
     m.add_class::<PyNonAbi3Symbol>()?;
 
     // Manylinux violation classes
-    m.add_class::<PyManylinuxSymbolViolation>()?;
+    m.add_class::<PyIncompatibleManylinuxSymbol>()?;
 
     // macOS violation classes
-    m.add_class::<PyMissingMinOS>()?;
-    m.add_class::<PyIncompatibleMinOS>()?;
+    m.add_class::<PyMissingMacOSVersion>()?;
+    m.add_class::<PyIncompatibleMacOSVersion>()?;
 
     m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     Ok(())

kernel_abi_check-0.6.2.dev0/bindings/python/tests/test_kernel_abi_check.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+import pytest
+
+from kernel_abi_check import (
+    BinaryFormat,
+    IncompatibleAbi3Symbol,
+    IncompatibleMacOSVersion,
+    ObjectFile,
+    IncompatibleManylinuxSymbol,
+)
+
+
+@pytest.fixture
+def test_dir():
+    return Path(__file__).parent
+
+
+def test_macos_shared_lib(test_dir):
+    o = ObjectFile(test_dir / "hello-darwin-x86_64.abi3.so")
+    assert o.check_python_abi("3.8") == []
+    assert o.check_python_abi("3.5") == [
+        IncompatibleAbi3Symbol(name="PyModule_GetNameObject", added="3.7")
+    ]
+
+    assert o.check_macos("15.0") == []
+    assert o.check_macos("10.0") == [IncompatibleMacOSVersion(version="11.3")]
+
+    assert o.format() == BinaryFormat.MACH_O
+
+
+def test_linux_shared_lib(test_dir):
+    o = ObjectFile(test_dir / "hello-linux-x86_64.abi3.so")
+    assert o.check_python_abi("3.8") == []
+    assert o.check_python_abi("3.5") == [
+        IncompatibleAbi3Symbol(name="PyModule_GetNameObject", added="3.7")
+    ]
+
+    assert o.check_manylinux("manylinux_2_34") == []
+    assert o.check_manylinux("manylinux_2_28") == [
+        IncompatibleManylinuxSymbol(name="fstat64", dep="GLIBC", version="2.33"),
+        IncompatibleManylinuxSymbol(
+            name="pthread_key_create", dep="GLIBC", version="2.34"
+        ),
+        IncompatibleManylinuxSymbol(
+            name="pthread_key_delete", dep="GLIBC", version="2.34"
+        ),
+        IncompatibleManylinuxSymbol(
+            name="pthread_setspecific", dep="GLIBC", version="2.34"
+        ),
+        IncompatibleManylinuxSymbol(name="stat64", dep="GLIBC", version="2.33"),
+    ]
+
+    assert o.format() == BinaryFormat.ELF

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/kernel-abi-check/Cargo.lock

@@ -274,7 +274,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "kernel-abi-check"
-version = "0.6.1"
+version = "0.6.2-dev0"
 dependencies = [
  "clap",
  "color-eyre",

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/kernel-abi-check/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kernel-abi-check"
-version = "0.6.1"
+version = "0.6.2-dev0"
 edition = "2021"
 description = "Check the ABI of Hub Kernels"
 homepage = "https://github.com/huggingface/kernel-builder"

{kernel_abi_check-0.1.0 → kernel_abi_check-0.6.2.dev0}/pyproject.toml

@@ -15,6 +15,11 @@ dynamic = [
 requires = ["maturin>=1,<2"]
 build-backend = "maturin"
 
+[dependency-groups]
+dev = [
+  "pytest>=8",
+]
+
 [tool.maturin]
 module-name = "kernel_abi_check"
 bindings = 'pyo3'