polyxml 0.33.6__tar.gz → 0.33.7__tar.gz

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

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

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

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

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

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

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

@@ -869,6 +869,55 @@ impl CSharpCodegen {
         let _ = writeln!(out, "{}    }};", indent);
     }
 
+    fn emit_default_scalar_proxy(
+        &self,
+        out: &mut String,
+        field: &FieldDef,
+        name: &str,
+        ir: &SchemaIR,
+        indent: &str,
+    ) -> bool {
+        let Some(default) = field.default_value.as_ref() else {
+            return false;
+        };
+        if !self.options.emit_xml_attributes
+            || field.kind != FieldKind::Element
+            || field.cardinality.is_list()
+            || matches!(field.type_ref, TypeRef::Named(ref q) if matches!(ir.types.get(q), Some(TypeDef::Struct(_) | TypeDef::Union(_))))
+        {
+            return false;
+        }
+        let ty = self.map_field_type(field, ir);
+        let base = ty.trim_end_matches('?');
+        let namespace = field
+            .namespace
+            .as_ref()
+            .map(|ns| format!(", Namespace = {ns:?}"))
+            .unwrap_or_default();
+        writeln!(
+            out,
+            "{indent}    [XmlIgnore] public {ty} {name} {{ get; set; }} = default!;"
+        )
+        .unwrap();
+        writeln!(
+            out,
+            "{indent}    [XmlElement({:?}{namespace})] public string? {name}Xml {{",
+            field.xml_name
+        )
+        .unwrap();
+        writeln!(out, "{indent}        get {{ if ({name} is null) return null; var writer = new System.IO.StringWriter(System.Globalization.CultureInfo.InvariantCulture); new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Serialize(writer, {name}); return System.Xml.Linq.XDocument.Parse(writer.ToString()).Root!.Value; }}").unwrap();
+        writeln!(out, "{indent}        set {{ if (value is null) {{ {name} = default!; return; }} var text = value.Length == 0 ? {default:?} : value; {name} = ({base})new XmlSerializer(typeof({base}), new XmlRootAttribute(\"value\")).Deserialize(new System.IO.StringReader(\"<value>\" + System.Security.SecurityElement.Escape(text) + \"</value>\"))!; }}
+{indent}    }}").unwrap();
+        if field.cardinality.is_optional() || field.nillable {
+            writeln!(
+                out,
+                "{indent}    public bool ShouldSerialize{name}Xml() => {name} is not null;"
+            )
+            .unwrap();
+        }
+        true
+    }
+
     fn emit_mixed_struct(
         &self,
         out: &mut String,
@@ -1030,7 +1079,7 @@ impl CSharpCodegen {
         }
 
         let has_lexical_union = self.options.emit_xml_attributes && s.fields.iter().any(|f| {
-            matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
+            f.default_value.is_some() || matches!(&f.type_ref, TypeRef::Named(q) if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()))
         });
 
         if self.options.use_records && has_lexical_union {
@@ -1041,6 +1090,9 @@ impl CSharpCodegen {
             )
             .unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
+                if self.emit_default_scalar_proxy(out, f, name, ir, indent) {
+                    continue;
+                }
                 let ty = self.map_field_type(f, ir);
                 if let TypeRef::Named(q) = &f.type_ref {
                     if matches!(ir.types.get(q), Some(TypeDef::Union(u)) if u.is_lexical()) {
@@ -1059,7 +1111,16 @@ impl CSharpCodegen {
                         } else {
                             "XmlElement"
                         };
-                        let _ = writeln!(out, "{}    [{}({:?})]", indent, xml_kind, f.xml_name);
+                        let namespace = f
+                            .namespace
+                            .as_ref()
+                            .map(|ns| format!(", Namespace = {ns:?}"))
+                            .unwrap_or_default();
+                        let _ = writeln!(
+                            out,
+                            "{}    [{}({:?}{namespace})]",
+                            indent, xml_kind, f.xml_name
+                        );
                         if self.options.emit_json_attributes {
                             let _ = writeln!(out, "{}    [JsonIgnore]", indent);
                         }
@@ -1093,6 +1154,9 @@ impl CSharpCodegen {
             .unwrap();
             writeln!(out, "{}    public {}() {{ }}", indent, struct_name).unwrap();
             for (f, name) in s.fields.iter().zip(&prop_names) {
+                if self.emit_default_scalar_proxy(out, f, name, ir, indent) {
+                    continue;
+                }
                 let ty = self.map_field_type(f, ir);
                 if let TypeRef::Named(q) = &f.type_ref {
                     if self.options.emit_xml_attributes
@@ -1113,7 +1177,16 @@ impl CSharpCodegen {
                         } else {
                             "XmlElement"
                         };
-                        let _ = writeln!(out, "{}    [{}({:?})]", indent, xml_kind, f.xml_name);
+                        let namespace = f
+                            .namespace
+                            .as_ref()
+                            .map(|ns| format!(", Namespace = {ns:?}"))
+                            .unwrap_or_default();
+                        let _ = writeln!(
+                            out,
+                            "{}    [{}({:?}{namespace})]",
+                            indent, xml_kind, f.xml_name
+                        );
                         if self.options.emit_json_attributes {
                             let _ = writeln!(out, "{}    [JsonIgnore]", indent);
                         }
@@ -1459,7 +1532,14 @@ impl CSharpCodegen {
             }
             if parts.is_empty() {
                 match f.kind {
-                    FieldKind::Attribute => parts.push(format!("XmlAttribute(\"{}\")", f.xml_name)),
+                    FieldKind::Attribute => {
+                        let namespace = f
+                            .namespace
+                            .as_ref()
+                            .map(|ns| format!(", Namespace = {ns:?}"))
+                            .unwrap_or_default();
+                        parts.push(format!("XmlAttribute({:?}{namespace})", f.xml_name));
+                    }
                     FieldKind::Text => parts.push("XmlText".to_string()),
                     FieldKind::Any => parts.push("XmlAnyElement".to_string()),
                     FieldKind::AnyAttribute => parts.push("XmlAnyAttribute".to_string()),

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

@@ -1230,7 +1230,7 @@ impl GoCodegen {
             let xml_val = match f.kind {
                 FieldKind::Attribute => {
                     let attr_name = match &f.namespace {
-                        Some(ns) if !ns.is_empty() && is_namespaced_ref(f, s, ir) => {
+                        Some(ns) if !ns.is_empty() => {
                             format!("{} {}", ns, f.xml_name)
                         }
                         _ => f.xml_name.clone(),

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

@@ -840,7 +840,11 @@ impl PythonCodegen {
                 format!("field(default_factory=list, metadata={})", meta_dict),
             )
         } else if field.cardinality.is_optional() || field.nillable {
-            if let Some(ref def) = field.default_value {
+            if let Some(def) = field
+                .default_value
+                .as_ref()
+                .filter(|_| field.kind == FieldKind::Attribute)
+            {
                 let py_val = self.format_default_value(def, &field.type_ref, ir);
                 (
                     format!("{} | None", base_type),
@@ -928,7 +932,11 @@ impl PythonCodegen {
                 format!("Field(default_factory=list, {})", extra_clause),
             )
         } else if field.cardinality.is_optional() || field.nillable {
-            if let Some(ref def) = field.default_value {
+            if let Some(def) = field
+                .default_value
+                .as_ref()
+                .filter(|_| field.kind == FieldKind::Attribute)
+            {
                 let py_val = self.format_default_value(def, &field.type_ref, ir);
                 (
                     format!("{} | None", base_type),
@@ -985,6 +993,9 @@ impl PythonCodegen {
             parts.push(format!("\"namespace\": \"{}\"", ns));
         }
 
+        if let Some(ref default) = field.default_value {
+            parts.push(format!("\"default\": {default:?}"));
+        }
         if field.nillable {
             parts.push("\"nillable\": True".to_string());
         }

{polyxml-0.33.6 → polyxml-0.33.7}/crates/polyxml-core/src/parser.rs

@@ -7,7 +7,7 @@ use smallvec::{smallvec, SmallVec};
 
 use crate::converters::ValueConverter;
 use crate::error::{PolyXmlError, Result};
-use crate::schema::{ModelSchema, ScalarType, ValueType};
+use crate::schema::{FieldKind, ModelSchema, ScalarType, ValueType};
 use crate::value::PolyValue;
 
 type NamespaceScope = Arc<HashMap<String, String>>;
@@ -71,6 +71,19 @@ impl StackFrame {
     }
 
     fn finish(mut self) -> Result<PolyValue> {
+        for (index, field) in self.schema.fields.iter().enumerate() {
+            if field.kind == FieldKind::Attribute && self.values[index].is_none() {
+                if let (Some(default), ValueType::Scalar(scalar)) =
+                    (&field.default_value, &field.val_type)
+                {
+                    self.values[index] = Some(ValueConverter::parse_scalar(
+                        scalar,
+                        default.as_bytes(),
+                        &field.name,
+                    )?);
+                }
+            }
+        }
         if !self.list_values.is_empty() {
             for (idx, list_opt) in self.list_values.into_iter().enumerate() {
                 if let Some(list) = list_opt {
@@ -107,6 +120,22 @@ impl StackFrame {
     }
 }
 
+fn parse_field_scalar(
+    scalar: &ScalarType,
+    text: &[u8],
+    field: &crate::schema::FieldSchema,
+) -> Result<PolyValue> {
+    let text = if text.is_empty() && field.kind != FieldKind::Attribute {
+        field
+            .default_value
+            .as_ref()
+            .map_or(text, |value| value.as_bytes())
+    } else {
+        text
+    };
+    ValueConverter::parse_scalar(scalar, text, &field.name)
+}
+
 pub struct XmlDeserializer;
 
 fn is_nil_element(e: &BytesStart) -> bool {
@@ -245,7 +274,10 @@ fn append_general_ref(
     } else if let Some(s) = quick_xml::escape::resolve_xml_entity(e.as_ref()) {
         s.as_bytes()
     } else {
-        e.as_ref().as_bytes()
+        return Err(PolyXmlError::SchemaError(format!(
+            "Unsupported general entity reference: &{};",
+            e.as_ref()
+        )));
     };
 
     if active_scalar {
@@ -598,20 +630,20 @@ impl XmlDeserializer {
                     {
                         let field = &current_schema.fields[field_idx];
                         match &field.val_type {
-                            ValueType::Scalar(_) => {
+                            ValueType::Scalar(scalar) => {
                                 let val = if is_nil {
                                     PolyValue::Null
                                 } else {
-                                    PolyValue::String(String::new())
+                                    parse_field_scalar(scalar, b"", field)?
                                 };
                                 stack.last_mut().unwrap().values[field_idx] = Some(val);
                             }
                             ValueType::List(inner) => match inner.as_ref() {
-                                ValueType::Scalar(_) => {
+                                ValueType::Scalar(scalar) => {
                                     let val = if is_nil {
                                         PolyValue::Null
                                     } else {
-                                        PolyValue::String(String::new())
+                                        parse_field_scalar(scalar, b"", field)?
                                     };
                                     stack.last_mut().unwrap().push_list_item(field_idx, val);
                                 }
@@ -779,6 +811,15 @@ impl XmlDeserializer {
                     }
                 }
                 Ok(Event::GeneralRef(ref e)) => {
+                    // Entity validity is independent of whether a field is retained.
+                    if !e.is_char_ref()
+                        && quick_xml::escape::resolve_xml_entity(e.as_ref()).is_none()
+                    {
+                        return Err(PolyXmlError::SchemaError(format!(
+                            "Unsupported general entity reference: &{};",
+                            e.as_ref()
+                        )));
+                    }
                     if unknown_depth > 0 {
                         continue;
                     }
@@ -848,9 +889,8 @@ impl XmlDeserializer {
                     } else if let Some((field_idx, ref scalar_type, is_list)) =
                         active_scalar_field.take()
                     {
-                        let field_name = &stack.last().unwrap().schema.fields[field_idx].name;
-                        let parsed_val =
-                            ValueConverter::parse_scalar(scalar_type, &text_buf, field_name)?;
+                        let field = &stack.last().unwrap().schema.fields[field_idx];
+                        let parsed_val = parse_field_scalar(scalar_type, &text_buf, field)?;
                         let frame = stack.last_mut().unwrap();
                         if is_list {
                             frame.push_list_item(field_idx, parsed_val);

{polyxml-0.33.6 → polyxml-0.33.7}/crates/polyxml-core/src/schema.rs

@@ -65,6 +65,7 @@ pub struct FieldSchema {
     pub kind: FieldKind,
     pub val_type: ValueType,
     pub required: bool,
+    pub default_value: Option<String>,
 }
 
 impl FieldSchema {
@@ -81,6 +82,7 @@ impl FieldSchema {
             kind,
             val_type,
             required: false,
+            default_value: None,
         }
     }
 
@@ -351,6 +353,7 @@ impl ModelSchema {
             }
 
             let mut field_schema = FieldSchema::new(&f.name, f.xml_name.as_bytes(), kind, val_type);
+            field_schema.default_value = f.default_value.clone();
             if let Some(ref ns) = f.namespace {
                 field_schema = field_schema.namespace(ns);
             }

{polyxml-0.33.6 → polyxml-0.33.7}/crates/polyxml-core/tests/test_csharp_codegen.rs

@@ -1232,3 +1232,49 @@ fn test_csharp_sequence_nested_inside_choice_codegen() {
     assert!(code.contains("string? Alternative = null"));
     assert!(code.contains("public record RootTypeSequence"));
 }
+
+#[test]
+fn element_defaults_preserve_absence_and_empty_presence() {
+    let ir = polyxml::schema_parser::XsdParser::new()
+        .parse_str(include_str!(
+            "../../../research/fixtures/element_defaults.xsd"
+        ))
+        .unwrap();
+    for use_records in [true, false] {
+        let temp = tempdir().unwrap();
+        fs::write(temp.path().join("App.csproj"), r#"<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net8.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup></Project>"#).unwrap();
+        fs::write(
+            temp.path().join("Models.cs"),
+            CSharpCodegen::new(CSharpOptions {
+                namespace: "Models".into(),
+                use_records,
+                ..Default::default()
+            })
+            .generate_module(&ir),
+        )
+        .unwrap();
+        fs::write(temp.path().join("Program.cs"), r#"using Models;using System.Xml.Serialization;
+var serializer=new XmlSerializer(typeof(Root));
+foreach(var document in new[]{"<Root/>","<Root><Flag/><Count></Count><Label/></Root>"}){
+var root=(Root)serializer.Deserialize(new StringReader(document))!;
+var present=document.Contains("Flag");
+if(present&&(root.Flag!=false||root.Count!=42||root.Label!="fallback"))throw new Exception("defaults missing");
+if(!present&&(root.Flag!=null||root.Count!=null||root.Label!=null))throw new Exception("absence lost");
+var writer=new StringWriter();serializer.Serialize(writer,root);
+if(!present&&writer.ToString().Contains("<Flag"))throw new Exception("absent value serialized");
+if(present&&!writer.ToString().Contains("<Flag>false</Flag>"))throw new Exception(writer.ToString());
+}"#).unwrap();
+        let _lock = DOTNET_LOCK.lock().unwrap();
+        let result = dotnet_command()
+            .arg("run")
+            .current_dir(temp.path())
+            .output()
+            .unwrap();
+        assert!(
+            result.status.success(),
+            "{}{}",
+            String::from_utf8_lossy(&result.stdout),
+            String::from_utf8_lossy(&result.stderr)
+        );
+    }
+}

{polyxml-0.33.6 → polyxml-0.33.7}/crates/polyxml-core/tests/test_python_codegen.rs

@@ -162,7 +162,7 @@ fn test_python_dataclass_codegen() {
     // Check fields
     assert!(code.contains("id: int = field(metadata={\"type\": \"Attribute\", \"name\": \"id\", \"json_name\": \"id\"})"));
     assert!(code.contains("type_: str | None = field(default=None, metadata={\"type\": \"Element\", \"name\": \"type\", \"json_name\": \"type\", \"namespace\": \"https://example.com/shop\", \"nillable\": True})"));
-    assert!(code.contains("status: OrderStatus = field(default=\"pending\", metadata={\"type\": \"Element\", \"name\": \"status\", \"json_name\": \"status\"})"));
+    assert!(code.contains("status: OrderStatus = field(default=\"pending\", metadata={\"type\": \"Element\", \"name\": \"status\", \"json_name\": \"status\", \"default\": \"pending\"})"));
     assert!(code.contains("tags: list[str] = field(default_factory=list, metadata={\"type\": \"Element\", \"name\": \"tag\", \"json_name\": \"tag\"})"));
 }
 

polyxml-0.33.7/crates/polyxml-core/tests/test_qualified_attributes.rs

@@ -0,0 +1,80 @@
+use polyxml::codegen::{
+    csharp::{CSharpCodegen, CSharpOptions},
+    go::{GoCodegen, GoOptions},
+};
+use polyxml::schema_parser::XsdParser;
+use std::{fs, process::Command};
+use tempfile::tempdir;
+
+#[test]
+fn global_attribute_references_round_trip_by_namespace() {
+    let mut parser = XsdParser::new();
+    let ir = parser
+        .parse_file(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../research/fixtures/wave6/xlink_shared_attribute/root.xsd"
+        ))
+        .unwrap();
+    let temp = tempdir().unwrap();
+    fs::write(temp.path().join("go.mod"), "module attrs\n\ngo 1.22\n").unwrap();
+    fs::write(
+        temp.path().join("models.go"),
+        GoCodegen::new(GoOptions::default()).generate_module(&ir),
+    )
+    .unwrap();
+    fs::write(temp.path().join("models_test.go"), r#"package models
+import("encoding/xml";"testing";"strings";"io")
+func TestAttributes(t *testing.T) {
+ for _, document := range []string{`<Links xmlns:xl="http://www.w3.org/1999/xlink"><Resource xl:type="resource"/><Arc xl:type="arc"/></Links>`, `<Links><Resource xmlns:other="http://www.w3.org/1999/xlink" other:type="resource"/><Arc xmlns:a="http://www.w3.org/1999/xlink" a:type="arc"/></Links>`} {
+ var root Links; if err:=xml.Unmarshal([]byte(document),&root);err!=nil{t.Fatal(err)}
+ data,err:=xml.Marshal(root);if err!=nil{t.Fatal(err)}
+ decoder:=xml.NewDecoder(strings.NewReader(string(data)));count:=0
+ for {token,err:=decoder.Token();if err==io.EOF{break};if err!=nil{t.Fatal(err)};if start,ok:=token.(xml.StartElement);ok{for _,attr:=range start.Attr{if attr.Name.Space=="http://www.w3.org/1999/xlink"&&attr.Name.Local=="type"{count++;if attr.Value!="resource"&&attr.Value!="arc"{t.Fatal(attr)}}}}}
+ if count!=2{t.Fatalf("attributes lost: %s",data)}
+ }
+}"#).unwrap();
+    let result = Command::new("go")
+        .args(["test", "./..."])
+        .current_dir(temp.path())
+        .output()
+        .unwrap();
+    assert!(
+        result.status.success(),
+        "{}{}",
+        String::from_utf8_lossy(&result.stdout),
+        String::from_utf8_lossy(&result.stderr)
+    );
+    for use_records in [true, false] {
+        let temp = tempdir().unwrap();
+        fs::write(temp.path().join("App.csproj"), r#"<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net8.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup></Project>"#).unwrap();
+        fs::write(
+            temp.path().join("Models.cs"),
+            CSharpCodegen::new(CSharpOptions {
+                namespace: "Models".into(),
+                use_records,
+                ..Default::default()
+            })
+            .generate_module(&ir),
+        )
+        .unwrap();
+        fs::write(temp.path().join("Program.cs"), r#"using System.Xml.Serialization;using System.Xml.Linq;using Models;
+var serializer=new XmlSerializer(typeof(Links));
+foreach(var document in new[]{"<Links xmlns:xl='http://www.w3.org/1999/xlink'><Resource xl:type='resource'/><Arc xl:type='arc'/></Links>","<Links><Resource xmlns:b='http://www.w3.org/1999/xlink' b:type='resource'/><Arc xmlns:c='http://www.w3.org/1999/xlink' c:type='arc'/></Links>"}){
+var root=(Links)serializer.Deserialize(new StringReader(document))!;
+var writer=new StringWriter();serializer.Serialize(writer,root);
+var xml=XDocument.Parse(writer.ToString());XNamespace ns="http://www.w3.org/1999/xlink";
+if((string?)xml.Root!.Element("Resource")!.Attribute(ns+"type")!="resource"||(string?)xml.Root.Element("Arc")!.Attribute(ns+"type")!="arc")throw new Exception(writer.ToString());
+}"#).unwrap();
+        let result = Command::new("dotnet")
+            .arg("run")
+            .current_dir(temp.path())
+            .output()
+            .unwrap();
+        assert!(
+            result.status.success(),
+            "{}{}",
+            String::from_utf8_lossy(&result.stdout),
+            String::from_utf8_lossy(&result.stderr)
+        );
+    }
+}

{polyxml-0.33.6 → polyxml-0.33.7}/crates/polyxml-core/tests/test_security.rs

@@ -162,3 +162,30 @@ fn test_malformed_unclosed_cdata_rejection() {
     let bad_xml = br#"<Doc><body><![CDATA[unclosed cdata</body></Doc>"#;
     assert!(deserialize(bad_xml, schema).is_err());
 }
+
+#[test]
+fn unsupported_general_entities_are_rejected() {
+    let schema = ModelSchema::builder("Document")
+        .field(FieldSchema::new(
+            "payload",
+            b"Payload",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .build();
+    for xml in [
+        "<Document><Payload>&audit;</Payload></Document>",
+        "<!DOCTYPE Document [<!ENTITY audit 'EXPECTED'>]><Document><Payload>&audit;</Payload></Document>",
+        "<!DOCTYPE Document [<!ENTITY audit SYSTEM 'file:///nonexistent/sentinel'>]><Document><Payload>&audit;</Payload></Document>",
+        "<Document><Unknown>&audit;</Unknown></Document>",
+    ] {
+        let error = deserialize(xml.as_bytes(), Arc::clone(&schema)).unwrap_err();
+        assert!(error.to_string().contains("Unsupported general entity reference"), "{error}");
+    }
+    let value = deserialize(
+        b"<Document><Payload>&amp;&#65;&#x42;</Payload></Document>",
+        schema,
+    )
+    .unwrap();
+    assert_eq!(value.get("payload"), Some(&PolyValue::String("&AB".into())));
+}

{polyxml-0.33.6 → polyxml-0.33.7}/crates/polyxml-python/src/lib.rs

@@ -417,6 +417,10 @@ fn extract_schema_from_class<'py>(
             });
 
             let mut field_schema = FieldSchema::new(py_name, xml_name.as_bytes(), kind, val_type);
+            field_schema.default_value = meta
+                .as_ref()
+                .and_then(|m| m.get_item("default").ok())
+                .and_then(|v| v.extract::<String>().ok());
             if let Some(ns) = field_ns {
                 field_schema = field_schema.namespace(ns);
             }
@@ -494,6 +498,11 @@ fn extract_schema_from_class<'py>(
             });
 
             let mut field_schema = FieldSchema::new(py_name, xml_name.as_bytes(), kind, val_type);
+            field_schema.default_value = field_obj
+                .getattr("metadata")
+                .ok()
+                .and_then(|m| m.get_item("default").ok())
+                .and_then(|v| v.extract::<String>().ok());
             if let Some(ns) = field_ns {
                 field_schema = field_schema.namespace(ns);
             }

{polyxml-0.33.6 → polyxml-0.33.7}/crates/polyxml-python/tests/test_generated_models.py

@@ -531,3 +531,70 @@ def test_codecs_flag_disabled():
         mod = _load_module_from_file("gen_no_codecs", out_dir / "warehouse.py")
         assert not hasattr(mod.Inventory, "from_xml")
         assert not hasattr(mod.Inventory, "to_xml")
+
+
+@pytest.mark.parametrize("backend", ["dataclass", "pydantic"])
+def test_generated_models_reject_general_entities(tmp_path, backend):
+    schema = pathlib.Path(__file__).resolve().parents[3] / "research/fixtures/wave7/xxe_text.xsd"
+    subprocess.run(
+        [
+            str(_get_polyxml_bin()),
+            "generate",
+            str(schema),
+            "--lang",
+            "python",
+            "--backend",
+            backend,
+            "--out",
+            str(tmp_path),
+        ],
+        check=True,
+        capture_output=True,
+    )
+    module = _load_module_from_file(f"entities_{backend}", tmp_path / "xxe_text.py")
+    sentinel = tmp_path / "sentinel.txt"
+    sentinel.write_text("PRIVATE_SENTINEL_VALUE")
+    for declaration in [
+        "",
+        "<!DOCTYPE Document [<!ENTITY audit 'EXPECTED'>]>",
+        f"<!DOCTYPE Document [<!ENTITY audit SYSTEM '{sentinel.as_uri()}'>]>",
+    ]:
+        with pytest.raises(ValueError, match="Unsupported general entity reference"):
+            module.Document.from_xml(
+                declaration + "<Document><Payload>&audit;</Payload></Document>"
+            )
+    model = module.Document.from_xml("<Document><Payload>&amp;&#65;&#x42;</Payload></Document>")
+    assert model.payload == "&AB"
+
+
+@pytest.mark.parametrize("backend", ["dataclass", "pydantic"])
+def test_element_defaults_preserve_absence(tmp_path, backend):
+    schema = pathlib.Path(__file__).resolve().parents[3] / "research/fixtures/element_defaults.xsd"
+    subprocess.run(
+        [
+            str(_get_polyxml_bin()),
+            "generate",
+            str(schema),
+            "--lang",
+            "python",
+            "--backend",
+            backend,
+            "--out",
+            str(tmp_path),
+        ],
+        check=True,
+        capture_output=True,
+    )
+    module = _load_module_from_file(f"defaults_{backend}", tmp_path / "element_defaults.py")
+    absent = module.Root.from_xml("<Root/>")
+    assert (absent.flag, absent.count, absent.label, absent.mode) == (None, None, None, "auto")
+    assert ET.fromstring(absent.to_xml()).find("Flag") is None
+    for document in [
+        "<Root><Flag/><Count></Count><Label/></Root>",
+        "<Root><Flag></Flag><Count/><Label></Label></Root>",
+    ]:
+        present = module.Root.from_xml(document)
+        assert (present.flag, present.count, present.label) == (False, 42, "fallback")
+        encoded = present.to_xml()
+        assert ET.fromstring(encoded).findtext("Flag") == "false"
+        assert module.Root.from_xml(encoded).count == 42

{polyxml-0.33.6 → polyxml-0.33.7}/pyproject.toml

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