unitforge 0.3.12__tar.gz → 0.3.14__tar.gz

{unitforge-0.3.12 → unitforge-0.3.14}/.gitignore

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

{unitforge-0.3.12 → unitforge-0.3.14}/Cargo.lock

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

{unitforge-0.3.12 → unitforge-0.3.14}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.3.12"
+version = "0.3.14"
 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.14", path = "unitforge_macros" }
 
 [features]
 serde = ["dep:serde", "dep:serde_json", "ndarray/serde"]

{unitforge-0.3.12 → unitforge-0.3.14}/PKG-INFO

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

{unitforge-0.3.12 → unitforge-0.3.14}/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.14/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.12 → unitforge-0.3.14}/unitforge_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge_macros"
-version = "0.3.12"
+version = "0.3.14"
 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"

{unitforge-0.3.12 → unitforge-0.3.14}/unitforge_macros/src/lib.rs

@@ -244,6 +244,75 @@ fn parse_unit_variants(files: &[String], unit_name: &str) -> Result<Vec<String>,
     Err(format!("Enum {unit_name} not found in quantity source files"))
 }
 
+fn fnv1a32(input: &str) -> u32 {
+    const OFFSET_BASIS: u32 = 0x811C9DC5;
+    const FNV_PRIME: u32 = 0x01000193;
+
+    let mut hash = OFFSET_BASIS;
+    for byte in input.as_bytes() {
+        hash ^= *byte as u32;
+        hash = hash.wrapping_mul(FNV_PRIME);
+    }
+    hash
+}
+
+fn stable_non_zero_hash(namespace: &str, name: &str) -> u32 {
+    let key = format!("{namespace}:{name}");
+    let mut hash = fnv1a32(&key);
+    if hash == 0 {
+        hash = fnv1a32(&format!("{key}#"));
+        if hash == 0 {
+            hash = 1;
+        }
+    }
+    hash
+}
+
+fn stable_quantity_kind_id(quantity_name: &str) -> u32 {
+    stable_non_zero_hash("unitforge.quantity", quantity_name)
+}
+
+fn stable_unit_variant_id(unit_name: &str, variant_name: &str) -> i32 {
+    let hash = stable_non_zero_hash(
+        "unitforge.unit_variant",
+        &format!("{unit_name}.{variant_name}"),
+    );
+    (hash & 0x7FFF_FFFF) as i32
+}
+
+fn ensure_stable_id_collisions(
+    quantity_names: &[String],
+    unit_variants_by_name: &HashMap<String, Vec<String>>,
+) -> Result<(), String> {
+    let mut quantity_ids: HashMap<u32, String> = HashMap::new();
+    for quantity_name in quantity_names {
+        let id = stable_quantity_kind_id(quantity_name);
+        if let Some(existing) = quantity_ids.insert(id, quantity_name.clone()) {
+            if existing != *quantity_name {
+                return Err(format!(
+                    "Quantity kind id collision: '{existing}' and '{quantity_name}' both map to id {id}"
+                ));
+            }
+        }
+    }
+
+    for (unit_name, variants) in unit_variants_by_name {
+        let mut variant_ids: HashMap<i32, String> = HashMap::new();
+        for variant_name in variants {
+            let id = stable_unit_variant_id(unit_name, variant_name);
+            if let Some(existing) = variant_ids.insert(id, variant_name.clone()) {
+                if existing != *variant_name {
+                    return Err(format!(
+                        "Unit variant id collision in {unit_name}: '{existing}' and '{variant_name}' both map to id {id}"
+                    ));
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
 fn write_quantity_code(
     template: &str,
     files: &[String],
@@ -283,6 +352,7 @@ fn write_quantity_code(
         let variants = parse_unit_variants(files, &unit_name)?;
         unit_variants_by_name.insert(unit_name, variants);
     }
+    ensure_stable_id_collisions(quantity_names, &unit_variants_by_name)?;
 
     let mul_macro_re = Regex::new(r"impl_mul!\(\s*(\w+),\s*(\w+),\s*(\w+)\)").unwrap();
     let div_macro_re = Regex::new(r"impl_div!\(\s*(\w+),\s*(\w+),\s*(\w+)\)").unwrap();
@@ -294,8 +364,8 @@ fn write_quantity_code(
     let mul_self_rel_re = Regex::new(r"impl_mul_relation_with_self!\(\s*(\w+),\s*(\w+)\)").unwrap();
 
     let mut first = true;
-    for (index, struct_name) in quantity_names.iter().enumerate() {
-        let quantity_kind_id = (index + 1) as u32;
+    for struct_name in quantity_names {
+        let quantity_kind_id = stable_quantity_kind_id(struct_name);
         let unit_name = format!("{struct_name}Unit");
         let unit_variant_list = unit_variants_by_name
             .get(&unit_name)
@@ -371,12 +441,13 @@ fn write_quantity_code(
 
         let mut variant_to_id_match = String::new();
         let mut id_to_variant_match = String::new();
-        for (variant_index, variant_name) in unit_variant_list.iter().enumerate() {
+        for variant_name in unit_variant_list {
+            let variant_id = stable_unit_variant_id(&unit_name, variant_name);
             variant_to_id_match += &format!(
-                "            {struct_name}Unit::{variant_name} => {variant_index},\n"
+                "            {struct_name}Unit::{variant_name} => {variant_id},\n"
             );
             id_to_variant_match += &format!(
-                "            {variant_index} => Some({struct_name}Unit::{variant_name}),\n"
+                "            {variant_id} => Some({struct_name}Unit::{variant_name}),\n"
             );
         }
         unit_variant_id_impls += &format!(