polyxml 0.33.4__tar.gz → 0.33.6__tar.gz

{polyxml-0.33.4 → polyxml-0.33.6}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.33.4"
+version = "0.33.6"
 dependencies = [
  "criterion",
  "heck",
@@ -629,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.33.4"
+version = "0.33.6"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.33.4"
+version = "0.33.6"
 dependencies = [
  "clap",
  "glob",
@@ -650,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.33.4"
+version = "0.33.6"
 dependencies = [
  "napi",
  "napi-build",
@@ -660,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.33.4"
+version = "0.33.6"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -670,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.33.4"
+version = "0.33.6"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.33.4 → polyxml-0.33.6}/Cargo.toml

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

{polyxml-0.33.4 → polyxml-0.33.6}/PKG-INFO

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

{polyxml-0.33.4 → polyxml-0.33.6}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -273,6 +273,28 @@ fn simple_value_target(base: &TypeRef, ir: &SchemaIR) -> String {
 }
 
 impl CSharpCodegen {
+    fn emit_optional_element_omission(
+        &self,
+        out: &mut String,
+        s: &StructDef,
+        names: &[String],
+        indent: &str,
+    ) {
+        if self.options.emit_xml_attributes {
+            for (field, name) in s.fields.iter().zip(names) {
+                if field.kind == FieldKind::Element
+                    && field.cardinality.min_occurs == 0
+                    && !field.nillable
+                {
+                    let _ = writeln!(
+                        out,
+                        "{indent}    public bool ShouldSerialize{name}() => {name} is not null;"
+                    );
+                }
+            }
+        }
+    }
+
     /// Creates a new C# code generator with the given configuration options.
     pub fn new(options: CSharpOptions) -> Self {
         Self {
@@ -1002,7 +1024,7 @@ impl CSharpCodegen {
             .map(|f| self.unique_property_name(&f.name, &mut seen_props, Some(&struct_name)))
             .collect();
 
-        if s.is_mixed && self.options.emit_xml_attributes {
+        if ir.has_ordered_content(s) && self.options.emit_xml_attributes {
             self.emit_mixed_struct(out, s, ir, indent, &struct_name, &prop_names);
             return;
         }
@@ -1032,7 +1054,12 @@ impl CSharpCodegen {
                             "{}    public {} {} {{ get; set; }} = default!;",
                             indent, ty, name
                         );
-                        let _ = writeln!(out, "{}    [XmlElement({:?})]", indent, f.xml_name);
+                        let xml_kind = if f.kind == FieldKind::Attribute {
+                            "XmlAttribute"
+                        } else {
+                            "XmlElement"
+                        };
+                        let _ = writeln!(out, "{}    [{}({:?})]", indent, xml_kind, f.xml_name);
                         if self.options.emit_json_attributes {
                             let _ = writeln!(out, "{}    [JsonIgnore]", indent);
                         }
@@ -1049,6 +1076,7 @@ impl CSharpCodegen {
                     indent, attrs, ty, name
                 );
             }
+            self.emit_optional_element_omission(out, s, &prop_names, indent);
             if self.options.emit_validation {
                 self.emit_struct_validator(out, s, ir, &prop_names, indent);
             }
@@ -1080,7 +1108,12 @@ impl CSharpCodegen {
                             "{}    public {} {} {{ get; set; }} = default!;",
                             indent, ty, name
                         );
-                        let _ = writeln!(out, "{}    [XmlElement({:?})]", indent, f.xml_name);
+                        let xml_kind = if f.kind == FieldKind::Attribute {
+                            "XmlAttribute"
+                        } else {
+                            "XmlElement"
+                        };
+                        let _ = writeln!(out, "{}    [{}({:?})]", indent, xml_kind, f.xml_name);
                         if self.options.emit_json_attributes {
                             let _ = writeln!(out, "{}    [JsonIgnore]", indent);
                         }
@@ -1103,6 +1136,7 @@ impl CSharpCodegen {
                 )
                 .unwrap();
             }
+            self.emit_optional_element_omission(out, s, &prop_names, indent);
             if self.options.emit_validation {
                 self.emit_struct_validator(out, s, ir, &prop_names, indent);
             }
@@ -1191,6 +1225,8 @@ impl CSharpCodegen {
         }
         writeln!(out, ") {{ }}\n").unwrap();
 
+        self.emit_optional_element_omission(out, s, &prop_names, indent);
+
         // IValidatableObject implementation
         if self.options.emit_validation {
             self.emit_struct_validator(out, s, ir, &prop_names, indent);
@@ -1379,6 +1415,11 @@ impl CSharpCodegen {
         };
 
         if f.cardinality.is_list() {
+            let base_type = if f.nillable {
+                format!("{}?", base_type)
+            } else {
+                base_type
+            };
             if f.cardinality.min_occurs == 0 || f.nillable {
                 format!("List<{}>?", base_type)
             } else {
@@ -1422,7 +1463,14 @@ impl CSharpCodegen {
                     FieldKind::Text => parts.push("XmlText".to_string()),
                     FieldKind::Any => parts.push("XmlAnyElement".to_string()),
                     FieldKind::AnyAttribute => parts.push("XmlAnyAttribute".to_string()),
-                    FieldKind::Element => parts.push(format!("XmlElement(\"{}\")", f.xml_name)),
+                    FieldKind::Element => {
+                        let nullable = if f.nillable {
+                            ", IsNullable = true"
+                        } else {
+                            ""
+                        };
+                        parts.push(format!("XmlElement(\"{}\"{})", f.xml_name, nullable));
+                    }
                 }
             }
         }
@@ -1500,6 +1548,17 @@ impl CSharpCodegen {
                         continue;
                     }
                 }
+                if self.options.use_records
+                    && !matches!(&elem.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Struct(_) | TypeDef::Simple(_) | TypeDef::Union(_))))
+                {
+                    let xml_attr = if self.options.emit_xml_attributes {
+                        "[property: XmlText] "
+                    } else {
+                        ""
+                    };
+                    writeln!(out, "{}public sealed record {}({}{} Value)\n{}{{\n{}    public {}() : this(default({})!) {{ }}\n{}}}\n", indent, elem_name, xml_attr, target_type, indent, indent, elem_name, target_type, indent).unwrap();
+                    continue;
+                }
                 writeln!(
                     out,
                     "{}public sealed {} {} : {}\n{}{{",

{polyxml-0.33.4 → polyxml-0.33.6}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -119,7 +119,9 @@ impl LanguageContext for GoLanguageContext {
             | PrimitiveType::GMonthDay
             | PrimitiveType::GDay
             | PrimitiveType::Duration => "string",
-            PrimitiveType::Date | PrimitiveType::Time | PrimitiveType::DateTime => "time.Time",
+            PrimitiveType::Date => "PolyxmlDate",
+            PrimitiveType::Time => "PolyxmlTime",
+            PrimitiveType::DateTime => "PolyxmlDateTime",
             PrimitiveType::Base64Binary | PrimitiveType::HexBinary => "[]byte",
             PrimitiveType::AnyType | PrimitiveType::AnySimpleType => "any",
         }
@@ -243,6 +245,46 @@ fn type_ident(q: &QName) -> String {
 }
 
 impl GoCodegen {
+    fn emit_temporal_types(&self, out: &mut String) {
+        for (name, layouts, default_layout) in [
+            (
+                "PolyxmlDate",
+                &["2006-01-02Z07:00", "2006-01-02"][..],
+                "2006-01-02Z07:00",
+            ),
+            (
+                "PolyxmlTime",
+                &["15:04:05Z07:00", "15:04:05"][..],
+                "15:04:05.999999999Z07:00",
+            ),
+            (
+                "PolyxmlDateTime",
+                &["2006-01-02T15:04:05Z07:00", "2006-01-02T15:04:05"][..],
+                "2006-01-02T15:04:05.999999999Z07:00",
+            ),
+        ] {
+            writeln!(out, "// {name} retains the XSD lexical form, including an absent timezone.\ntype {name} struct {{ time.Time; lexical string }}").unwrap();
+            writeln!(out, "func (v *{name}) UnmarshalText(text []byte) error {{\n    value := strings.TrimSpace(string(text))").unwrap();
+            for layout in layouts {
+                writeln!(out, "    if parsed, err := time.Parse({layout:?}, value); err == nil {{ *v = {name}{{Time: parsed, lexical: value}}; return nil }}").unwrap();
+            }
+            writeln!(out, "    return fmt.Errorf(\"invalid {name}: %q\", value)\n}}\nfunc (v {name}) MarshalText() ([]byte, error) {{\n    layout := {default_layout:?}").unwrap();
+            for original_layout in layouts {
+                writeln!(out, "    if parsed, err := time.Parse({original_layout:?}, v.lexical); err == nil {{\n        _, offset := v.Time.Zone(); _, originalOffset := parsed.Zone()\n        if v.Time.Equal(parsed) && offset == originalOffset {{ return []byte(v.lexical), nil }}").unwrap();
+                if !original_layout.contains("Z07:00") {
+                    writeln!(
+                        out,
+                        "        layout = {:?}",
+                        default_layout.trim_end_matches("Z07:00")
+                    )
+                    .unwrap();
+                }
+                out.push_str("    }\n");
+            }
+            out.push_str("    return []byte(v.Time.Format(layout)), nil\n}\n\n");
+        }
+    }
+
     pub fn new(options: GoOptions) -> Self {
         Self {
             options,
@@ -278,7 +320,7 @@ impl GoCodegen {
         for type_def in ir.emitted_types() {
             match type_def {
                 TypeDef::Struct(s) => {
-                    if s.is_mixed && self.options.emit_xml_tags {
+                    if ir.has_ordered_content(s) && self.options.emit_xml_tags {
                         has_fmt = true;
                         has_io = true;
                     }
@@ -324,6 +366,9 @@ impl GoCodegen {
 
         // Generate types
         self.emit_types(&mut body, ir);
+        if has_time {
+            self.emit_temporal_types(&mut body);
+        }
         self.emit_root_aliases(&mut body, ir);
 
         // Assemble final output with package and imports
@@ -357,7 +402,7 @@ impl GoCodegen {
             && ir
                 .types
                 .values()
-                .any(|def| matches!(def, TypeDef::Struct(s) if s.is_mixed))
+                .any(|def| matches!(def, TypeDef::Struct(s) if ir.has_ordered_content(s)))
         {
             imports.push("\"bytes\"");
         }
@@ -466,6 +511,12 @@ impl GoCodegen {
         let type_name = type_ident(&simple.qname);
         let base_type = self.context.map_type_ref(&simple.base_type);
         writeln!(out, "type {} {}\n", type_name, base_type).unwrap();
+        if matches!(
+            super::primitive_base(&simple.base_type, ir),
+            TypeRef::Primitive(PrimitiveType::Date | PrimitiveType::Time | PrimitiveType::DateTime)
+        ) {
+            writeln!(out, "func (v *{type_name}) UnmarshalText(text []byte) error {{ return (*{base_type})(v).UnmarshalText(text) }}\nfunc (v {type_name}) MarshalText() ([]byte, error) {{ return {base_type}(v).MarshalText() }}\n").unwrap();
+        }
         if self.options.validate_facets && !simple.facets.patterns.is_empty() {
             writeln!(out, "func (s {}) Validate() error {{", type_name).unwrap();
             for pattern in &simple.facets.patterns {
@@ -771,7 +822,13 @@ impl GoCodegen {
             "func (c *{}) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {{",
             name
         );
-        out.push_str("    var raw string\n    if err := d.DecodeElement(&raw, &start); err != nil { return err }\n    value := strings.TrimSpace(raw)\n    *c = ");
+        out.push_str("    var raw string\n    if err := d.DecodeElement(&raw, &start); err != nil { return err }\n    return c.UnmarshalText([]byte(raw))\n}\n\n");
+        let _ = writeln!(
+            out,
+            "func (c *{}) UnmarshalText(text []byte) error {{",
+            name
+        );
+        out.push_str("    value := strings.TrimSpace(string(text))\n    *c = ");
         let _ = writeln!(out, "{}{{}}", name);
         for (branch, field) in u.branches.iter().zip(&fields) {
             let mapped = self.context.map_type_ref(&branch.type_ref);
@@ -819,13 +876,13 @@ impl GoCodegen {
                 _ => None,
             };
             if matches!(base, TypeRef::Primitive(PrimitiveType::Date)) {
-                let _ = writeln!(out, "    if parsed, err := time.Parse(\"2006-01-02\", value); err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", mapped, field);
+                let _ = writeln!(out, "    if parsed, err := time.Parse(\"2006-01-02\", value); err == nil {{ v := {}{{Time: parsed, lexical: value}}; c.{} = &v; return nil }}", mapped, field);
             } else if matches!(base, TypeRef::Primitive(PrimitiveType::DateTime)) {
-                let _ = writeln!(out, "    if parsed, err := time.Parse(time.RFC3339, value); err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", mapped, field);
-                let _ = writeln!(out, "    if parsed, err := time.Parse(\"2006-01-02T15:04:05\", value); err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", mapped, field);
+                let _ = writeln!(out, "    if parsed, err := time.Parse(time.RFC3339, value); err == nil {{ v := {}{{Time: parsed, lexical: value}}; c.{} = &v; return nil }}", mapped, field);
+                let _ = writeln!(out, "    if parsed, err := time.Parse(\"2006-01-02T15:04:05\", value); err == nil {{ v := {}{{Time: parsed, lexical: value}}; c.{} = &v; return nil }}", mapped, field);
             } else if matches!(base, TypeRef::Primitive(PrimitiveType::Time)) {
-                let _ = writeln!(out, "    if parsed, err := time.Parse(\"15:04:05Z07:00\", value); err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", mapped, field);
-                let _ = writeln!(out, "    if parsed, err := time.Parse(\"15:04:05\", value); err == nil {{ v := {}(parsed); c.{} = &v; return nil }}", mapped, field);
+                let _ = writeln!(out, "    if parsed, err := time.Parse(\"15:04:05Z07:00\", value); err == nil {{ v := {}{{Time: parsed, lexical: value}}; c.{} = &v; return nil }}", mapped, field);
+                let _ = writeln!(out, "    if parsed, err := time.Parse(\"15:04:05\", value); err == nil {{ v := {}{{Time: parsed, lexical: value}}; c.{} = &v; return nil }}", mapped, field);
             } else if let Some(kind) = numeric {
                 let parse = match kind {
                     "signed" => "strconv.ParseInt(value, 10, 64)",
@@ -881,11 +938,22 @@ impl GoCodegen {
             "func (c {}) MarshalXML(e *xml.Encoder, start xml.StartElement) error {{",
             name
         );
+        out.push_str("    text, err := c.MarshalText()\n    if err != nil { return err }\n    return e.EncodeElement(string(text), start)\n}\n\n");
+        let _ = writeln!(out, "func (c {}) MarshalText() ([]byte, error) {{", name);
         out.push_str("    count := 0\n    var value string\n");
         for (branch, field) in u.branches.iter().zip(&fields) {
             if matches!(&branch.type_ref, TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Union(inner)) if inner.is_lexical()))
             {
-                let _ = writeln!(out, "    if c.{field} != nil {{ data, err := xml.Marshal(c.{field}); if err != nil {{ return err }}; if err := xml.Unmarshal(data, &value); err != nil {{ return err }}; count++ }}");
+                let _ = writeln!(out, "    if c.{field} != nil {{ data, err := xml.Marshal(c.{field}); if err != nil {{ return nil, err }}; if err := xml.Unmarshal(data, &value); err != nil {{ return nil, err }}; count++ }}");
+                continue;
+            }
+            if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(
+                    PrimitiveType::Date | PrimitiveType::Time | PrimitiveType::DateTime
+                )
+            ) {
+                let _ = writeln!(out, "    if c.{field} != nil {{ text, err := c.{field}.MarshalText(); if err != nil {{ return nil, err }}; count++; value = string(text) }}");
                 continue;
             }
             let expr = if matches!(
@@ -912,7 +980,7 @@ impl GoCodegen {
                 field, expr
             );
         }
-        out.push_str("    if count != 1 { return fmt.Errorf(\"lexical union requires exactly one member\") }\n    return e.EncodeElement(value, start)\n}\n\n");
+        out.push_str("    if count != 1 { return nil, fmt.Errorf(\"lexical union requires exactly one member\") }\n    return []byte(value), nil\n}\n\n");
     }
 
     fn emit_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
@@ -1036,7 +1104,7 @@ impl GoCodegen {
 
         writeln!(out, "}}\n").unwrap();
 
-        if s.is_mixed && self.options.emit_xml_tags {
+        if ir.has_ordered_content(s) && self.options.emit_xml_tags {
             self.emit_mixed_struct_xml(out, s, ir, &field_names);
         }
 
@@ -1162,7 +1230,9 @@ impl GoCodegen {
             let xml_val = match f.kind {
                 FieldKind::Attribute => {
                     let attr_name = match &f.namespace {
-                        Some(ns) if !ns.is_empty() => format!("{} {}", ns, f.xml_name),
+                        Some(ns) if !ns.is_empty() && is_namespaced_ref(f, s, ir) => {
+                            format!("{} {}", ns, f.xml_name)
+                        }
                         _ => f.xml_name.clone(),
                     };
                     if is_opt {
@@ -1175,10 +1245,11 @@ impl GoCodegen {
                 FieldKind::Any => ",any".to_string(),
                 FieldKind::AnyAttribute => ",any,attr".to_string(),
                 FieldKind::Element => {
-                    let elem_name = if is_namespaced_ref(f, s, ir) {
-                        format!("{} {}", f.namespace.as_ref().unwrap(), f.xml_name)
-                    } else {
-                        f.xml_name.clone()
+                    let elem_name = match &f.namespace {
+                        Some(ns) if !ns.is_empty() && is_namespaced_ref(f, s, ir) => {
+                            format!("{} {}", ns, f.xml_name)
+                        }
+                        _ => f.xml_name.clone(),
                     };
                     if f.xml_name.is_empty() {
                         ",any".to_string()
@@ -1630,7 +1701,24 @@ impl GoCodegen {
                         }
                     }
                 }
-                writeln!(out, "type {} = {}\n", elem_alias, target_type).unwrap();
+                if self.options.emit_xml_tags {
+                    let namespace = elem.qname.namespace.as_deref().unwrap_or("");
+                    writeln!(out, "type {} {}\n", elem_alias, target_type).unwrap();
+                    if matches!(&elem.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Struct(s)) if s.is_abstract))
+                    {
+                        writeln!(out, "func (r {elem_alias}) Selected() string {{ return {target_type}(r).Selected() }}\n").unwrap();
+                    }
+                    writeln!(out, "func (r *{elem_alias}) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {{\n    if start.Name.Local != {:?} || start.Name.Space != {:?} {{ return fmt.Errorf(\"unexpected root element: %v\", start.Name) }}\n    return d.DecodeElement((*{target_type})(r), &start)\n}}\n", elem.qname.local, namespace).unwrap();
+                    let bind_name = if matches!(&elem.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Struct(_))))
+                    {
+                        "    value.XMLName = start.Name\n"
+                    } else {
+                        ""
+                    };
+                    writeln!(out, "func (r {elem_alias}) MarshalXML(e *xml.Encoder, start xml.StartElement) error {{\n    start.Name = xml.Name{{Local: {:?}, Space: {:?}}}\n    value := {target_type}(r)\n{bind_name}    return e.EncodeElement(value, start)\n}}\n", elem.qname.local, namespace).unwrap();
+                } else {
+                    writeln!(out, "type {} = {}\n", elem_alias, target_type).unwrap();
+                }
             }
         }
     }

{polyxml-0.33.4 → polyxml-0.33.6}/crates/polyxml-core/src/codegen/java/codec.rs

@@ -298,7 +298,7 @@ impl JavaCodegen {
         if text_field.is_some() {
             out.push_str("                if (event == XMLStreamConstants.CHARACTERS || event == XMLStreamConstants.CDATA) text.append(reader.getText());\n");
         }
-        if s.is_mixed {
+        if ir.has_ordered_content(s) {
             if let Some((field, id, union)) = fields.iter().find_map(|(field, id)| {
                 self.resolve_union_def(&field.type_ref, ir)
                     .filter(|union| union.is_mixed_content())

{polyxml-0.33.4 → polyxml-0.33.6}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -305,7 +305,7 @@ impl PythonCodegen {
     }
 
     fn emit_imports(&self, out: &mut String, ir: &SchemaIR) {
-        let mut has_structs = false;
+        let mut has_structs = self.options.emit_root_aliases && !ir.elements.is_empty();
         let mut has_enums = false;
         let mut has_decimal = false;
         let mut has_annotated = false;
@@ -634,7 +634,7 @@ impl PythonCodegen {
             has_body = true;
         }
 
-        if self.options.emit_meta || s.is_mixed {
+        if self.options.emit_meta || ir.has_ordered_content(s) {
             if has_body {
                 out.push('\n');
             }
@@ -644,6 +644,7 @@ impl PythonCodegen {
                 out.push_str("    class Meta:\n");
             }
             let _ = writeln!(out, "        name = \"{}\"", s.qname.local);
+            out.push_str("        strict_root = False\n");
             if let Some(ref ns) = s.qname.namespace {
                 let _ = writeln!(out, "        namespace = \"{}\"", ns);
             }
@@ -652,8 +653,10 @@ impl PythonCodegen {
             // derivations.
             if s.is_abstract {
                 out.push_str("        abstract = True\n");
+            } else if struct_base.is_some() {
+                out.push_str("        abstract = False\n");
             }
-            if s.is_mixed {
+            if ir.has_ordered_content(s) {
                 if let Some(item_field) = s
                     .fields
                     .iter()
@@ -722,7 +725,28 @@ impl PythonCodegen {
             out.push_str("    ) -> bytes:\n");
             out.push_str("        \"\"\"Serialize this model instance into XML bytes.\"\"\"\n");
             out.push_str("        import polyxml\n");
-            out.push_str("        return polyxml.serialize(self, indent=indent, namespaces=namespaces, ns_map=ns_map)\n\n");
+            let mut ancestors = BTreeSet::new();
+            let mut base = s.base_type.as_ref();
+            while let Some(q) = base {
+                if !ancestors.insert(q.clone()) {
+                    break;
+                }
+                base = match ir.types.get(q) {
+                    Some(TypeDef::Struct(parent)) => parent.base_type.as_ref(),
+                    _ => None,
+                };
+            }
+            let roots = ir.elements.values().filter(|element| matches!(&element.type_ref, TypeRef::Named(q) if ancestors.contains(q) && matches!(ir.types.get(q), Some(TypeDef::Struct(parent)) if parent.is_abstract))).collect::<Vec<_>>();
+            if let [root] = roots.as_slice() {
+                let root_name = AsPascalCase(&root.qname.local).to_string();
+                if !ir.types.keys().any(|q| type_ident(q) == root_name) {
+                    let _ = writeln!(out, "        return polyxml.serialize(self, target_type={}, indent=indent, namespaces=namespaces, ns_map=ns_map)\n", root_name);
+                } else {
+                    out.push_str("        return polyxml.serialize(self, indent=indent, namespaces=namespaces, ns_map=ns_map)\n\n");
+                }
+            } else {
+                out.push_str("        return polyxml.serialize(self, indent=indent, namespaces=namespaces, ns_map=ns_map)\n\n");
+            }
             out.push_str("    @classmethod\n");
             out.push_str("    def from_json(cls, data: bytes | str) -> Self:\n");
             out.push_str("        \"\"\"Deserialize JSON bytes or string into this model.\"\"\"\n");
@@ -1077,11 +1101,124 @@ impl PythonCodegen {
         }
 
         for element in ir.elements.values() {
-            let el_name = AsPascalCase(&element.qname.local).to_string();
+            let mut el_name = AsPascalCase(&element.qname.local).to_string();
+            let root_count = ir
+                .elements
+                .values()
+                .filter(|other| AsPascalCase(&other.qname.local).to_string() == el_name)
+                .count();
+            if root_count == 1
+                && declared_names.contains(&el_name)
+                && self.options.emit_meta
+                && matches!(&element.type_ref, TypeRef::Named(q) if q == &element.qname && type_ident(q) == el_name && matches!(ir.types.get(q), Some(TypeDef::Struct(_))))
+            {
+                let _ = writeln!(
+                    out,
+                    "\n{}.Meta.strict_root = True\n{}.Meta.name = {:?}",
+                    el_name, el_name, element.qname.local
+                );
+                continue;
+            }
+            if declared_names.contains(&el_name) {
+                let base = format!("{}Element", el_name);
+                el_name = base.clone();
+                let mut suffix = 2;
+                while declared_names.contains(&el_name) {
+                    el_name = format!("{base}{suffix}");
+                    suffix += 1;
+                }
+            }
             if !declared_names.contains(&el_name) {
                 let target_type = self.context.map_type_ref(&element.type_ref);
                 if el_name != target_type {
-                    let _ = writeln!(out, "\ntype {} = {}", el_name, target_type);
+                    if matches!(&element.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Struct(_))))
+                    {
+                        if self.options.backend != PythonBackend::Pydantic {
+                            let _ = writeln!(
+                                out,
+                                "\n@dataclass(slots={}, kw_only={})",
+                                if self.options.slots { "True" } else { "False" },
+                                if self.options.kw_only {
+                                    "True"
+                                } else {
+                                    "False"
+                                }
+                            );
+                        }
+                        let meta_base = if self.options.emit_meta {
+                            format!("({}.Meta)", target_type)
+                        } else {
+                            String::new()
+                        };
+                        let _ = writeln!(out, "class {}({}):\n    class Meta{}:\n        name = {:?}\n        namespace = {:?}\n        strict_root = True", el_name, target_type, meta_base, element.qname.local, element.qname.namespace.as_deref().unwrap_or(""));
+                        let _ = writeln!(out, "        root_type = {}", target_type);
+                    } else {
+                        let fields = if let TypeRef::Named(q) = &element.type_ref {
+                            if let Some(TypeDef::Union(union)) = ir
+                                .types
+                                .get(q)
+                                .filter(|t| matches!(t, TypeDef::Union(u) if !u.is_lexical()))
+                            {
+                                union
+                                    .branches
+                                    .iter()
+                                    .map(|branch| {
+                                        let mut field = FieldDef::new(
+                                            &branch.variant_name,
+                                            &branch.xml_name,
+                                            FieldKind::Element,
+                                            branch.type_ref.clone(),
+                                        );
+                                        field.namespace = branch.namespace.clone();
+                                        field.cardinality = crate::ir::Cardinality::optional_one();
+                                        field
+                                    })
+                                    .collect()
+                            } else {
+                                vec![FieldDef::new(
+                                    "value",
+                                    "",
+                                    FieldKind::Text,
+                                    element.type_ref.clone(),
+                                )]
+                            }
+                        } else {
+                            let mut value = FieldDef::new(
+                                "value",
+                                "",
+                                FieldKind::Text,
+                                element.type_ref.clone(),
+                            );
+                            if matches!(
+                                element.type_ref,
+                                TypeRef::Primitive(
+                                    PrimitiveType::AnyType | PrimitiveType::AnySimpleType
+                                )
+                            ) {
+                                value.cardinality = crate::ir::Cardinality::optional_one();
+                            } else if matches!(
+                                element.type_ref,
+                                TypeRef::Primitive(PrimitiveType::String)
+                            ) {
+                                value.default_value = Some(String::new());
+                            }
+                            vec![value]
+                        };
+                        let wrapper = StructDef {
+                            qname: QName::new(element.qname.namespace.clone(), &el_name),
+                            base_type: None,
+                            is_abstract: false,
+                            is_mixed: false,
+                            fields,
+                            documentation: element.documentation.clone(),
+                        };
+                        self.emit_struct(out, &wrapper, ir);
+                        let _ = writeln!(
+                            out,
+                            "{}.Meta.strict_root = True\n{}.Meta.name = {:?}",
+                            el_name, el_name, element.qname.local
+                        );
+                    }
                     declared_names.insert(el_name);
                 }
             }

{polyxml-0.33.4 → polyxml-0.33.6}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -1630,7 +1630,7 @@ impl RustCodegen {
             out.push_str("                },\n");
 
             out.push_str("                Event::End(e) if e.local_name().as_ref() == start.local_name().as_ref() => break,\n");
-            if s.is_mixed {
+            if ir.has_ordered_content(s) {
                 let item_union = field_metas.iter().find_map(|meta| {
                     self.resolve_union_def(&meta.field.type_ref, ir)
                         .filter(|u| u.is_mixed_content())