unitforge 0.3.8__tar.gz → 0.3.10__tar.gz

{unitforge-0.3.8 → unitforge-0.3.10}/Cargo.lock

@@ -369,22 +369,15 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "unitforge"
-version = "0.3.8"
+version = "0.3.10"
 dependencies = [
  "ndarray",
  "num-traits",
  "numpy",
  "pyo3",
+ "regex",
  "serde",
  "serde_json",
  "strum",
  "strum_macros",
- "unitforge_macros",
-]
-
-[[package]]
-name = "unitforge_macros"
-version = "0.3.8"
-dependencies = [
- "regex",
 ]

{unitforge-0.3.8 → unitforge-0.3.10}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.3.8"
+version = "0.3.10"
 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,12 +23,11 @@ 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.8", path = "unitforge_macros" }
+
+[build-dependencies]
+regex = "1.11.1"
 
 [features]
 serde = ["dep:serde", "dep:serde_json", "ndarray/serde"]
 pyo3 = ["dep:pyo3", "dep:numpy"]
 strum = ["dep:strum", "dep:strum_macros"]
-
-[workspace]
-members = ["unitforge_macros"]

{unitforge-0.3.8 → unitforge-0.3.10}/PKG-INFO

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

unitforge-0.3.8/unitforge_macros/src/lib.rs → unitforge-0.3.10/build.rs

@@ -1,172 +1,67 @@
-use proc_macro::TokenStream;
 use regex::Regex;
-use std::fs;
-use std::io;
+use std::fs::File;
 use std::path::{Path, PathBuf};
-
-struct SourceFile {
-    rel_path: String,
-    content: String,
-}
-
-struct Context {
-    files: Vec<String>,
-    quantity_files: Vec<SourceFile>,
-    relations: Option<SourceFile>,
-    quantity_names: Vec<String>,
-    aliases: Vec<(String, String, String, String)>,
-}
-
-#[proc_macro]
-pub fn generate_quantities(_input: TokenStream) -> TokenStream {
-    match generate_quantities_impl() {
-        Ok(tokens) => tokens,
-        Err(err) => compile_error(&err),
+use std::{env, fs, io::Write};
+
+fn main() {
+    let quantities_template_path = "src/quantities.template.rs".to_string();
+    let vector_template_path = "src/small_linalg/bindings/vector3_py.template.rs".to_string();
+    let matrix_template_path = "src/small_linalg/bindings/matrix3_py.template.rs".to_string();
+    println!("cargo:rerun-if-changed=src/quantities/");
+    println!("cargo:rerun-if-changed=src/relations.rs");
+    println!("cargo:rerun-if-changed={quantities_template_path}");
+    println!("cargo:rerun-if-changed={vector_template_path}");
+    println!("cargo:rerun-if-changed={matrix_template_path}");
+
+    let out_dir = env::var("OUT_DIR").unwrap();
+
+    let mut files = read_all_rs_files(Path::new("src/quantities"));
+    if let Ok(relations) = fs::read_to_string("src/relations.rs") {
+        files.push(relations);
     }
-}
 
-#[proc_macro]
-pub fn generate_vector3_py(_input: TokenStream) -> TokenStream {
-    match generate_vector3_py_impl() {
-        Ok(tokens) => tokens,
-        Err(err) => compile_error(&err),
-    }
-}
+    let quantity_macro_re = Regex::new(r"impl_quantity!\s*\(\s*(\w+)").unwrap();
+    let quantity_names = extract_quantities(&files, &quantity_macro_re);
+    let aliases = extract_aliases(&files);
 
-#[proc_macro]
-pub fn generate_matrix3_py(_input: TokenStream) -> TokenStream {
-    match generate_matrix3_py_impl() {
-        Ok(tokens) => tokens,
-        Err(err) => compile_error(&err),
-    }
-}
+    write_quantity_code(
+        &Path::new(&out_dir).join("quantities.rs"),
+        &files,
+        &quantity_names,
+        quantities_template_path,
+    );
 
-#[proc_macro]
-pub fn generate_python_module_definition(_input: TokenStream) -> TokenStream {
-    match generate_python_module_definition_impl() {
-        Ok(tokens) => tokens,
-        Err(err) => compile_error(&err),
+    if env::var("CARGO_FEATURE_PYO3").is_ok() {
+        write_vector_code(
+            &Path::new(&out_dir).join("vector3_py.rs"),
+            &quantity_names,
+            vector_template_path,
+        );
+        write_matrix_code(
+            &Path::new(&out_dir).join("matrix3_py.rs"),
+            &quantity_names,
+            matrix_template_path,
+        );
+        write_module_definition(
+            &Path::new(&out_dir).join("python_module_definition.rs"),
+            &quantity_names,
+            aliases,
+        );
     }
 }
 
-fn generate_quantities_impl() -> Result<TokenStream, String> {
-    let ctx = load_context()?;
-    let template = read_template("quantities.template.rs")?;
-    let generated = write_quantity_code(&template, &ctx.files, &ctx.quantity_names);
-    let deps = dependency_consts(&deps_for_quantities(&ctx));
-    parse_generated(&format!("{generated}\n{deps}"))
-}
-
-fn generate_vector3_py_impl() -> Result<TokenStream, String> {
-    let ctx = load_context()?;
-    let template = read_template("small_linalg/bindings/vector3_py.template.rs")?;
-    let generated = write_vector_code(&template, &ctx.quantity_names);
-    let mut deps_list = deps_for_vector_matrix(&ctx);
-    deps_list.push("small_linalg/bindings/vector3_py.template.rs".to_string());
-    let deps = dependency_consts(&deps_list);
-    parse_generated(&format!("{generated}\n{deps}"))
-}
-
-fn generate_matrix3_py_impl() -> Result<TokenStream, String> {
-    let ctx = load_context()?;
-    let template = read_template("small_linalg/bindings/matrix3_py.template.rs")?;
-    let generated = write_matrix_code(&template, &ctx.quantity_names);
-    let mut deps_list = deps_for_vector_matrix(&ctx);
-    deps_list.push("small_linalg/bindings/matrix3_py.template.rs".to_string());
-    let deps = dependency_consts(&deps_list);
-    parse_generated(&format!("{generated}\n{deps}"))
-}
-
-fn generate_python_module_definition_impl() -> Result<TokenStream, String> {
-    let ctx = load_context()?;
-    let generated = write_module_definition(&ctx.quantity_names, &ctx.aliases);
-    let deps = dependency_consts(&deps_for_python_module_definition(&ctx));
-    parse_generated(&format!("{generated}\n{deps}"))
-}
-
-fn compile_error(message: &str) -> TokenStream {
-    format!("compile_error!({:?});", message)
-        .parse()
-        .unwrap_or_else(|_| TokenStream::new())
-}
-
-fn parse_generated(src: &str) -> Result<TokenStream, String> {
-    src.parse().map_err(|e| format!("Failed to parse generated code: {e}"))
-}
-
-fn unitforge_root() -> PathBuf {
-    std::env::var("CARGO_MANIFEST_DIR")
-        .map(PathBuf::from)
-        .unwrap_or_else(|_| PathBuf::from("."))
-}
-
-fn read_template(rel_path: &str) -> Result<String, String> {
-    let root = unitforge_root();
-    let path = root.join("src").join(rel_path);
-    fs::read_to_string(&path)
-        .map_err(|e| format!("Failed to read template {}: {e}", path.display()))
-}
-
-fn rel_path_from_src(src_root: &Path, path: &Path) -> Result<String, String> {
-    let rel = path
-        .strip_prefix(src_root)
-        .map_err(|e| format!("Failed to compute relative path: {e}"))?;
-    Ok(rel.to_string_lossy().replace('\\', "/"))
-}
-
-fn load_context() -> Result<Context, String> {
-    let root = unitforge_root();
-    let src_root = root.join("src");
-    let quantities_dir = src_root.join("quantities");
-
-    let mut quantity_files = Vec::new();
-    let entries = fs::read_dir(&quantities_dir)
-        .map_err(|e| format!("Can't read {}: {e}", quantities_dir.display()))?;
-
-    for entry in entries {
-        let entry = entry.map_err(|e| format!("Failed to read quantity entry: {e}"))?;
+fn read_all_rs_files(dir: &Path) -> Vec<String> {
+    let mut contents = Vec::new();
+    for entry in fs::read_dir(dir).expect("Can't read src/quantities") {
+        let entry = entry.unwrap();
         let path = entry.path();
         if path.extension().and_then(|s| s.to_str()) == Some("rs") {
-            let content = fs::read_to_string(&path)
-                .map_err(|e| format!("Failed to read {}: {e}", path.display()))?;
-            let rel_path = rel_path_from_src(&src_root, &path)?;
-            quantity_files.push(SourceFile { rel_path, content });
+            if let Ok(c) = fs::read_to_string(&path) {
+                contents.push(c);
+            }
         }
     }
-
-    let mut files = quantity_files
-        .iter()
-        .map(|file| file.content.clone())
-        .collect::<Vec<_>>();
-
-    let relations_path = src_root.join("relations.rs");
-    let relations = match fs::read_to_string(&relations_path) {
-        Ok(content) => {
-            let rel_path = rel_path_from_src(&src_root, &relations_path)?;
-            files.push(content.clone());
-            Some(SourceFile { rel_path, content })
-        }
-        Err(err) if err.kind() == io::ErrorKind::NotFound => None,
-        Err(err) => {
-            return Err(format!(
-                "Failed to read {}: {err}",
-                relations_path.display()
-            ))
-        }
-    };
-
-    let quantity_macro_re =
-        Regex::new(r"impl_quantity!\s*\(\s*(\w+)").map_err(|e| e.to_string())?;
-    let quantity_names = extract_quantities(&files, &quantity_macro_re);
-    let aliases = extract_aliases(&files)?;
-
-    Ok(Context {
-        files,
-        quantity_files,
-        relations,
-        quantity_names,
-        aliases,
-    })
+    contents
 }
 
 fn extract_quantities(files: &[String], re: &Regex) -> Vec<String> {
@@ -179,11 +74,9 @@ fn extract_quantities(files: &[String], re: &Regex) -> Vec<String> {
     result
 }
 
-fn extract_aliases(files: &[String]) -> Result<Vec<(String, String, String, String)>, String> {
-    let alias_re = Regex::new(
-        r"make_alias!\s*\(\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*\)",
-    )
-    .map_err(|e| e.to_string())?;
+fn extract_aliases(files: &[String]) -> Vec<(String, String, String, String)> {
+    let alias_re =
+        Regex::new(r"make_alias!\s*\(\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*\)").unwrap();
     let mut result = Vec::new();
 
     for content in files {
@@ -197,7 +90,7 @@ fn extract_aliases(files: &[String]) -> Result<Vec<(String, String, String, Stri
         }
     }
 
-    Ok(result)
+    result
 }
 
 fn camel_to_snake(input: &str) -> String {
@@ -215,7 +108,15 @@ fn camel_to_snake(input: &str) -> String {
     result
 }
 
-fn write_quantity_code(template: &str, files: &[String], quantity_names: &[String]) -> String {
+fn write_quantity_code(
+    dest_path: &PathBuf,
+    files: &[String],
+    quantity_names: &[String],
+    template_path: String,
+) {
+    let template =
+        fs::read_to_string(template_path).expect("Failed to read quantities.template.rs");
+
     let mut quantity_variants = String::new();
     let mut quantity_to_variants = String::new();
     let mut quantity_fmt_matches = String::new();
@@ -241,12 +142,9 @@ fn write_quantity_code(template: &str, files: &[String], quantity_names: &[Strin
     let mul_self_re = Regex::new(r"impl_mul_with_self!\(\s*(\w+),\s*(\w+)\)").unwrap();
     let div_self_re = Regex::new(r"impl_div_with_self_to_f64!\(\s*(\w+)\)").unwrap();
     let sqrt_macro_re = Regex::new(r"impl_sqrt!\(\s*(\w+),\s*(\w+)\s*\)").unwrap();
-    let mul_rel_re = Regex::new(
-        r"impl_mul_relation_with_other!\(\s*(\w+),\s*(\w+),\s*(\w+)\)",
-    )
-    .unwrap();
-    let mul_self_rel_re =
-        Regex::new(r"impl_mul_relation_with_self!\(\s*(\w+),\s*(\w+)\)").unwrap();
+    let mul_rel_re =
+        Regex::new(r"impl_mul_relation_with_other!\(\s*(\w+),\s*(\w+),\s*(\w+)\)").unwrap();
+    let mul_self_rel_re = Regex::new(r"impl_mul_relation_with_self!\(\s*(\w+),\s*(\w+)\)").unwrap();
 
     let mut first = true;
     for struct_name in quantity_names {
@@ -296,7 +194,12 @@ fn write_quantity_code(template: &str, files: &[String], quantity_names: &[Strin
 
         let lower = camel_to_snake(struct_name);
         base_quantity_matches += &format!(
-            "    pub fn extract_{lower}(&self) -> Result<{struct_name}, String> {{\n        match self {{\n            Quantity::{struct_name}Quantity(v) => Ok(*v),\n            _ => Err(\"Cannot extract {struct_name} from Quantity enum\".into()),\n        }}\n    }}\n\n",
+            "    pub fn extract_{lower}(&self) -> Result<{struct_name}, String> {{
+        match self {{
+            Quantity::{struct_name}Quantity(v) => Ok(*v),
+            _ => Err(\"Cannot extract {struct_name} from Quantity enum\".into()),
+        }}
+    }}\n\n",
         );
 
         first = false;
@@ -377,7 +280,7 @@ fn write_quantity_code(template: &str, files: &[String], quantity_names: &[Strin
         }
     }
 
-    template
+    let generated = template
         .replace("// __QUANTITY_VARIANTS__", &quantity_variants)
         .replace("// __QUANTITY_TO_VARIANTS__", &quantity_to_variants)
         .replace("// __QUANTITY_FMT_MATCHES__", &quantity_fmt_matches)
@@ -396,10 +299,16 @@ fn write_quantity_code(template: &str, files: &[String], quantity_names: &[Strin
         .replace("// __BASE_QUANTITY_MATCHES__", &base_quantity_matches)
         .replace("// __ADD_QUANTITY_MATCHES__", &add_matches)
         .replace("// __SUB_QUANTITY_MATCHES__", &sub_matches)
-        .replace("// __QUANTITY_SQRTS__", &sqrt_matches)
+        .replace("// __QUANTITY_SQRTS__", &sqrt_matches);
+
+    let mut f = File::create(dest_path).expect("Could not create output quantities.rs");
+    f.write_all(generated.as_bytes())
+        .expect("Could not write quantities.rs");
 }
 
-fn write_vector_code(template: &str, quantity_names: &[String]) -> String {
+fn write_vector_code(dest_path: &PathBuf, quantity_names: &[String], template_path: String) {
+    let template =
+        fs::read_to_string(template_path).expect("Failed to read vector3_py.template.rs");
     let mut raw_interfaces = String::new();
     for struct_name in quantity_names {
         let lower = camel_to_snake(struct_name);
@@ -427,10 +336,15 @@ fn write_vector_code(template: &str, quantity_names: &[String]) -> String {
         raw_interfaces += "\n        }";
         raw_interfaces += "\n    }";
     }
-    template.replace("//__RAW_INTERFACE__", &raw_interfaces)
+    let generated = template.replace("//__RAW_INTERFACE__", &raw_interfaces);
+    let mut f = File::create(dest_path).expect("Could not create output vector3_py.rs");
+    f.write_all(generated.as_bytes())
+        .expect("Could not write vector3_py.rs");
 }
 
-fn write_matrix_code(template: &str, quantity_names: &[String]) -> String {
+fn write_matrix_code(dest_path: &PathBuf, quantity_names: &[String], template_path: String) {
+    let template =
+        fs::read_to_string(template_path).expect("Failed to read matrix3_py.template.rs");
     let mut raw_interfaces = String::new();
     for struct_name in quantity_names {
         let lower = camel_to_snake(struct_name);
@@ -470,13 +384,17 @@ fn write_matrix_code(template: &str, quantity_names: &[String]) -> String {
         raw_interfaces += "\n        }";
         raw_interfaces += "\n    }";
     }
-    template.replace("//__RAW_INTERFACE__", &raw_interfaces)
+    let generated = template.replace("//__RAW_INTERFACE__", &raw_interfaces);
+    let mut f = File::create(dest_path).expect("Could not create output matrix3_py.rs");
+    f.write_all(generated.as_bytes())
+        .expect("Could not write matrix3_py.rs");
 }
 
 fn write_module_definition(
+    dest_path: &PathBuf,
     quantity_names: &[String],
-    aliases: &[(String, String, String, String)],
-) -> String {
+    aliases: Vec<(String, String, String, String)>,
+) {
     let mut module_src = String::from(
         "#[pymodule]\n\
          pub fn unitforge(_py: Python<'_>, m: Bound<PyModule>) -> PyResult<()> {\n\
@@ -499,41 +417,5 @@ fn write_module_definition(
         ));
     }
     module_src.push_str("    Ok(())\n}\n");
-    module_src
-}
-
-fn deps_for_quantities(ctx: &Context) -> Vec<String> {
-    let mut deps = Vec::new();
-    deps.push("quantities.template.rs".to_string());
-    for file in &ctx.quantity_files {
-        deps.push(file.rel_path.clone());
-    }
-    if let Some(relations) = &ctx.relations {
-        deps.push(relations.rel_path.clone());
-    }
-    deps
-}
-
-fn deps_for_vector_matrix(ctx: &Context) -> Vec<String> {
-    let mut deps = Vec::new();
-    for file in &ctx.quantity_files {
-        deps.push(file.rel_path.clone());
-    }
-    deps
-}
-
-fn deps_for_python_module_definition(ctx: &Context) -> Vec<String> {
-    let mut deps = Vec::new();
-    for file in &ctx.quantity_files {
-        deps.push(file.rel_path.clone());
-    }
-    deps
-}
-
-fn dependency_consts(paths: &[String]) -> String {
-    let mut result = String::new();
-    for path in paths {
-        result.push_str(&format!("const _: &str = include_str!(\"{}\");\n", path));
-    }
-    result
+    fs::write(dest_path, module_src).expect("Could not write python_module_definition.rs")
 }

{unitforge-0.3.8 → unitforge-0.3.10}/src/lib.rs

@@ -5,13 +5,13 @@ pub use impl_macros::*;
 pub mod prelude;
 mod relations;
 
-unitforge_macros::generate_quantities!();
+include!(concat!(env!("OUT_DIR"), "/quantities.rs"));
 #[cfg(feature = "pyo3")]
-unitforge_macros::generate_vector3_py!();
+include!(concat!(env!("OUT_DIR"), "/vector3_py.rs"));
 #[cfg(feature = "pyo3")]
-unitforge_macros::generate_matrix3_py!();
+include!(concat!(env!("OUT_DIR"), "/matrix3_py.rs"));
 #[cfg(feature = "pyo3")]
-unitforge_macros::generate_python_module_definition!();
+include!(concat!(env!("OUT_DIR"), "/python_module_definition.rs"));
 
 pub use prelude::*;
 
@@ -54,6 +54,8 @@ pub mod quantities {
     pub use inverse_stress::*;
     pub mod mass;
     pub use mass::*;
+    pub mod mass_div_time_squared_volume;
+    pub use mass_div_time_squared_volume::*;
     pub mod mass_per_distance;
     pub use mass_per_distance::*;
     pub mod force_distance;

unitforge-0.3.10/src/quantities/mass_div_time_squared_volume.rs

@@ -0,0 +1,43 @@
+use crate::impl_macros::macros::*;
+use crate::prelude::*;
+use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
+use num_traits::identities::Zero;
+use num_traits::{Float, FromPrimitive};
+#[cfg(feature = "pyo3")]
+use pyo3::pyclass;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
+use std::fmt;
+use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+#[cfg(feature = "strum")]
+use strum_macros::EnumIter;
+
+#[cfg_attr(feature = "strum", derive(EnumIter))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, PartialEq, Debug)]
+#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int))]
+pub enum MassDivTimeSquaredVolumeUnit {
+    kg_ssqmq,
+}
+
+impl PhysicsUnit for MassDivTimeSquaredVolumeUnit {
+    fn name(&self) -> &str {
+        match &self {
+            MassDivTimeSquaredVolumeUnit::kg_ssqmq => "kg/s²m³",
+        }
+    }
+
+    fn base_per_x(&self) -> (f64, i32) {
+        match self {
+            MassDivTimeSquaredVolumeUnit::kg_ssqmq => (1., 0),
+        }
+    }
+}
+
+impl_quantity!(
+    MassDivTimeSquaredVolume,
+    MassDivTimeSquaredVolumeUnit,
+    [MassDivTimeSquaredVolumeUnit::kg_ssqmq]
+);
+impl_div_with_self_to_f64!(MassDivTimeSquaredVolume);

{unitforge-0.3.8 → unitforge-0.3.10}/src/relations.rs

@@ -50,10 +50,13 @@ impl_mul_relation_with_other!(Area, Density, MassPerDistance);
 impl_mul_relation_with_other!(MassPerDistance, Acceleration, Stiffness);
 impl_mul_relation_with_other!(Stiffness, AreaOfMoment, ForceVolume);
 impl_mul_relation_with_other!(RotationalStiffness, Angle, ForceDistance);
-impl_mul_relation_with_other!(InverseArea, Volume, Distance);
+impl_mul_relation_with_other!(AngularAcceleration, Density, MassDivTimeSquaredVolume);
+impl_mul_relation_with_other!(MassDivTimeSquaredVolume, Area, Stress);
 impl_mul_relation_with_other!(Force, Volume, ForceVolume);
+impl_mul_relation_with_other!(Velocity, AngularVelocity, Acceleration);
 
 impl_mul_relation_with_self!(Distance, Area);
 impl_mul_relation_with_self!(Area, AreaOfMoment);
 impl_mul_relation_with_self!(InverseDistance, InverseArea);
 impl_mul_relation_with_self!(Stress, StressSquared);
+impl_mul_relation_with_self!(AngularVelocity, AngularAcceleration);

unitforge-0.3.8/unitforge_macros/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "unitforge_macros"
-version = "0.3.8"
-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"
-license = "MIT"
-repository = "https://gitlab.com/henrikjstromberg/unitforge"
-keywords = ["units", "quantities", "simulation", "physics"]
-
-[lib]
-proc-macro = true
-
-[dependencies]
-regex = "1.11.1"