polyxml 0.19.0__tar.gz → 0.19.2__tar.gz

{polyxml-0.19.0 → polyxml-0.19.2}/Cargo.lock

@@ -549,7 +549,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.19.0"
+version = "0.19.2"
 dependencies = [
  "criterion",
  "heck",
@@ -567,14 +567,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.19.0"
+version = "0.19.2"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.19.0"
+version = "0.19.2"
 dependencies = [
  "clap",
  "glob",
@@ -588,7 +588,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.19.0"
+version = "0.19.2"
 dependencies = [
  "napi",
  "napi-build",
@@ -598,7 +598,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.19.0"
+version = "0.19.2"
 dependencies = [
  "lexical-core",
  "polyxml",

{polyxml-0.19.0 → polyxml-0.19.2}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/polyxml-core", "crates/polyxml-python"]
 
 [workspace.package]
-version = "0.19.0"
+version = "0.19.2"
 edition = "2021"
 rust-version = "1.80"
 license = "MIT"

{polyxml-0.19.0 → polyxml-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.19.0
+Version: 0.19.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyxml-0.19.0 → polyxml-0.19.2}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -391,8 +391,8 @@ impl CSharpCodegen {
         if self.options.emit_json_attributes {
             writeln!(
                 out,
-                "{}[JsonConverter(typeof(JsonStringEnumConverter))]",
-                indent
+                "{}[JsonConverter(typeof(JsonStringEnumConverter<{}>))]",
+                indent, enum_name
             )
             .unwrap();
         }
@@ -669,7 +669,7 @@ impl CSharpCodegen {
                 || f.nillable
                 || (f.cardinality.is_list() && f.cardinality.min_occurs == 0);
             let default_arg = if is_opt {
-                "default".to_string()
+                format!("default({})", field_type)
             } else {
                 format!("default({})!", field_type)
             };

{polyxml-0.19.0 → polyxml-0.19.2}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -204,8 +204,19 @@ impl PythonCodegen {
         if let Some(ref header) = self.options.custom_header {
             let trimmed = header.trim();
             if !trimmed.is_empty() {
-                out.push_str(trimmed);
-                out.push_str("\n\n");
+                for line in trimmed.lines() {
+                    let line_trimmed = line.trim_start();
+                    if line_trimmed.starts_with("//") {
+                        let content = line_trimmed.strip_prefix("//").unwrap_or("");
+                        out.push('#');
+                        out.push_str(content);
+                        out.push('\n');
+                    } else {
+                        out.push_str(line);
+                        out.push('\n');
+                    }
+                }
+                out.push('\n');
             }
         }
 

{polyxml-0.19.0 → polyxml-0.19.2}/crates/polyxml-core/src/json.rs

@@ -27,6 +27,15 @@ impl From<&PolyValue> for JsonValue {
                 }
                 JsonValue::Object(map)
             }
+            PolyValue::Record { schema, values } => {
+                let mut map = serde_json::Map::with_capacity(schema.fields.len());
+                for (idx, field) in schema.fields.iter().enumerate() {
+                    if let Some(Some(v)) = values.get(idx) {
+                        map.insert(field.name.clone(), JsonValue::from(v));
+                    }
+                }
+                JsonValue::Object(map)
+            }
         }
     }
 }
@@ -67,17 +76,25 @@ pub fn poly_value_to_json_value(
     schema: &ModelSchema,
     by_alias: bool,
 ) -> JsonValue {
+    let get_field = |idx: usize, name: &str| -> Option<&PolyValue> {
+        match val {
+            PolyValue::Record { values, .. } => values.get(idx).and_then(|v| v.as_ref()),
+            PolyValue::Object(map) => map.get(name),
+            _ => None,
+        }
+    };
+
     match val {
-        PolyValue::Object(map) => {
+        PolyValue::Record { .. } | PolyValue::Object(_) => {
             let mut json_map = serde_json::Map::with_capacity(schema.fields.len());
-            for field in &schema.fields {
+            for (idx, field) in schema.fields.iter().enumerate() {
                 let key = if by_alias {
                     std::str::from_utf8(&field.xml_name).unwrap_or(field.name.as_str())
                 } else {
                     field.name.as_str()
                 };
 
-                if let Some(field_val) = map.get(&field.name) {
+                if let Some(field_val) = get_field(idx, &field.name) {
                     let converted = match &field.val_type {
                         ValueType::Nested(nested_schema) => {
                             if field_val.is_null() {

{polyxml-0.19.0 → polyxml-0.19.2}/crates/polyxml-core/src/parser.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::sync::Arc;
 
 use quick_xml::events::{BytesStart, Event};
@@ -48,19 +47,10 @@ impl StackFrame {
     }
 
     fn finish(mut self) -> Result<PolyValue> {
-        let mut obj = HashMap::with_capacity(self.schema.fields.len());
-
-        for (idx, field) in self.schema.fields.iter().enumerate() {
-            if let Some(val) = self.values.get_mut(idx).and_then(|v| v.take()) {
-                obj.insert(field.name.clone(), val);
-            }
-        }
-
         if !self.list_values.is_empty() {
             for (idx, list_opt) in self.list_values.into_iter().enumerate() {
                 if let Some(list) = list_opt {
-                    let field = &self.schema.fields[idx];
-                    obj.insert(field.name.clone(), PolyValue::List(list));
+                    self.values[idx] = Some(PolyValue::List(list));
                 }
             }
         }
@@ -72,12 +62,12 @@ impl StackFrame {
                     match &field.val_type {
                         ValueType::Scalar(st) => {
                             let val = ValueConverter::parse_scalar(st, text_buf, &field.name)?;
-                            obj.insert(field.name.clone(), val);
+                            self.values[text_idx] = Some(val);
                         }
                         ValueType::List(inner) => {
                             if let ValueType::Scalar(st) = &**inner {
                                 let val = ValueConverter::parse_scalar(st, text_buf, &field.name)?;
-                                obj.insert(field.name.clone(), PolyValue::List(vec![val]));
+                                self.values[text_idx] = Some(PolyValue::List(vec![val]));
                             }
                         }
                         _ => {}
@@ -86,7 +76,10 @@ impl StackFrame {
             }
         }
 
-        Ok(PolyValue::Object(obj))
+        Ok(PolyValue::Record {
+            schema: self.schema,
+            values: self.values.into_vec().into_boxed_slice(),
+        })
     }
 }
 
@@ -313,12 +306,24 @@ impl XmlDeserializer {
                     if unknown_depth > 0 {
                         continue;
                     }
-                    let unescaped = quick_xml::escape::unescape(e.as_ref())?;
-                    if active_scalar_field.is_some() {
-                        text_buf.extend_from_slice(unescaped.as_bytes());
-                    } else if let Some(frame) = stack.last_mut() {
-                        if let Some(ref mut tb) = frame.frame_text_buf {
-                            tb.extend_from_slice(unescaped.as_bytes());
+                    let raw = e.as_ref();
+                    let raw_bytes = raw.as_bytes();
+                    if memchr::memchr(b'&', raw_bytes).is_none() {
+                        if active_scalar_field.is_some() {
+                            text_buf.extend_from_slice(raw_bytes);
+                        } else if let Some(frame) = stack.last_mut() {
+                            if let Some(ref mut tb) = frame.frame_text_buf {
+                                tb.extend_from_slice(raw_bytes);
+                            }
+                        }
+                    } else {
+                        let unescaped = quick_xml::escape::unescape(raw)?;
+                        if active_scalar_field.is_some() {
+                            text_buf.extend_from_slice(unescaped.as_bytes());
+                        } else if let Some(frame) = stack.last_mut() {
+                            if let Some(ref mut tb) = frame.frame_text_buf {
+                                tb.extend_from_slice(unescaped.as_bytes());
+                            }
                         }
                     }
                 }

{polyxml-0.19.0 → polyxml-0.19.2}/crates/polyxml-core/src/serializer.rs

@@ -212,12 +212,20 @@ impl XmlSerializer {
         is_root: bool,
         element_ns: Option<&str>,
     ) -> Result<()> {
-        let obj = match value {
-            PolyValue::Object(o) => o,
+        match value {
+            PolyValue::Record { .. } | PolyValue::Object(_) => {}
             _ => {
                 return Err(PolyXmlError::SerializationError(
-                    "Expected Object value for model".into(),
-                ))
+                    "Expected Object or Record value for model".into(),
+                ));
+            }
+        }
+
+        let get_field = |idx: usize, name: &str| -> Option<&PolyValue> {
+            match value {
+                PolyValue::Record { values, .. } => values.get(idx).and_then(|v| v.as_ref()),
+                PolyValue::Object(o) => o.get(name),
+                _ => None,
             }
         };
 
@@ -245,9 +253,9 @@ impl XmlSerializer {
         }
 
         // 1. Collect and write attributes
-        for field in &schema.fields {
+        for (idx, field) in schema.fields.iter().enumerate() {
             if field.kind == FieldKind::Attribute {
-                if let Some(val) = obj.get(&field.name) {
+                if let Some(val) = get_field(idx, &field.name) {
                     if !val.is_null() {
                         let local_attr = std::str::from_utf8(&field.xml_name)?;
                         let attr_name = if let Some(ctx) = ns_ctx {
@@ -271,7 +279,7 @@ impl XmlSerializer {
         // 2. Write text content if present
         if let Some(text_idx) = schema.text_field {
             let field = &schema.fields[text_idx];
-            if let Some(val) = obj.get(&field.name) {
+            if let Some(val) = get_field(text_idx, &field.name) {
                 let mut buf = [0u8; lexical_core::BUFFER_SIZE];
                 if let Some(text_content) = Self::format_scalar_to(val, &mut buf) {
                     if !text_content.is_empty() {
@@ -295,9 +303,9 @@ impl XmlSerializer {
         }
 
         // 3. Write child elements
-        for field in &schema.fields {
+        for (idx, field) in schema.fields.iter().enumerate() {
             if field.kind == FieldKind::Element {
-                if let Some(val) = obj.get(&field.name) {
+                if let Some(val) = get_field(idx, &field.name) {
                     if val.is_null() {
                         continue;
                     }

polyxml-0.19.2/crates/polyxml-core/src/value.rs

@@ -0,0 +1,167 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::schema::ModelSchema;
+
+#[derive(Debug, Clone)]
+pub enum PolyValue {
+    Null,
+    Bool(bool),
+    Int(i64),
+    Float(f64),
+    String(String),
+    List(Vec<PolyValue>),
+    Object(HashMap<String, PolyValue>),
+    Record {
+        schema: Arc<ModelSchema>,
+        values: Box<[Option<PolyValue>]>,
+    },
+}
+
+impl PartialEq for PolyValue {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (PolyValue::Null, PolyValue::Null) => true,
+            (PolyValue::Bool(a), PolyValue::Bool(b)) => a == b,
+            (PolyValue::Int(a), PolyValue::Int(b)) => a == b,
+            (PolyValue::Float(a), PolyValue::Float(b)) => a == b,
+            (PolyValue::String(a), PolyValue::String(b)) => a == b,
+            (PolyValue::List(a), PolyValue::List(b)) => a == b,
+            (PolyValue::Object(a), PolyValue::Object(b)) => a == b,
+            (
+                PolyValue::Record {
+                    schema: s1,
+                    values: v1,
+                },
+                PolyValue::Record {
+                    schema: s2,
+                    values: v2,
+                },
+            ) => (Arc::ptr_eq(s1, s2) || s1.name == s2.name) && v1 == v2,
+            (PolyValue::Record { schema, values }, PolyValue::Object(map))
+            | (PolyValue::Object(map), PolyValue::Record { schema, values }) => {
+                for (idx, field) in schema.fields.iter().enumerate() {
+                    let rec_val = values.get(idx).and_then(|v| v.as_ref());
+                    let map_val = map.get(&field.name);
+                    if rec_val != map_val {
+                        return false;
+                    }
+                }
+                true
+            }
+            _ => false,
+        }
+    }
+}
+
+impl PolyValue {
+    pub fn is_null(&self) -> bool {
+        matches!(self, PolyValue::Null)
+    }
+
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            PolyValue::String(s) => Some(s.as_str()),
+            _ => None,
+        }
+    }
+
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            PolyValue::Int(i) => Some(*i),
+            _ => None,
+        }
+    }
+
+    pub fn as_f64(&self) -> Option<f64> {
+        match self {
+            PolyValue::Float(f) => Some(*f),
+            _ => None,
+        }
+    }
+
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            PolyValue::Bool(b) => Some(*b),
+            _ => None,
+        }
+    }
+
+    pub fn as_list(&self) -> Option<&[PolyValue]> {
+        match self {
+            PolyValue::List(l) => Some(l.as_slice()),
+            _ => None,
+        }
+    }
+
+    pub fn as_object(&self) -> Option<&HashMap<String, PolyValue>> {
+        match self {
+            PolyValue::Object(o) => Some(o),
+            _ => None,
+        }
+    }
+
+    pub fn as_record(&self) -> Option<(&Arc<ModelSchema>, &[Option<PolyValue>])> {
+        match self {
+            PolyValue::Record { schema, values } => Some((schema, values.as_ref())),
+            _ => None,
+        }
+    }
+
+    pub fn get_by_index(&self, idx: usize) -> Option<&PolyValue> {
+        match self {
+            PolyValue::Record { values, .. } => values.get(idx).and_then(|v| v.as_ref()),
+            _ => None,
+        }
+    }
+
+    pub fn get(&self, key: &str) -> Option<&PolyValue> {
+        match self {
+            PolyValue::Object(o) => o.get(key),
+            PolyValue::Record { schema, values } => {
+                let idx = schema.fields.iter().position(|f| f.name == key)?;
+                values.get(idx).and_then(|v| v.as_ref())
+            }
+            _ => None,
+        }
+    }
+
+    pub fn to_hash_map(&self) -> Option<HashMap<String, PolyValue>> {
+        match self {
+            PolyValue::Object(o) => Some(o.clone()),
+            PolyValue::Record { schema, values } => {
+                let mut map = HashMap::with_capacity(schema.fields.len());
+                for (idx, field) in schema.fields.iter().enumerate() {
+                    if let Some(Some(val)) = values.get(idx) {
+                        map.insert(field.name.clone(), val.clone());
+                    }
+                }
+                Some(map)
+            }
+            _ => None,
+        }
+    }
+
+    /// Serialize this PolyValue into raw JSON bytes.
+    pub fn to_json(&self, indent: Option<usize>) -> crate::error::Result<Vec<u8>> {
+        let json_val = serde_json::Value::from(self);
+        match indent {
+            Some(spaces) if spaces > 0 => {
+                let indent_str = " ".repeat(spaces);
+                let formatter =
+                    serde_json::ser::PrettyFormatter::with_indent(indent_str.as_bytes());
+                let mut buf = Vec::new();
+                let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
+                serde::Serialize::serialize(&json_val, &mut ser)?;
+                Ok(buf)
+            }
+            _ => Ok(serde_json::to_vec(&json_val)?),
+        }
+    }
+
+    /// Deserialize raw JSON bytes into a dynamic PolyValue without a schema.
+    pub fn from_json(json_bytes: &[u8]) -> crate::error::Result<Self> {
+        let json_val: serde_json::Value = serde_json::from_slice(json_bytes)?;
+        Ok(PolyValue::from(json_val))
+    }
+}

{polyxml-0.19.0 → polyxml-0.19.2}/crates/polyxml-core/tests/test_csharp_codegen.rs

@@ -180,7 +180,7 @@ fn test_csharp_records_and_enums_generation() {
 
     assert!(cs_code.contains("using System.Text.Json.Serialization;"));
     assert!(cs_code.contains("namespace Crm.Models;"));
-    assert!(cs_code.contains("[JsonConverter(typeof(JsonStringEnumConverter))]"));
+    assert!(cs_code.contains("[JsonConverter(typeof(JsonStringEnumConverter<OrderStatus>))]"));
     assert!(cs_code.contains("public enum OrderStatus"));
     assert!(cs_code.contains("[XmlEnum(\"pending\")]"));
     assert!(cs_code.contains("Pending,"));

{polyxml-0.19.0 → polyxml-0.19.2}/crates/polyxml-python/src/lib.rs

@@ -12,11 +12,14 @@ use std::sync::{Arc, RwLock};
 use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType};
 use polyxml::value::PolyValue;
 
+use smallvec::SmallVec;
+
 type PyObject = Py<PyAny>;
 
 struct CachedFieldMeta {
     py_string: Py<PyString>,
     is_init: bool,
+    #[allow(dead_code)]
     is_kw_only: bool,
     py_type: Option<PyObject>,
 }
@@ -25,6 +28,8 @@ struct CachedSchemaMeta {
     schema: Arc<ModelSchema>,
     py_cls: PyObject,
     is_dataclass: bool,
+    all_init: bool,
+    kwnames: Option<Py<PyTuple>>,
     fields: Vec<CachedFieldMeta>,
 }
 
@@ -394,10 +399,24 @@ fn get_or_create_schema_meta<'py>(cls: &Bound<'py, PyType>) -> PyResult<Arc<Cach
     let (schema, cached_fields) = extract_schema_from_class(cls)?;
     let py_cls_obj: PyObject = cls.clone().into_any().unbind();
 
+    let all_init =
+        is_dataclass && !cached_fields.is_empty() && cached_fields.iter().all(|f| f.is_init);
+    let kwnames = if all_init {
+        let py_strings: Vec<Bound<'py, PyString>> = cached_fields
+            .iter()
+            .map(|f| f.py_string.bind(cls.py()).clone())
+            .collect();
+        PyTuple::new(cls.py(), &py_strings).ok().map(|t| t.unbind())
+    } else {
+        None
+    };
+
     let meta = Arc::new(CachedSchemaMeta {
         schema: Arc::clone(&schema),
         py_cls: py_cls_obj,
         is_dataclass,
+        all_init,
+        kwnames,
         fields: cached_fields,
     });
 
@@ -559,7 +578,10 @@ fn poly_value_to_py<'py>(
                 Ok(py_list.into_any().unbind())
             }
         }
-        PolyValue::Object(map) => {
+        PolyValue::Record {
+            schema: rec_schema,
+            values,
+        } => {
             let meta_opt = if let ValueType::Nested(ref s) = val_type {
                 lookup_cached_meta(&s.name)
             } else {
@@ -573,40 +595,194 @@ fn poly_value_to_py<'py>(
 
             if let Some(ref target_cls) = effective_cls {
                 if let ValueType::Nested(ref schema) = val_type {
-                    // Method 1: Fast Positional Tuple Construction for Dataclasses when all fields are present AND all fields are is_init and not kw_only
+                    // Method 1: Python 3.12+ Vectorcall for Dataclasses
                     if let Some(ref meta) = meta_opt {
-                        if meta.is_dataclass
-                            && schema.fields.len() == map.len()
-                            && meta.fields.iter().all(|f| f.is_init && !f.is_kw_only)
-                        {
-                            let mut args_vec = Vec::with_capacity(schema.fields.len());
-                            let mut all_found = true;
-                            for (i, field) in schema.fields.iter().enumerate() {
-                                if let Some(field_val) = map.get(&field.name) {
-                                    let field_cls = if let ValueType::Nested(ref s) = field.val_type
-                                    {
-                                        lookup_py_class(py, &s.name)
+                        if meta.is_dataclass && meta.all_init && !meta.fields.is_empty() {
+                            if let Some(ref kwnames) = meta.kwnames {
+                                let mut args_ptrs: SmallVec<[*mut pyo3::ffi::PyObject; 16]> =
+                                    SmallVec::with_capacity(schema.fields.len());
+                                let mut py_vals: SmallVec<[PyObject; 16]> =
+                                    SmallVec::with_capacity(schema.fields.len());
+                                let mut all_found = true;
+
+                                for (i, field) in schema.fields.iter().enumerate() {
+                                    if let Some(Some(field_val)) = values.get(i) {
+                                        let field_cls =
+                                            if let ValueType::Nested(ref s) = field.val_type {
+                                                lookup_py_class(py, &s.name)
+                                            } else {
+                                                None
+                                            };
+                                        let f_meta = meta.fields.get(i);
+                                        let py_val = poly_value_to_py(
+                                            py,
+                                            field_val,
+                                            &field.val_type,
+                                            field_cls.as_ref(),
+                                            f_meta,
+                                        )?;
+                                        args_ptrs.push(py_val.as_ptr());
+                                        py_vals.push(py_val);
                                     } else {
-                                        None
-                                    };
-                                    let f_meta = meta.fields.get(i);
-                                    let py_val = poly_value_to_py(
-                                        py,
-                                        field_val,
-                                        &field.val_type,
-                                        field_cls.as_ref(),
-                                        f_meta,
-                                    )?;
-                                    args_vec.push(py_val);
+                                        all_found = false;
+                                        break;
+                                    }
+                                }
+
+                                if all_found && args_ptrs.len() == schema.fields.len() {
+                                    unsafe {
+                                        let res_ptr = pyo3::ffi::PyObject_Vectorcall(
+                                            target_cls.as_ptr(),
+                                            args_ptrs.as_ptr(),
+                                            0,
+                                            kwnames.as_ptr(),
+                                        );
+                                        if !res_ptr.is_null() {
+                                            return Ok(Bound::from_owned_ptr(py, res_ptr).unbind());
+                                        } else {
+                                            return Err(PyErr::fetch(py));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    // Method 2: Keyword arguments with init=False post-init support
+                    let kwargs = PyDict::new(py);
+                    let mut post_init_fields: Vec<(Py<PyString>, PyObject)> = Vec::new();
+
+                    for (i, field) in schema.fields.iter().enumerate() {
+                        if let Some(Some(field_val)) = values.get(i) {
+                            let field_cls = if let ValueType::Nested(ref s) = field.val_type {
+                                lookup_py_class(py, &s.name)
+                            } else {
+                                None
+                            };
+                            let f_meta = meta_opt.as_ref().and_then(|m| m.fields.get(i));
+                            let is_init = f_meta.map(|f| f.is_init).unwrap_or(true);
+                            let py_val = poly_value_to_py(
+                                py,
+                                field_val,
+                                &field.val_type,
+                                field_cls.as_ref(),
+                                f_meta,
+                            )?;
+                            if let Some(meta) = f_meta {
+                                if is_init {
+                                    kwargs.set_item(meta.py_string.bind(py), py_val)?;
                                 } else {
-                                    all_found = false;
-                                    break;
+                                    post_init_fields.push((meta.py_string.clone_ref(py), py_val));
                                 }
+                            } else if is_init {
+                                kwargs.set_item(&field.name, py_val)?;
+                            } else {
+                                post_init_fields
+                                    .push((PyString::new(py, &field.name).unbind(), py_val));
                             }
-                            if all_found {
-                                let tuple = pyo3::types::PyTuple::new(py, &args_vec)?;
-                                if let Ok(instance) = target_cls.call1(tuple) {
-                                    return Ok(instance.unbind());
+                        }
+                    }
+                    let instance = target_cls.call((), Some(&kwargs))?;
+                    for (attr_name, val) in post_init_fields {
+                        instance.setattr(&attr_name, val)?;
+                    }
+                    return Ok(instance.unbind());
+                }
+
+                let dict = PyDict::new(py);
+                for (i, field) in rec_schema.fields.iter().enumerate() {
+                    if let Some(Some(v)) = values.get(i) {
+                        let py_v = poly_value_to_py(
+                            py,
+                            v,
+                            &ValueType::Scalar(ScalarType::Any),
+                            None,
+                            None,
+                        )?;
+                        dict.set_item(&field.name, py_v)?;
+                    }
+                }
+                let instance = target_cls.call((), Some(&dict))?;
+                Ok(instance.unbind())
+            } else {
+                let dict = PyDict::new(py);
+                for (i, field) in rec_schema.fields.iter().enumerate() {
+                    if let Some(Some(v)) = values.get(i) {
+                        let py_v = poly_value_to_py(
+                            py,
+                            v,
+                            &ValueType::Scalar(ScalarType::Any),
+                            None,
+                            None,
+                        )?;
+                        dict.set_item(&field.name, py_v)?;
+                    }
+                }
+                Ok(dict.into_any().unbind())
+            }
+        }
+        PolyValue::Object(map) => {
+            let meta_opt = if let ValueType::Nested(ref s) = val_type {
+                lookup_cached_meta(&s.name)
+            } else {
+                None
+            };
+
+            let effective_cls = match cls {
+                Some(c) => Some(c.clone()),
+                None => meta_opt.as_ref().map(|m| m.py_cls.bind(py).clone()),
+            };
+
+            if let Some(ref target_cls) = effective_cls {
+                if let ValueType::Nested(ref schema) = val_type {
+                    // Method 1: Python 3.12+ Vectorcall for Dataclasses
+                    if let Some(ref meta) = meta_opt {
+                        if meta.is_dataclass && meta.all_init && !meta.fields.is_empty() {
+                            if let Some(ref kwnames) = meta.kwnames {
+                                let mut args_ptrs: SmallVec<[*mut pyo3::ffi::PyObject; 16]> =
+                                    SmallVec::with_capacity(schema.fields.len());
+                                let mut py_vals: SmallVec<[PyObject; 16]> =
+                                    SmallVec::with_capacity(schema.fields.len());
+                                let mut all_found = true;
+
+                                for (i, field) in schema.fields.iter().enumerate() {
+                                    if let Some(field_val) = map.get(&field.name) {
+                                        let field_cls =
+                                            if let ValueType::Nested(ref s) = field.val_type {
+                                                lookup_py_class(py, &s.name)
+                                            } else {
+                                                None
+                                            };
+                                        let f_meta = meta.fields.get(i);
+                                        let py_val = poly_value_to_py(
+                                            py,
+                                            field_val,
+                                            &field.val_type,
+                                            field_cls.as_ref(),
+                                            f_meta,
+                                        )?;
+                                        args_ptrs.push(py_val.as_ptr());
+                                        py_vals.push(py_val);
+                                    } else {
+                                        all_found = false;
+                                        break;
+                                    }
+                                }
+
+                                if all_found && args_ptrs.len() == schema.fields.len() {
+                                    unsafe {
+                                        let res_ptr = pyo3::ffi::PyObject_Vectorcall(
+                                            target_cls.as_ptr(),
+                                            args_ptrs.as_ptr(),
+                                            0,
+                                            kwnames.as_ptr(),
+                                        );
+                                        if !res_ptr.is_null() {
+                                            return Ok(Bound::from_owned_ptr(py, res_ptr).unbind());
+                                        } else {
+                                            return Err(PyErr::fetch(py));
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -679,18 +855,99 @@ fn py_to_poly_value<'py>(
     schema: &ModelSchema,
     meta_opt: Option<&CachedSchemaMeta>,
 ) -> PyResult<PolyValue> {
-    let mut map = HashMap::with_capacity(schema.fields.len());
+    if let Some(meta) = meta_opt {
+        let mut values: Vec<Option<PolyValue>> = vec![None; schema.fields.len()];
 
-    for (i, field) in schema.fields.iter().enumerate() {
-        let val_res = if let Some(meta) = meta_opt {
-            if let Some(f_meta) = meta.fields.get(i) {
+        for (i, field) in schema.fields.iter().enumerate() {
+            let val_res = if let Some(f_meta) = meta.fields.get(i) {
                 obj.getattr(f_meta.py_string.bind(py))
             } else {
                 obj.getattr(field.name.as_str())
+            };
+
+            if let Ok(val) = val_res {
+                if val.is_none() {
+                    values[i] = Some(PolyValue::Null);
+                    continue;
+                }
+
+                match &field.val_type {
+                    ValueType::Scalar(st) => match st {
+                        ScalarType::Int => {
+                            let int_val: i64 = if let Ok(enum_val) = val.getattr("value") {
+                                enum_val.extract()?
+                            } else {
+                                val.extract()?
+                            };
+                            values[i] = Some(PolyValue::Int(int_val));
+                        }
+                        ScalarType::Float => {
+                            let f: f64 = val.extract()?;
+                            values[i] = Some(PolyValue::Float(f));
+                        }
+                        ScalarType::Bool => {
+                            let b: bool = val.extract()?;
+                            values[i] = Some(PolyValue::Bool(b));
+                        }
+                        _ => {
+                            let s: String = if let Ok(enum_val) = val.getattr("value") {
+                                enum_val.str()?.extract()?
+                            } else {
+                                val.str()?.extract()?
+                            };
+                            values[i] = Some(PolyValue::String(s));
+                        }
+                    },
+                    ValueType::List(inner) => {
+                        if let Ok(list) = val.cast::<PyList>() {
+                            let mut poly_items = Vec::with_capacity(list.len());
+                            let child_meta = if let ValueType::Nested(sub_schema) = inner.as_ref() {
+                                lookup_cached_meta(&sub_schema.name)
+                            } else {
+                                None
+                            };
+                            for item in list.iter() {
+                                if let ValueType::Nested(sub_schema) = inner.as_ref() {
+                                    poly_items.push(py_to_poly_value(
+                                        py,
+                                        &item,
+                                        sub_schema,
+                                        child_meta.as_deref(),
+                                    )?);
+                                } else {
+                                    let s: String = if let Ok(enum_val) = item.getattr("value") {
+                                        enum_val.str()?.extract()?
+                                    } else {
+                                        item.str()?.extract()?
+                                    };
+                                    poly_items.push(PolyValue::String(s));
+                                }
+                            }
+                            values[i] = Some(PolyValue::List(poly_items));
+                        }
+                    }
+                    ValueType::Nested(sub_schema) => {
+                        let child_meta = lookup_cached_meta(&sub_schema.name);
+                        values[i] = Some(py_to_poly_value(
+                            py,
+                            &val,
+                            sub_schema,
+                            child_meta.as_deref(),
+                        )?);
+                    }
+                }
             }
-        } else {
-            obj.getattr(field.name.as_str())
-        };
+        }
+        return Ok(PolyValue::Record {
+            schema: Arc::clone(&meta.schema),
+            values: values.into_boxed_slice(),
+        });
+    }
+
+    let mut map = HashMap::with_capacity(schema.fields.len());
+
+    for field in &schema.fields {
+        let val_res = obj.getattr(field.name.as_str());
 
         if let Ok(val) = val_res {
             if val.is_none() {

{polyxml-0.19.0 → polyxml-0.19.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "polyxml"
-version = "0.19.0"
+version = "0.19.2"
 description = "High-performance, polyglot XML data-binding engine built in Rust"
 authors = [
     { name = "Bailey Nguyen", email = "bailey.tan.nguyen@gmail.com" }

polyxml-0.19.0/crates/polyxml-core/src/value.rs

@@ -1,90 +0,0 @@
-use std::collections::HashMap;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum PolyValue {
-    Null,
-    Bool(bool),
-    Int(i64),
-    Float(f64),
-    String(String),
-    List(Vec<PolyValue>),
-    Object(HashMap<String, PolyValue>),
-}
-
-impl PolyValue {
-    pub fn is_null(&self) -> bool {
-        matches!(self, PolyValue::Null)
-    }
-
-    pub fn as_str(&self) -> Option<&str> {
-        match self {
-            PolyValue::String(s) => Some(s.as_str()),
-            _ => None,
-        }
-    }
-
-    pub fn as_i64(&self) -> Option<i64> {
-        match self {
-            PolyValue::Int(i) => Some(*i),
-            _ => None,
-        }
-    }
-
-    pub fn as_f64(&self) -> Option<f64> {
-        match self {
-            PolyValue::Float(f) => Some(*f),
-            _ => None,
-        }
-    }
-
-    pub fn as_bool(&self) -> Option<bool> {
-        match self {
-            PolyValue::Bool(b) => Some(*b),
-            _ => None,
-        }
-    }
-
-    pub fn as_list(&self) -> Option<&[PolyValue]> {
-        match self {
-            PolyValue::List(l) => Some(l.as_slice()),
-            _ => None,
-        }
-    }
-
-    pub fn as_object(&self) -> Option<&HashMap<String, PolyValue>> {
-        match self {
-            PolyValue::Object(o) => Some(o),
-            _ => None,
-        }
-    }
-
-    pub fn get(&self, key: &str) -> Option<&PolyValue> {
-        match self {
-            PolyValue::Object(o) => o.get(key),
-            _ => None,
-        }
-    }
-
-    /// Serialize this PolyValue into raw JSON bytes.
-    pub fn to_json(&self, indent: Option<usize>) -> crate::error::Result<Vec<u8>> {
-        let json_val = serde_json::Value::from(self);
-        match indent {
-            Some(spaces) if spaces > 0 => {
-                let indent_str = " ".repeat(spaces);
-                let formatter =
-                    serde_json::ser::PrettyFormatter::with_indent(indent_str.as_bytes());
-                let mut buf = Vec::new();
-                let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
-                serde::Serialize::serialize(&json_val, &mut ser)?;
-                Ok(buf)
-            }
-            _ => Ok(serde_json::to_vec(&json_val)?),
-        }
-    }
-
-    /// Deserialize raw JSON bytes into a dynamic PolyValue without a schema.
-    pub fn from_json(json_bytes: &[u8]) -> crate::error::Result<Self> {
-        let json_val: serde_json::Value = serde_json::from_slice(json_bytes)?;
-        Ok(PolyValue::from(json_val))
-    }
-}