polyxml 0.24.0__tar.gz → 0.25.0__tar.gz

{polyxml-0.24.0 → polyxml-0.25.0}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "criterion",
  "heck",
@@ -628,14 +628,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "clap",
  "glob",
@@ -649,7 +649,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -659,7 +659,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -669,7 +669,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.24.0"
+version = "0.25.0"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.24.0 → polyxml-0.25.0}/Cargo.toml

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

{polyxml-0.24.0 → polyxml-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.24.0
+Version: 0.25.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -62,9 +62,9 @@ pip install polyxml
 
 ## Features
 
-- **⚡ Blazing Fast**: 16x faster deserialization and 38x faster serialization than standard Python tools.
-- **🌊 Streaming `iterparse()`**: Parse multi-gigabyte XML files with O(1) constant memory (<5 MB RAM).
-- **📦 Zero-GIL Binary Serialization**: Native `dumps_binary()` and `loads_binary()` using MessagePack (`msgspec`), up to 12.4x faster than pickle.
+- **⚡ Fast typed XML binding**: 10.0x faster deserialization and 23.5x faster serialization than `xsdata` on the [10,000-item catalog benchmark](../../benchmarks/python/results.md).
+- **🌊 Streaming `iterparse()`**: Process records incrementally; measure memory on your own document structure.
+- **📦 Binary Serialization**: Native `dumps_binary()` and `loads_binary()` using MessagePack (`msgspec`).
 - **🎯 Full Type Support**: Dataclasses and Pydantic v2 models with zero boilerplate.
 
 ---

{polyxml-0.24.0/crates/polyxml-python → polyxml-0.25.0}/README.md

@@ -29,9 +29,9 @@ pip install polyxml
 
 ## Features
 
-- **⚡ Blazing Fast**: 16x faster deserialization and 38x faster serialization than standard Python tools.
-- **🌊 Streaming `iterparse()`**: Parse multi-gigabyte XML files with O(1) constant memory (<5 MB RAM).
-- **📦 Zero-GIL Binary Serialization**: Native `dumps_binary()` and `loads_binary()` using MessagePack (`msgspec`), up to 12.4x faster than pickle.
+- **⚡ Fast typed XML binding**: 10.0x faster deserialization and 23.5x faster serialization than `xsdata` on the [10,000-item catalog benchmark](../../benchmarks/python/results.md).
+- **🌊 Streaming `iterparse()`**: Process records incrementally; measure memory on your own document structure.
+- **📦 Binary Serialization**: Native `dumps_binary()` and `loads_binary()` using MessagePack (`msgspec`).
 - **🎯 Full Type Support**: Dataclasses and Pydantic v2 models with zero boilerplate.
 
 ---

{polyxml-0.24.0 → polyxml-0.25.0}/crates/polyxml-core/src/codegen/cpp/mod.rs

@@ -5,7 +5,8 @@ use heck::{AsPascalCase, AsSnakeCase};
 use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
-    build_type_name_map, lookup_type_name, sanitize_keyword, set_type_name_map, LanguageContext,
+    build_type_name_map, lookup_type_name, normalize_symbol_name, sanitize_keyword,
+    set_type_name_map, LanguageContext,
 };
 use crate::ir::{
     EnumDef, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef, StructDef, TypeDef,
@@ -224,7 +225,11 @@ pub fn to_cpp_field_name(raw: &str) -> String {
 
 /// Converts an enumeration variant raw value into a safe C++ scoped enum identifier.
 pub fn to_cpp_enum_variant(raw: &str) -> String {
-    let pascal = AsPascalCase(raw).to_string();
+    if raw.trim().is_empty() {
+        return "Unknown".to_string();
+    }
+    let normalized = normalize_symbol_name(raw);
+    let pascal = AsPascalCase(&normalized).to_string();
     let safe = if pascal.is_empty() {
         "Unknown".to_string()
     } else if pascal.starts_with(|c: char| c.is_ascii_digit()) {
@@ -255,6 +260,39 @@ impl CppCodegen {
         }
     }
 
+    fn unique_field_name(
+        &self,
+        struct_name: &str,
+        raw: &str,
+        seen: &mut HashSet<String>,
+    ) -> String {
+        let base = to_cpp_field_name(raw);
+        let mut name = base.clone();
+        if name.eq_ignore_ascii_case(struct_name) {
+            name.push_str("_value");
+        }
+        let stem = name.clone();
+        let mut index = 2;
+        while seen.contains(&name) || name.eq_ignore_ascii_case(struct_name) {
+            name = format!("{}_{}", stem, index);
+            index += 1;
+        }
+        seen.insert(name.clone());
+        name
+    }
+
+    fn unique_enum_variant(&self, raw: &str, seen: &mut HashSet<String>) -> String {
+        let base = to_cpp_enum_variant(raw);
+        let mut name = base.clone();
+        let mut index = 2;
+        while seen.contains(&name) {
+            name = format!("{}_{}", base, index);
+            index += 1;
+        }
+        seen.insert(name.clone());
+        name
+    }
+
     /// Generate complete header-only source (`.hpp`).
     pub fn generate_header(&self, ir: &SchemaIR) -> String {
         set_type_name_map(build_type_name_map(ir, to_cpp_type_name));
@@ -501,8 +539,15 @@ endif()
                     writeln!(out, "    static constexpr auto value = enumerate();").unwrap();
                 } else {
                     writeln!(out, "    static constexpr auto value = enumerate(").unwrap();
-                    for (i, v) in enum_def.variants.iter().enumerate() {
-                        let var_name = to_cpp_enum_variant(&v.name);
+                    let mut seen = HashSet::new();
+                    let variant_names: Vec<String> = enum_def
+                        .variants
+                        .iter()
+                        .map(|v| self.unique_enum_variant(&v.name, &mut seen))
+                        .collect();
+                    for (i, (v, var_name)) in
+                        enum_def.variants.iter().zip(&variant_names).enumerate()
+                    {
                         let comma = if i + 1 < enum_def.variants.len() {
                             ","
                         } else {
@@ -527,6 +572,7 @@ endif()
                 writeln!(out, "    using T = {};", full_type).unwrap();
 
                 let mut field_bindings = Vec::new();
+                let mut seen = HashSet::new();
 
                 // Check for simple_content_base "value"
                 if let Some(ref base_qname) = s.base_type {
@@ -538,12 +584,13 @@ endif()
                         && (PrimitiveType::from_xsd_name(&base_qname.local).is_some()
                             || matches!(ir.types.get(base_qname), Some(TypeDef::Simple(_))))
                     {
+                        seen.insert("value".to_string());
                         field_bindings.push(r#""value", &T::value"#.to_string());
                     }
                 }
 
                 for f in &s.fields {
-                    let field_name = to_cpp_field_name(&f.name);
+                    let field_name = self.unique_field_name(&struct_name, &f.name, &mut seen);
                     field_bindings.push(format!("{:?}, &T::{}", f.xml_name, field_name));
                 }
 
@@ -671,11 +718,17 @@ concept XmlModel = requires(T a) {{
         let enum_name = type_ident(&enum_def.qname);
         writeln!(out, "enum class {} {{", enum_name).unwrap();
 
-        for variant in &enum_def.variants {
+        let mut seen = HashSet::new();
+        let variant_names: Vec<String> = enum_def
+            .variants
+            .iter()
+            .map(|v| self.unique_enum_variant(&v.name, &mut seen))
+            .collect();
+
+        for (variant, var_name) in enum_def.variants.iter().zip(&variant_names) {
             if let Some(ref doc) = variant.documentation {
                 writeln!(out, "    /// {}", doc).unwrap();
             }
-            let var_name = to_cpp_enum_variant(&variant.name);
             writeln!(out, "    {},", var_name).unwrap();
         }
         writeln!(out, "}};\n").unwrap();
@@ -689,8 +742,7 @@ concept XmlModel = requires(T a) {{
             )
             .unwrap();
             writeln!(out, "    switch (value) {{").unwrap();
-            for variant in &enum_def.variants {
-                let var_name = to_cpp_enum_variant(&variant.name);
+            for (variant, var_name) in enum_def.variants.iter().zip(&variant_names) {
                 writeln!(
                     out,
                     "        case {}::{}: return \"{}\";",
@@ -718,8 +770,7 @@ concept XmlModel = requires(T a) {{
                 enum_name, func_name
             )
             .unwrap();
-            for variant in &enum_def.variants {
-                let var_name = to_cpp_enum_variant(&variant.name);
+            for (variant, var_name) in enum_def.variants.iter().zip(&variant_names) {
                 writeln!(
                     out,
                     "    if (s == \"{}\") return {}::{};",
@@ -816,7 +867,7 @@ concept XmlModel = requires(T a) {{
 
         writeln!(out, "struct {}{} {{", struct_name, base_clause).unwrap();
 
-        if let Some(base_type_str) = simple_content_base {
+        if let Some(ref base_type_str) = simple_content_base {
             let has_value_field = s
                 .fields
                 .iter()
@@ -828,8 +879,6 @@ concept XmlModel = requires(T a) {{
                     || base_type_str.starts_with("std::uint")
                 {
                     " = 0"
-                } else if base_type_str == "bool" {
-                    " = false"
                 } else {
                     " = {}"
                 };
@@ -837,12 +886,27 @@ concept XmlModel = requires(T a) {{
             }
         }
 
+        let mut seen = HashSet::new();
+        if simple_content_base.is_some() {
+            let has_value_field = s
+                .fields
+                .iter()
+                .any(|f| f.name == "value" || f.kind == crate::ir::FieldKind::Text);
+            if !has_value_field {
+                seen.insert("value".to_string());
+            }
+        }
+        let field_names: Vec<String> = s
+            .fields
+            .iter()
+            .map(|f| self.unique_field_name(&struct_name, &f.name, &mut seen))
+            .collect();
+
         // Fields
-        for f in &s.fields {
+        for (f, field_name) in s.fields.iter().zip(&field_names) {
             if let Some(ref doc) = f.documentation {
                 writeln!(out, "    /// {}", doc).unwrap();
             }
-            let field_name = to_cpp_field_name(&f.name);
             let (field_type, init_val) = self.resolve_field_type_and_init(f);
             writeln!(out, "    {} {}{};", field_type, field_name, init_val).unwrap();
         }
@@ -857,7 +921,7 @@ concept XmlModel = requires(T a) {{
         }
 
         if self.options.validate_facets {
-            self.emit_struct_validator(out, s, ir);
+            self.emit_struct_validator(out, s, ir, &field_names);
         }
 
         writeln!(out, "}};\n").unwrap();
@@ -929,13 +993,19 @@ concept XmlModel = requires(T a) {{
         }
     }
 
-    fn emit_struct_validator(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
+    fn emit_struct_validator(
+        &self,
+        out: &mut String,
+        s: &StructDef,
+        ir: &SchemaIR,
+        field_names: &[String],
+    ) {
         writeln!(out, "\n    [[nodiscard]] bool validate() const noexcept {{").unwrap();
 
         let mut has_checks = false;
-        for f in &s.fields {
+        for (f, field_name) in s.fields.iter().zip(field_names) {
             if let Some(simple) = super::patterned_simple(&f.type_ref, ir) {
-                let field = to_cpp_field_name(&f.name);
+                let field = field_name.clone();
                 let name = type_ident(&simple.qname);
                 let is_string = self
                     .context
@@ -963,7 +1033,6 @@ concept XmlModel = requires(T a) {{
                 }
             }
             if let Some(ref facets) = f.facets {
-                let field_name = to_cpp_field_name(&f.name);
                 let is_opt = f.cardinality.is_optional() || f.nillable;
 
                 if is_opt {
@@ -976,7 +1045,7 @@ concept XmlModel = requires(T a) {{
                     );
                     writeln!(out, "        }}").unwrap();
                 } else {
-                    self.emit_facet_checks(out, facets, &field_name, "        ");
+                    self.emit_facet_checks(out, facets, field_name, "        ");
                 }
                 has_checks = true;
             }

{polyxml-0.24.0 → polyxml-0.25.0}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -3,13 +3,15 @@
 //! Emits idiomatic C# 12 records with primary constructors, standard System.Xml.Serialization
 //! attributes, polymorphic xs:choice abstract records, and IValidatableObject facet boundary checks.
 
+use std::collections::HashSet;
 use std::fmt::Write as FmtWrite;
 
 use heck::{AsLowerCamelCase, AsPascalCase};
 use serde::{Deserialize, Serialize};
 
 use crate::codegen::{
-    build_type_name_map, lookup_type_name, sanitize_keyword, set_type_name_map, LanguageContext,
+    build_type_name_map, lookup_type_name, normalize_symbol_name, sanitize_keyword,
+    set_type_name_map, LanguageContext,
 };
 use crate::ir::{
     EnumDef, FieldDef, FieldKind, PrimitiveType, QName, RestrictionFacets, SchemaIR, SimpleTypeDef,
@@ -135,7 +137,8 @@ pub fn to_csharp_param_name(raw: &str) -> String {
 
 /// Sanitizes an identifier into a PascalCase C# enum variant.
 pub fn to_csharp_variant_name(raw: &str) -> String {
-    let pascal = AsPascalCase(raw).to_string();
+    let normalized = normalize_symbol_name(raw);
+    let pascal = AsPascalCase(&normalized).to_string();
     let safe = if pascal.is_empty() {
         "Value".to_string()
     } else if pascal.starts_with(|c: char| c.is_ascii_digit()) {
@@ -381,6 +384,7 @@ impl CSharpCodegen {
             if let TypeDef::Union(u) = def {
                 let name = type_ident(&u.qname);
                 writeln!(out, "{}[JsonSerializable(typeof({}))]", indent, name).unwrap();
+                writeln!(out, "{}[JsonSerializable(typeof(List<{}>))]", indent, name).unwrap();
             }
         }
 
@@ -428,8 +432,14 @@ impl CSharpCodegen {
         writeln!(out, "{}public enum {}", indent, enum_name).unwrap();
         writeln!(out, "{}{{", indent).unwrap();
 
-        for variant in &e.variants {
-            let variant_name = to_csharp_variant_name(&variant.name);
+        let mut seen_variants = HashSet::new();
+        let variant_names: Vec<String> = e
+            .variants
+            .iter()
+            .map(|v| self.unique_variant_name(&v.name, &mut seen_variants))
+            .collect();
+
+        for (variant, variant_name) in e.variants.iter().zip(&variant_names) {
             if let Some(ref doc) = variant.documentation {
                 self.emit_docstring(out, doc, &format!("{}    ", indent));
             }
@@ -453,8 +463,7 @@ impl CSharpCodegen {
         )
         .unwrap();
         writeln!(out, "{}    {{", indent).unwrap();
-        for variant in &e.variants {
-            let variant_name = to_csharp_variant_name(&variant.name);
+        for variant_name in &variant_names {
             writeln!(
                 out,
                 "{}        {}.{} => true,",
@@ -473,8 +482,7 @@ impl CSharpCodegen {
         )
         .unwrap();
         writeln!(out, "{}    {{", indent).unwrap();
-        for variant in &e.variants {
-            let variant_name = to_csharp_variant_name(&variant.name);
+        for (variant, variant_name) in e.variants.iter().zip(&variant_names) {
             writeln!(
                 out,
                 "{}        {}.{} => \"{}\",",
@@ -717,6 +725,13 @@ impl CSharpCodegen {
             format!(" : {}", base_clause.join(", "))
         };
 
+        let mut seen_props = HashSet::new();
+        let prop_names: Vec<String> = s
+            .fields
+            .iter()
+            .map(|f| self.unique_property_name(&f.name, &mut seen_props, Some(&struct_name)))
+            .collect();
+
         if !self.options.use_records {
             writeln!(
                 out,
@@ -725,8 +740,7 @@ impl CSharpCodegen {
             )
             .unwrap();
             writeln!(out, "{}    public {}() {{ }}", indent, struct_name).unwrap();
-            for f in &s.fields {
-                let name = to_csharp_property_name(&f.name, Some(&struct_name));
+            for (f, name) in s.fields.iter().zip(&prop_names) {
                 let ty = self.map_field_type(f, ir);
                 let attrs = self
                     .build_field_attributes(f, ir)
@@ -744,7 +758,7 @@ impl CSharpCodegen {
                 .unwrap();
             }
             if self.options.emit_validation {
-                self.emit_struct_validator(out, s, indent);
+                self.emit_struct_validator(out, s, &prop_names, indent);
             }
             writeln!(out, "{}}}\n", indent).unwrap();
             return;
@@ -764,8 +778,7 @@ impl CSharpCodegen {
 
         writeln!(out, "{}public {} {}(", indent, record_keyword, struct_name).unwrap();
 
-        for (i, f) in s.fields.iter().enumerate() {
-            let prop_name = to_csharp_property_name(&f.name, Some(&struct_name));
+        for (i, (f, prop_name)) in s.fields.iter().zip(&prop_names).enumerate() {
             let field_type = self.map_field_type(f, ir);
             let is_opt = f.cardinality.is_optional()
                 || f.nillable
@@ -822,14 +835,49 @@ impl CSharpCodegen {
 
         // IValidatableObject implementation
         if self.options.emit_validation {
-            self.emit_struct_validator(out, s, indent);
+            self.emit_struct_validator(out, s, &prop_names, indent);
         }
 
         writeln!(out, "{}}}\n", indent).unwrap();
     }
 
-    fn emit_struct_validator(&self, out: &mut String, s: &StructDef, indent: &str) {
-        let struct_name = type_ident(&s.qname);
+    fn unique_property_name(
+        &self,
+        name: &str,
+        seen: &mut HashSet<String>,
+        enclosing: Option<&str>,
+    ) -> String {
+        let base = to_csharp_property_name(name, enclosing);
+        let mut candidate = base.clone();
+        let mut counter = 1;
+        while seen.contains(&candidate) {
+            counter += 1;
+            candidate = format!("{}{}", base, counter);
+        }
+        seen.insert(candidate.clone());
+        candidate
+    }
+
+    fn unique_variant_name(&self, name: &str, seen: &mut HashSet<String>) -> String {
+        let base = to_csharp_variant_name(name);
+        let mut candidate = base.clone();
+        let mut counter = 1;
+        while seen.contains(&candidate) {
+            counter += 1;
+            candidate = format!("{}{}", base, counter);
+        }
+        seen.insert(candidate.clone());
+        candidate
+    }
+
+    fn emit_struct_validator(
+        &self,
+        out: &mut String,
+        s: &StructDef,
+        prop_names: &[String],
+        indent: &str,
+    ) {
+        let _struct_name = type_ident(&s.qname);
         let new_kw = if !self.options.use_records {
             if s.base_type.is_some() {
                 "override "
@@ -853,8 +901,7 @@ impl CSharpCodegen {
             writeln!(out, "{}        foreach (var result in base.Validate(validationContext)) yield return result;", indent).unwrap();
         }
         let mut has_checks = false;
-        for f in &s.fields {
-            let prop_name = to_csharp_property_name(&f.name, Some(&struct_name));
+        for (f, prop_name) in s.fields.iter().zip(prop_names) {
             let is_opt = f.cardinality.is_optional()
                 || f.nillable
                 || (f.cardinality.is_list() && f.cardinality.min_occurs == 0);
@@ -866,12 +913,12 @@ impl CSharpCodegen {
                     self.emit_facet_checks(
                         out,
                         facets,
-                        &prop_name,
+                        prop_name,
                         &format!("{}            ", indent),
                     );
                     writeln!(out, "{}        }}", indent).unwrap();
                 } else {
-                    self.emit_facet_checks(out, facets, &prop_name, &format!("{}        ", indent));
+                    self.emit_facet_checks(out, facets, prop_name, &format!("{}        ", indent));
                 }
                 has_checks = true;
             }
@@ -982,7 +1029,15 @@ impl CSharpCodegen {
 
         if self.options.emit_xml_attributes {
             // If the field is a choice (UnionDef), emit XmlElement("branchXml", typeof(BranchType))
-            if let TypeRef::Named(ref qname) = f.type_ref {
+            let named_qname = match &f.type_ref {
+                TypeRef::Named(q) => Some(q),
+                TypeRef::List(inner) | TypeRef::Boxed(inner) => match &**inner {
+                    TypeRef::Named(q) => Some(q),
+                    _ => None,
+                },
+                _ => None,
+            };
+            if let Some(qname) = named_qname {
                 if let Some(TypeDef::Union(u)) = ir.types.get(qname) {
                     let choice_name = type_ident(&u.qname);
                     for branch in &u.branches {
@@ -1008,7 +1063,13 @@ impl CSharpCodegen {
         if self.options.emit_json_attributes {
             let json_name = match f.kind {
                 FieldKind::Text => "value",
-                _ => &f.xml_name,
+                _ => {
+                    if f.xml_name.is_empty() {
+                        &f.name
+                    } else {
+                        &f.xml_name
+                    }
+                }
             };
             if f.kind != FieldKind::Any && f.kind != FieldKind::AnyAttribute {
                 parts.push(format!("JsonPropertyName(\"{}\")", json_name));