add aliases hashmap creation and bump version

Author: collerek

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ormar_rust_utils"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "Rust-accelerated utility functions for the ormar ORM"
 license = "MIT"

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ormar-utils"
-version = "0.1.0"
+version = "0.1.1"
 description = "Rust-accelerated utility functions for the ormar ORM"
 readme = "README.md"
 license = { text = "MIT" }
@@ -35,7 +35,7 @@ features = ["pyo3/extension-module"]
 
 [tool.poetry]
 name = "ormar-utils"
-version = "0.1.0"
+version = "0.1.1"
 description = "Rust-accelerated utility functions for the ormar ORM"
 authors = ["Radosław Drążkiewicz <collerek@gmail.com>"]
 package-mode = false

src/alias_utils.rs

@@ -0,0 +1,76 @@
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+use std::collections::HashMap;
+
+/// Build a reverse mapping from alias -> field_name given a forward mapping
+/// of field_name -> alias. If a field has no alias (alias == field_name),
+/// it still gets an identity entry.
+///
+/// This is called once per model class and cached.
+#[pyfunction]
+pub fn build_reverse_alias_map<'py>(
+    py: Python<'py>,
+    field_alias_map: &Bound<'py, PyDict>,
+) -> PyResult<Bound<'py, PyDict>> {
+    let result = PyDict::new(py);
+    for (key, value) in field_alias_map.iter() {
+        let field_name: String = key.extract()?;
+        let alias: String = value.extract()?;
+        // Map alias -> field_name
+        result.set_item(&alias, &field_name)?;
+        // Also keep field_name -> field_name for identity lookups
+        if alias != field_name {
+            result.set_item(&field_name, &field_name)?;
+        }
+    }
+    Ok(result)
+}
+
+/// Translate dict keys from field names to their database aliases.
+/// Takes the dict to translate and a field_name->alias mapping.
+/// Returns a new dict with aliased keys.
+#[pyfunction]
+pub fn translate_columns_to_aliases<'py>(
+    py: Python<'py>,
+    new_kwargs: &Bound<'py, PyDict>,
+    field_to_alias: &Bound<'py, PyDict>,
+) -> PyResult<Bound<'py, PyDict>> {
+    let result = PyDict::new(py);
+    // Pre-extract the mapping into a Rust HashMap for fast lookup
+    let mut alias_map: HashMap<String, String> = HashMap::new();
+    for (k, v) in field_to_alias.iter() {
+        let key: String = k.extract()?;
+        let val: String = v.extract()?;
+        alias_map.insert(key, val);
+    }
+
+    for (key, value) in new_kwargs.iter() {
+        let field_name: String = key.extract()?;
+        if let Some(alias) = alias_map.get(&field_name) {
+            result.set_item(alias, value)?;
+        } else {
+            result.set_item(key, value)?;
+        }
+    }
+    Ok(result)
+}
+
+/// Translate dict keys from database aliases to field names.
+/// Takes the dict to translate and an alias->field_name mapping.
+/// Returns a new dict with field name keys.
+#[pyfunction]
+pub fn translate_aliases_to_columns<'py>(
+    py: Python<'py>,
+    new_kwargs: &Bound<'py, PyDict>,
+    alias_to_field: &Bound<'py, PyDict>,
+) -> PyResult<Bound<'py, PyDict>> {
+    let result = PyDict::new(py);
+    for (key, value) in new_kwargs.iter() {
+        if let Some(field_name) = alias_to_field.get_item(&key)? {
+            result.set_item(field_name, value)?;
+        } else {
+            result.set_item(key, value)?;
+        }
+    }
+    Ok(result)
+}

src/lib.rs

@@ -1,3 +1,4 @@
+mod alias_utils;
 mod extract_columns;
 mod group_related;
 mod hash_item;
@@ -24,5 +25,8 @@ fn ormar_rust_utils(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(prepare_save::prepare_model_to_save, m)?)?;
     m.add_function(wrap_pyfunction!(merge_instances::group_by_pk, m)?)?;
     m.add_function(wrap_pyfunction!(merge_items::plan_merge_items_lists, m)?)?;
+    m.add_function(wrap_pyfunction!(alias_utils::build_reverse_alias_map, m)?)?;
+    m.add_function(wrap_pyfunction!(alias_utils::translate_columns_to_aliases, m)?)?;
+    m.add_function(wrap_pyfunction!(alias_utils::translate_aliases_to_columns, m)?)?;
     Ok(())
 }