unitforge 0.3.11__tar.gz → 0.3.13__tar.gz

{unitforge-0.3.11 → unitforge-0.3.13}/.gitignore

@@ -1,6 +1,9 @@
 debug/
 target/
 dist/
+python/unitforge/__init__.pyi
+python/unitforge/py.typed
+python/unitforge/unitforge*
 **/*.rs.bk
 .idea/
 .gitlab-ci-local/

{unitforge-0.3.11 → unitforge-0.3.13}/Cargo.lock

@@ -369,7 +369,7 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "unitforge"
-version = "0.3.11"
+version = "0.3.13"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -384,7 +384,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.3.11"
+version = "0.3.13"
 dependencies = [
  "regex",
 ]

{unitforge-0.3.11 → unitforge-0.3.13}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.3.11"
+version = "0.3.13"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "A library for unit and quantity consistent computations in Rust"
@@ -23,7 +23,7 @@ pyo3 = { version = "0.26.0", features = ["extension-module", "auto-initialize",
 numpy = { version = "0.26.0", optional = true }
 strum = { version = "0.27.2", optional = true }
 strum_macros = { version = "0.27.2", optional = true }
-unitforge_macros = { version = "0.3.10", path = "unitforge_macros" }
+unitforge_macros = { version = "0.3.13", path = "unitforge_macros" }
 
 [features]
 serde = ["dep:serde", "dep:serde_json", "ndarray/serde"]

{unitforge-0.3.11 → unitforge-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.3.11
+Version: 0.3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License

{unitforge-0.3.11 → unitforge-0.3.13}/pyproject.toml

@@ -34,3 +34,7 @@ bindings = "pyo3"
 features = ["pyo3"]
 python-source = "python"
 module-name = "unitforge.unitforge"
+include = [
+    "unitforge/__init__.pyi",
+    "unitforge/py.typed",
+]

unitforge-0.3.13/python/unitforge/__init__.py

@@ -0,0 +1,4 @@
+from .unitforge import *  # noqa: F401,F403
+from . import unitforge as _ext
+_UNITFORGE_API = _ext._UNITFORGE_API
+del _ext

unitforge-0.3.13/src/quantities.template.rs

@@ -0,0 +1,624 @@
+use std::fmt::Display;
+use std::cmp::Ordering;
+use std::fmt;
+use std::fmt::Formatter;
+use std::ops::{Add, Sub, Mul, Div, Neg};
+#[cfg(feature = "pyo3")]
+use pyo3::{Bound, PyAny, prelude::*};
+
+#[derive(Debug)]
+pub enum QuantityOperationError {
+    AddError,
+    SubError,
+    MulError,
+    DivError,
+    SqrtError,
+    ComparisonError,
+}
+
+impl fmt::Display for QuantityOperationError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            QuantityOperationError::AddError => write!(f, "Addition operation failed"),
+            QuantityOperationError::SubError => write!(f, "Subtraction operation failed"),
+            QuantityOperationError::MulError => write!(f, "Multiplication operation failed"),
+            QuantityOperationError::DivError => write!(f, "Division operation failed"),
+            QuantityOperationError::SqrtError => write!(f, "Sqrt operation failed"),
+            QuantityOperationError::ComparisonError => write!(f, "Comparison operation failed"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum Quantity {
+    //Is used for runtime checked operations with quantities
+    FloatQuantity(f64),
+    // __QUANTITY_VARIANTS__
+}
+
+impl Quantity {
+    pub fn to(&self, unit: Unit) -> Result<f64, String> {
+        match (self, unit) {
+            (Quantity::FloatQuantity(value), Unit::NoUnit) => Ok(*value),
+            // __QUANTITY_TO_VARIANTS__
+            _ => Err("Cannot use given pair of quantity and unit.".to_string())
+        }
+    }
+
+    pub fn abs(&self) -> Quantity {
+        match self {
+            Quantity::FloatQuantity(value) => Quantity::FloatQuantity(value.abs()),
+            // __QUANTITY_ABS_VARIANTS__
+        }
+    }
+
+    pub fn is_nan(&self) -> bool {
+        match self {
+            Quantity::FloatQuantity(value) => value.is_nan(),
+            // __QUANTITY_NAN_VARIANTS__
+        }
+    }
+}
+
+
+impl Neg for Quantity {
+    type Output = Quantity;
+    fn neg(self) -> Quantity {
+        match self {
+            Quantity::FloatQuantity(value) => Quantity::FloatQuantity(-value),
+            // __QUANTITY_NEG_VARIANTS__
+        }
+    }
+}
+
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum Unit {
+    //Is used for runtime checked operations with quantities
+    NoUnit,
+    // __UNIT_VARIANTS__
+}
+
+impl Display for Unit {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.get_name())
+    }
+}
+
+impl Unit {
+    pub fn to_quantity(&self, value: f64) -> Quantity {
+        match self {
+            Unit::NoUnit => Quantity::FloatQuantity(value),
+            // __TO_QUANTITY_VARIANTS__
+        }
+    }
+
+    pub fn get_name(&self) -> &str {
+        match self {
+            Unit::NoUnit => "No Unit",
+            // __TO_UNIT_NAME_VARIANTS__
+        }
+    }
+}
+
+impl Mul for Quantity {
+    type Output = Result<Quantity, QuantityOperationError>;
+    fn mul(self, other: Quantity) -> Result<Quantity, QuantityOperationError> {
+        fn try_multiply(lhs: &Quantity, rhs: &Quantity) -> Result<Quantity, QuantityOperationError> {
+            use Quantity::*;
+            match (lhs, rhs) {
+                (FloatQuantity(v_lhs), FloatQuantity(v_rhs)) => Ok(FloatQuantity(v_lhs * v_rhs)),
+                // __MUL_MATCHES__
+                _ => Err(QuantityOperationError::MulError)
+            }
+        }
+        match try_multiply(&self, &other) {
+            Ok(result) => Ok(result),
+            Err(_) => try_multiply(&other, &self)
+        }
+    }
+}
+
+impl Div for Quantity {
+    type Output = Result<Quantity, QuantityOperationError>;
+    fn div(self, other: Quantity) -> Result<Quantity, QuantityOperationError> {
+        use Quantity::*;
+        match (self, other) {
+            (FloatQuantity(v_lhs), FloatQuantity(v_rhs)) => Ok(FloatQuantity(v_lhs / v_rhs)),
+            // __DIV_MATCHES__
+            _ => Err(QuantityOperationError::DivError)
+        }
+    }
+}
+
+impl Add for Quantity {
+    type Output = Result<Quantity, QuantityOperationError>;
+    fn add(self, other: Quantity) -> Result<Quantity, QuantityOperationError> {
+        use Quantity::*;
+        match (self, other) {
+            (Quantity::FloatQuantity(v_lhs), Quantity::FloatQuantity(v_rhs)) => Ok(Quantity::FloatQuantity(v_lhs + v_rhs)),
+            // __ADD_QUANTITY_MATCHES__
+            _ => Err(QuantityOperationError::AddError)
+        }
+    }
+}
+
+impl Sub for Quantity {
+    type Output = Result<Quantity, QuantityOperationError>;
+    fn sub(self, other: Quantity) -> Result<Self, QuantityOperationError> {
+        use Quantity::*;
+        match (self, other) {
+            (Quantity::FloatQuantity(v_lhs), Quantity::FloatQuantity(v_rhs)) => Ok(Quantity::FloatQuantity(v_lhs - v_rhs)),
+            // __SUB_QUANTITY_MATCHES__
+            _ => Err(QuantityOperationError::SubError)
+        }
+    }
+}
+
+impl Quantity {
+    pub fn extract_float(&self) -> Result<f64, String> {
+        match self {
+            Quantity::FloatQuantity(v) => Ok(*v),
+            _ => Err("Cannot extract float from Quantity enum".into()),
+        }
+    }
+
+    // __BASE_QUANTITY_MATCHES__
+    pub fn sqrt(&self) -> Result<Self, QuantityOperationError> {
+        match self {
+            Quantity::FloatQuantity(v) => Ok(Self::FloatQuantity(v.sqrt())),
+            // __QUANTITY_SQRTS__
+            _=> Err(QuantityOperationError::SqrtError)
+        }
+    }
+}
+
+impl PartialOrd for Quantity {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        use Quantity::*;
+        match (self, other) {
+            (FloatQuantity(lhs), FloatQuantity(rhs)) => lhs.partial_cmp(rhs),
+            // __QUANTITY_COMPARISONS__
+            _ => panic!("Cannot compare non matching quantities!")
+        }
+    }
+}
+
+#[cfg(feature = "pyo3")]
+fn extract_f64(v: &Bound<PyAny>) -> Option<f64> {
+    if let Ok(inner) = v.extract::<f64>() {
+        Some(inner)
+    } else if let Ok(inner) = v.extract::<f32>() {
+        Some(inner as f64)
+    } else if let Ok(inner) = v.extract::<i32>() {
+        Some(inner as f64)
+    } else if let Ok(inner) = v.extract::<i64>() {
+        Some(inner as f64)
+    } else {
+        None
+    }
+}
+
+#[cfg(feature = "pyo3")]
+impl Quantity {
+    pub fn from_py_any(v: &Bound<PyAny>) -> Result<Self, String> {
+        if let Some(inner) = extract_f64(v) {
+            Ok(Quantity::FloatQuantity(inner))
+        }
+        // __EXTRACT_QUANTITY_MATCHES__
+        else if let Ok(inner) = pyo3_capsule_api::extract_quantity_from_capsule(v) {
+            Ok(inner)
+        }
+        else {
+            Err("Cannot interpret given value as Quantity".to_string())
+        }
+    }
+
+    pub fn to_pyobject(self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(match self {
+            Quantity::FloatQuantity(v) => v.into_pyobject(py).map(|obj| obj.into())?,
+            // __TO_PYOBJECT_MATCHES__
+        })
+    }
+}
+
+impl Display for Quantity {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Quantity::FloatQuantity(v) => write!(f, "{v}"),
+            // __QUANTITY_FMT_MATCHES__
+        }
+    }
+}
+
+#[cfg(feature = "pyo3")]
+impl Unit {
+
+    pub fn from_py_any(v: &Bound<PyAny>) -> Result<Self, String> {
+        // __EXTRACT_UNIT_MATCHES__
+        else if let Ok(inner) = pyo3_capsule_api::extract_unit_from_capsule(v) {
+            Ok(inner)
+        }
+        else {
+            Err("Cannot interpret given value as Quantity".to_string())
+        }
+    }
+}
+
+#[cfg(feature = "pyo3")]
+pub mod pyo3_capsule_api {
+    use super::*;
+    use pyo3::exceptions::PyValueError;
+    use pyo3::ffi;
+    use pyo3::types::{PyAnyMethods, PyCapsule, PyCapsuleMethods, PyList, PyModule};
+    use pyo3::{Bound, PyErr, PyRef, PyResult, Python};
+    use std::ffi::{c_int, CString};
+
+    pub const UNITFORGE_API_VERSION: u64 = 1;
+    pub const CAPSULE_NAME: &str = "_UNITFORGE_API";
+
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug)]
+    pub struct QuantityRepr {
+        pub kind_id: u32,
+        pub multiplier: f64,
+        pub power: i32,
+    }
+
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug)]
+    pub struct UnitRepr {
+        pub kind_id: u32,
+        pub variant_id: i32,
+    }
+
+    pub trait QuantityKindId {
+        const KIND_ID: u32;
+    }
+
+    pub trait UnitKindId {
+        const KIND_ID: u32;
+    }
+
+    pub trait UnitVariantId {
+        fn to_variant_id(self) -> i32;
+        fn from_variant_id(variant_id: i32) -> Option<Self>
+        where
+            Self: Sized;
+    }
+
+    // __QUANTITY_KIND_ID_IMPLS__
+    // __UNIT_KIND_ID_IMPLS__
+    // __UNIT_VARIANT_ID_IMPLS__
+
+    pub fn quantity_to_repr(quantity: Quantity) -> Result<QuantityRepr, String> {
+        match quantity {
+            Quantity::FloatQuantity(value) => Ok(QuantityRepr {
+                kind_id: 0,
+                multiplier: value,
+                power: 0,
+            }),
+            // __QUANTITY_TO_REPR_MATCHES__
+        }
+    }
+
+    fn quantity_from_repr(repr: QuantityRepr) -> Result<Quantity, String> {
+        match repr.kind_id {
+            0 => Ok(Quantity::FloatQuantity(repr.multiplier * 10f64.powi(repr.power))),
+            // __QUANTITY_FROM_REPR_MATCHES__
+            _ => Err(format!("Unknown quantity kind id: {}", repr.kind_id)),
+        }
+    }
+
+    pub fn unit_to_repr(unit: Unit) -> UnitRepr {
+        match unit {
+            Unit::NoUnit => UnitRepr {
+                kind_id: 0,
+                variant_id: 0,
+            },
+            // __UNIT_TO_REPR_MATCHES__
+        }
+    }
+
+    fn unit_from_repr(repr: UnitRepr) -> Result<Unit, String> {
+        match repr.kind_id {
+            0 => Ok(Unit::NoUnit),
+            // __UNIT_FROM_REPR_MATCHES__
+            _ => Err(format!("Unknown unit kind id: {}", repr.kind_id)),
+        }
+    }
+
+    pub fn extract_quantity_from_capsule(obj: &Bound<PyAny>) -> PyResult<Quantity> {
+        let py = obj.py();
+        let module = PyModule::import(py, "unitforge")?;
+        let api = get_api(py, &module)?;
+        let mut repr = QuantityRepr {
+            kind_id: 0,
+            multiplier: 0.0,
+            power: 0,
+        };
+        // SAFETY: `obj` is a valid python object and `repr` points to writable memory.
+        let rc = unsafe { (api.extract_quantity_repr)(obj.as_ptr(), &mut repr as *mut QuantityRepr) };
+        if rc != 0 {
+            return Err(PyErr::fetch(py));
+        }
+        quantity_from_repr(repr).map_err(PyValueError::new_err)
+    }
+
+    pub fn extract_unit_from_capsule(obj: &Bound<PyAny>) -> PyResult<Unit> {
+        let py = obj.py();
+        let module = PyModule::import(py, "unitforge")?;
+        let api = get_api(py, &module)?;
+        let mut repr = UnitRepr {
+            kind_id: 0,
+            variant_id: 0,
+        };
+        // SAFETY: `obj` is a valid python object and `repr` points to writable memory.
+        let rc = unsafe { (api.extract_unit_repr)(obj.as_ptr(), &mut repr as *mut UnitRepr) };
+        if rc != 0 {
+            return Err(PyErr::fetch(py));
+        }
+        unit_from_repr(repr).map_err(PyValueError::new_err)
+    }
+
+    #[repr(C)]
+    #[derive(Clone, Copy)]
+    pub struct UnitforgeApiV1 {
+        pub version: u64,
+        pub extract_quantity_repr:
+            unsafe extern "C" fn(obj: *mut ffi::PyObject, out: *mut QuantityRepr) -> c_int,
+        pub quantity_repr_to_object:
+            unsafe extern "C" fn(repr: QuantityRepr) -> *mut ffi::PyObject,
+        pub extract_unit_repr:
+            unsafe extern "C" fn(obj: *mut ffi::PyObject, out: *mut UnitRepr) -> c_int,
+        pub unit_repr_to_object: unsafe extern "C" fn(repr: UnitRepr) -> *mut ffi::PyObject,
+        pub extract_vector3_repr:
+            unsafe extern "C" fn(obj: *mut ffi::PyObject, out: *mut QuantityRepr) -> c_int,
+        pub vector3_repr_to_object:
+            unsafe extern "C" fn(data: *const QuantityRepr) -> *mut ffi::PyObject,
+        pub extract_matrix3_repr:
+            unsafe extern "C" fn(obj: *mut ffi::PyObject, out: *mut QuantityRepr) -> c_int,
+        pub matrix3_repr_to_object:
+            unsafe extern "C" fn(data: *const QuantityRepr) -> *mut ffi::PyObject,
+    }
+
+    unsafe extern "C" fn extract_quantity_repr_impl(
+        obj: *mut ffi::PyObject,
+        out: *mut QuantityRepr,
+    ) -> c_int {
+        let py = Python::assume_attached();
+        let result: PyResult<()> = (|| {
+            if out.is_null() {
+                return Err(PyValueError::new_err("output pointer for quantity repr is null"));
+            }
+            let obj_bound = Bound::from_borrowed_ptr(py, obj);
+            let quantity = Quantity::from_py_any(&obj_bound).map_err(PyValueError::new_err)?;
+            unsafe {
+                *out = quantity_to_repr(quantity).map_err(PyValueError::new_err)?;
+            }
+            Ok(())
+        })();
+
+        match result {
+            Ok(_) => 0,
+            Err(err) => {
+                err.restore(py);
+                -1
+            }
+        }
+    }
+
+    unsafe extern "C" fn quantity_repr_to_object_impl(repr: QuantityRepr) -> *mut ffi::PyObject {
+        let py = Python::assume_attached();
+        let result: PyResult<Py<PyAny>> = (|| {
+            quantity_from_repr(repr)
+                .map_err(PyValueError::new_err)?
+                .to_pyobject(py)
+        })();
+        match result {
+            Ok(obj) => obj.into_ptr(),
+            Err(err) => {
+                err.restore(py);
+                std::ptr::null_mut()
+            }
+        }
+    }
+
+    unsafe extern "C" fn extract_unit_repr_impl(
+        obj: *mut ffi::PyObject,
+        out: *mut UnitRepr,
+    ) -> c_int {
+        let py = Python::assume_attached();
+        let result: PyResult<()> = (|| {
+            if out.is_null() {
+                return Err(PyValueError::new_err("output pointer for unit repr is null"));
+            }
+            let obj_bound = Bound::from_borrowed_ptr(py, obj);
+            let unit = Unit::from_py_any(&obj_bound).map_err(PyValueError::new_err)?;
+            unsafe {
+                *out = unit_to_repr(unit);
+            }
+            Ok(())
+        })();
+
+        match result {
+            Ok(_) => 0,
+            Err(err) => {
+                err.restore(py);
+                -1
+            }
+        }
+    }
+
+    unsafe extern "C" fn unit_repr_to_object_impl(repr: UnitRepr) -> *mut ffi::PyObject {
+        let py = Python::assume_attached();
+        let result: PyResult<Py<PyAny>> = (|| {
+            let unit = unit_from_repr(repr).map_err(PyValueError::new_err)?;
+            match unit {
+                Unit::NoUnit => {
+                    Err(PyValueError::new_err("NoUnit cannot be converted into a Python object"))
+                }
+                // __UNIT_TO_PYOBJECT_MATCHES__
+            }
+        })();
+        match result {
+            Ok(obj) => obj.into_ptr(),
+            Err(err) => {
+                err.restore(py);
+                std::ptr::null_mut()
+            }
+        }
+    }
+
+    unsafe extern "C" fn extract_vector3_repr_impl(
+        obj: *mut ffi::PyObject,
+        out: *mut QuantityRepr,
+    ) -> c_int {
+        let py = Python::assume_attached();
+        let result: PyResult<()> = (|| {
+            if out.is_null() {
+                return Err(PyValueError::new_err("output pointer for vector repr is null"));
+            }
+            let obj_bound = Bound::from_borrowed_ptr(py, obj);
+            let vec = obj_bound.extract::<Vector3Py>()?;
+            for i in 0..3 {
+                let repr = quantity_to_repr(vec.data[i]).map_err(PyValueError::new_err)?;
+                unsafe {
+                    *out.add(i) = repr;
+                }
+            }
+            Ok(())
+        })();
+        match result {
+            Ok(_) => 0,
+            Err(err) => {
+                err.restore(py);
+                -1
+            }
+        }
+    }
+
+    unsafe extern "C" fn vector3_repr_to_object_impl(
+        data: *const QuantityRepr,
+    ) -> *mut ffi::PyObject {
+        let py = Python::assume_attached();
+        let result: PyResult<Py<PyAny>> = (|| {
+            if data.is_null() {
+                return Err(PyValueError::new_err("input pointer for vector repr is null"));
+            }
+            let mut quantity_data = [Quantity::FloatQuantity(0.0); 3];
+            for i in 0..3 {
+                let repr = unsafe { *data.add(i) };
+                quantity_data[i] = quantity_from_repr(repr).map_err(PyValueError::new_err)?;
+            }
+            let vec = Vector3Py { data: quantity_data };
+            Ok(vec.into_pyobject(py)?.into_any().unbind())
+        })();
+
+        match result {
+            Ok(obj) => obj.into_ptr(),
+            Err(err) => {
+                err.restore(py);
+                std::ptr::null_mut()
+            }
+        }
+    }
+
+    unsafe extern "C" fn extract_matrix3_repr_impl(
+        obj: *mut ffi::PyObject,
+        out: *mut QuantityRepr,
+    ) -> c_int {
+        let py = Python::assume_attached();
+        let result: PyResult<()> = (|| {
+            if out.is_null() {
+                return Err(PyValueError::new_err("output pointer for matrix repr is null"));
+            }
+            let obj_bound = Bound::from_borrowed_ptr(py, obj);
+            let mat = obj_bound.extract::<PyRef<Matrix3Py>>()?;
+            for i in 0..3 {
+                for j in 0..3 {
+                    let repr =
+                        quantity_to_repr(mat.data[i][j]).map_err(PyValueError::new_err)?;
+                    unsafe {
+                        *out.add(i * 3 + j) = repr;
+                    }
+                }
+            }
+            Ok(())
+        })();
+        match result {
+            Ok(_) => 0,
+            Err(err) => {
+                err.restore(py);
+                -1
+            }
+        }
+    }
+
+    unsafe extern "C" fn matrix3_repr_to_object_impl(
+        data: *const QuantityRepr,
+    ) -> *mut ffi::PyObject {
+        let py = Python::assume_attached();
+        let result: PyResult<Py<PyAny>> = (|| {
+            if data.is_null() {
+                return Err(PyValueError::new_err("input pointer for matrix repr is null"));
+            }
+            let mut quantity_data = [[Quantity::FloatQuantity(0.0); 3]; 3];
+            for i in 0..3 {
+                for j in 0..3 {
+                    let repr = unsafe { *data.add(i * 3 + j) };
+                    quantity_data[i][j] =
+                        quantity_from_repr(repr).map_err(PyValueError::new_err)?;
+                }
+            }
+            let mat = Matrix3Py { data: quantity_data };
+            Ok(mat.into_pyobject(py)?.into_any().unbind())
+        })();
+        match result {
+            Ok(obj) => obj.into_ptr(),
+            Err(err) => {
+                err.restore(py);
+                std::ptr::null_mut()
+            }
+        }
+    }
+
+    pub fn register_unitforge_api(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
+        let api = UnitforgeApiV1 {
+            version: UNITFORGE_API_VERSION,
+            extract_quantity_repr: extract_quantity_repr_impl,
+            quantity_repr_to_object: quantity_repr_to_object_impl,
+            extract_unit_repr: extract_unit_repr_impl,
+            unit_repr_to_object: unit_repr_to_object_impl,
+            extract_vector3_repr: extract_vector3_repr_impl,
+            vector3_repr_to_object: vector3_repr_to_object_impl,
+            extract_matrix3_repr: extract_matrix3_repr_impl,
+            matrix3_repr_to_object: matrix3_repr_to_object_impl,
+        };
+
+        let capsule = PyCapsule::new_with_destructor(
+            py,
+            api,
+            Some(CString::new(CAPSULE_NAME).unwrap()),
+            |_api, _ctx| {},
+        )?;
+        m.add(CAPSULE_NAME, capsule)?;
+        Ok(())
+    }
+
+    pub fn get_api<'py>(py: Python<'py>, module: &Bound<'py, PyModule>) -> PyResult<&'py UnitforgeApiV1> {
+        let capsule = module.getattr(CAPSULE_NAME)?.cast_into::<PyCapsule>()?;
+        if !capsule.is_valid() {
+            return Err(PyValueError::new_err(format!(
+                "Invalid capsule in unitforge module at attribute '{CAPSULE_NAME}'"
+            )));
+        }
+        let ptr = capsule.pointer();
+        if ptr.is_null() {
+            return Err(PyValueError::new_err(format!(
+                "Null pointer in unitforge capsule '{CAPSULE_NAME}'"
+            )));
+        }
+        unsafe { Ok(&*ptr.cast::<UnitforgeApiV1>()) }
+    }
+}

{unitforge-0.3.11 → unitforge-0.3.13}/unitforge_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge_macros"
-version = "0.3.11"
+version = "0.3.13"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "Proc macros for generating units, quantities, and Python bindings in unitforge"