polyxml 0.33.0__tar.gz → 0.33.2__tar.gz

{polyxml-0.33.0 → polyxml-0.33.2}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.33.0"
+version = "0.33.2"
 dependencies = [
  "criterion",
  "heck",
@@ -629,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.33.0"
+version = "0.33.2"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.33.0"
+version = "0.33.2"
 dependencies = [
  "clap",
  "glob",
@@ -650,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.33.0"
+version = "0.33.2"
 dependencies = [
  "napi",
  "napi-build",
@@ -660,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.33.0"
+version = "0.33.2"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -670,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.33.0"
+version = "0.33.2"
 dependencies = [
  "polyxml",
  "quick-xml",
@@ -913,9 +913,9 @@ checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
 
 [[package]]
 name = "smallvec"
-version = "1.16.1"
+version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
+checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e"
 
 [[package]]
 name = "strsim"
@@ -966,18 +966,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.20"
+version = "2.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.20"
+version = "2.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1063,9 +1063,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf"
+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1076,9 +1076,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed"
+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1086,9 +1086,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a"
+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -1099,9 +1099,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e"
+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
 dependencies = [
  "unicode-ident",
 ]

{polyxml-0.33.0 → polyxml-0.33.2}/Cargo.toml

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

{polyxml-0.33.0 → polyxml-0.33.2}/PKG-INFO

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

{polyxml-0.33.0 → polyxml-0.33.2}/crates/polyxml-core/src/codegen/csharp/mod.rs

@@ -307,6 +307,7 @@ impl CSharpCodegen {
             writeln!(out, "using System.Text.RegularExpressions;").unwrap();
         }
         if self.options.emit_xml_attributes {
+            writeln!(out, "using System.Xml;").unwrap();
             writeln!(out, "using System.Xml.Serialization;").unwrap();
         }
         if self.options.emit_json_attributes || self.options.emit_source_gen {
@@ -582,7 +583,7 @@ impl CSharpCodegen {
             }
             writeln!(
                 out,
-                "{}public sealed record {}([property: XmlText] {} Value) : IValidatableObject",
+                "{}public record {}([property: XmlText] {} Value) : IValidatableObject",
                 indent, type_name, base_type
             )
             .unwrap();
@@ -819,6 +820,16 @@ impl CSharpCodegen {
                 TypeRef::Primitive(PrimitiveType::Date)
             ) {
                 "item.Value.ToString(\"yyyy-MM-dd\", System.Globalization.CultureInfo.InvariantCulture)".to_string()
+            } else if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(PrimitiveType::DateTime)
+            ) {
+                "System.Xml.XmlConvert.ToString(item.Value)".to_string()
+            } else if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(PrimitiveType::Time)
+            ) {
+                "item.Value.ToString(\"HH:mm:ssK\", System.Globalization.CultureInfo.InvariantCulture)".to_string()
             } else {
                 match &branch.type_ref {
                 TypeRef::Named(qname) if matches!(ir.types.get(qname), Some(TypeDef::Enum(_))) => "item.Value.ToXmlValue()".to_string(),
@@ -1039,7 +1050,7 @@ impl CSharpCodegen {
                 );
             }
             if self.options.emit_validation {
-                self.emit_struct_validator(out, s, &prop_names, indent);
+                self.emit_struct_validator(out, s, ir, &prop_names, indent);
             }
             writeln!(out, "{}}}\n", indent).unwrap();
             return;
@@ -1093,7 +1104,7 @@ impl CSharpCodegen {
                 .unwrap();
             }
             if self.options.emit_validation {
-                self.emit_struct_validator(out, s, &prop_names, indent);
+                self.emit_struct_validator(out, s, ir, &prop_names, indent);
             }
             writeln!(out, "{}}}\n", indent).unwrap();
             return;
@@ -1109,7 +1120,7 @@ impl CSharpCodegen {
                 )
                 .unwrap();
                 writeln!(out, "{}{{", indent).unwrap();
-                self.emit_struct_validator(out, s, &prop_names, indent);
+                self.emit_struct_validator(out, s, ir, &prop_names, indent);
                 writeln!(out, "{}}}", indent).unwrap();
             } else {
                 writeln!(
@@ -1182,7 +1193,7 @@ impl CSharpCodegen {
 
         // IValidatableObject implementation
         if self.options.emit_validation {
-            self.emit_struct_validator(out, s, &prop_names, indent);
+            self.emit_struct_validator(out, s, ir, &prop_names, indent);
         }
 
         writeln!(out, "{}}}\n", indent).unwrap();
@@ -1221,17 +1232,23 @@ impl CSharpCodegen {
         &self,
         out: &mut String,
         s: &StructDef,
+        ir: &SchemaIR,
         prop_names: &[String],
         indent: &str,
     ) {
         let _struct_name = type_ident(&s.qname);
+        let has_struct_base = s
+            .base_type
+            .as_ref()
+            .map(|b| matches!(ir.types.get(b), Some(TypeDef::Struct(_))))
+            .unwrap_or(false);
         let new_kw = if !self.options.use_records {
-            if s.base_type.is_some() {
+            if has_struct_base {
                 "override "
             } else {
                 "virtual "
             }
-        } else if s.base_type.is_some() {
+        } else if has_struct_base {
             "new "
         } else {
             ""
@@ -1244,7 +1261,7 @@ impl CSharpCodegen {
         .unwrap();
         writeln!(out, "{}    {{", indent).unwrap();
 
-        if !self.options.use_records && s.base_type.is_some() {
+        if !self.options.use_records && has_struct_base {
             writeln!(out, "{}        foreach (var result in base.Validate(validationContext)) yield return result;", indent).unwrap();
         }
         let mut has_checks = false;
@@ -1345,6 +1362,9 @@ impl CSharpCodegen {
     }
 
     fn map_field_type(&self, f: &FieldDef, ir: &SchemaIR) -> String {
+        if f.kind == FieldKind::AnyAttribute {
+            return "System.Xml.XmlAttribute[]?".to_string();
+        }
         let base_type = match &f.type_ref {
             TypeRef::Primitive(p) => self.context.map_primitive(*p).to_string(),
             TypeRef::Named(qn) => {

{polyxml-0.33.0 → polyxml-0.33.2}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -273,14 +273,12 @@ impl GoCodegen {
                 }));
         let mut has_fmt = has_patterns;
         let mut has_io = false;
-        let mut has_xml = self.options.emit_xml_tags;
 
         // Check types for time.Time
         for type_def in ir.emitted_types() {
             match type_def {
                 TypeDef::Struct(s) => {
                     if s.is_mixed && self.options.emit_xml_tags {
-                        has_xml = true;
                         has_fmt = true;
                         has_io = true;
                     }
@@ -310,11 +308,9 @@ impl GoCodegen {
                     if self.options.validate_choice_exclusivity && !u.is_lexical() {
                         has_fmt = true;
                         has_io = true;
-                        has_xml = true;
                     }
                     if u.is_lexical() {
                         has_fmt = true;
-                        has_xml = true;
                     }
                 }
                 TypeDef::Simple(st) => {
@@ -354,7 +350,7 @@ impl GoCodegen {
         writeln!(out, "package {}\n", pkg).unwrap();
 
         let mut imports = Vec::new();
-        if has_xml {
+        if body.contains("xml.") {
             imports.push("\"encoding/xml\"");
         }
         if self.options.emit_xml_tags
@@ -451,6 +447,14 @@ impl GoCodegen {
                 self.emit_struct(out, s, ir);
             }
         }
+
+        let has_any_element = ir.emitted_types().any(|t| match t {
+            TypeDef::Struct(s) => s.fields.iter().any(|f| f.kind == FieldKind::Any),
+            _ => false,
+        });
+        if has_any_element {
+            out.push_str("// AnyElement represents an unmapped wildcard XML element (xs:any).\ntype AnyElement struct {\n    XMLName xml.Name\n    Attrs   []xml.Attr `xml:\",any,attr\" json:\"attrs,omitempty\"`\n    Content string     `xml:\",innerxml\" json:\"content,omitempty\"`\n}\n\n");
+        }
     }
 
     fn emit_simple_type(&self, out: &mut String, simple: &SimpleTypeDef, ir: &SchemaIR) {
@@ -813,6 +817,12 @@ impl GoCodegen {
             };
             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);
+            } 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);
+            } 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);
             } else if let Some(kind) = numeric {
                 let parse = match kind {
                     "signed" => "strconv.ParseInt(value, 10, 64)",
@@ -880,6 +890,16 @@ impl GoCodegen {
                 TypeRef::Primitive(PrimitiveType::Date)
             ) {
                 format!("c.{}.Format(\"2006-01-02\")", field)
+            } else if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(PrimitiveType::DateTime)
+            ) {
+                format!("c.{}.Format(time.RFC3339)", field)
+            } else if matches!(
+                super::primitive_base(&branch.type_ref, ir),
+                TypeRef::Primitive(PrimitiveType::Time)
+            ) {
+                format!("c.{}.Format(\"15:04:05Z07:00\")", field)
             } else {
                 format!("fmt.Sprint(*c.{})", field)
             };
@@ -1089,6 +1109,18 @@ impl GoCodegen {
     }
 
     fn resolve_field_type(&self, f: &FieldDef) -> String {
+        if f.kind == FieldKind::AnyAttribute {
+            return "[]xml.Attr".to_string();
+        }
+        if f.kind == FieldKind::Any {
+            if f.cardinality.is_list() {
+                return "[]AnyElement".to_string();
+            } else if f.is_cycle_cut || f.cardinality.is_optional() || f.nillable {
+                return "*AnyElement".to_string();
+            } else {
+                return "AnyElement".to_string();
+            }
+        }
         let base_type = self.context.map_type_ref(&f.type_ref);
 
         if f.cardinality.is_list() {
@@ -1134,32 +1166,50 @@ impl GoCodegen {
         }
 
         if self.options.emit_json_tags || self.options.backend == GoBackend::Sonic {
-            let is_opt = f.cardinality.is_optional() || f.nillable;
-            let raw_json_name = if f.kind == FieldKind::Text {
-                "value".to_string()
-            } else if f.xml_name.is_empty() {
-                f.name.clone()
+            if f.kind == FieldKind::AnyAttribute {
+                if self.options.emit_json_tags {
+                    parts.push("json:\"-\"".to_string());
+                }
+                if self.options.backend == GoBackend::Sonic {
+                    parts.push("sonic:\"-\"".to_string());
+                }
+            } else if f.kind == FieldKind::Any {
+                let is_opt = f.cardinality.is_optional() || f.nillable;
+                let tag = if is_opt { "any,omitempty" } else { "any" };
+                if self.options.emit_json_tags {
+                    parts.push(format!("json:\"{}\"", tag));
+                }
+                if self.options.backend == GoBackend::Sonic {
+                    parts.push(format!("sonic:\"{}\"", tag));
+                }
             } else {
-                f.xml_name.clone()
-            };
-            let mut json_name = raw_json_name.clone();
-            let mut counter = 2;
-            while seen_json.contains(&json_name) {
-                json_name = format!("{}_{}", raw_json_name, counter);
-                counter += 1;
-            }
-            seen_json.insert(json_name.clone());
+                let is_opt = f.cardinality.is_optional() || f.nillable;
+                let raw_json_name = if f.kind == FieldKind::Text {
+                    "value".to_string()
+                } else if f.xml_name.is_empty() {
+                    f.name.clone()
+                } else {
+                    f.xml_name.clone()
+                };
+                let mut json_name = raw_json_name.clone();
+                let mut counter = 2;
+                while seen_json.contains(&json_name) {
+                    json_name = format!("{}_{}", raw_json_name, counter);
+                    counter += 1;
+                }
+                seen_json.insert(json_name.clone());
 
-            let json_val = if is_opt {
-                format!("{},omitempty", json_name)
-            } else {
-                json_name
-            };
-            if self.options.emit_json_tags {
-                parts.push(format!("json:\"{}\"", json_val));
-            }
-            if self.options.backend == GoBackend::Sonic {
-                parts.push(format!("sonic:\"{}\"", json_val));
+                let json_val = if is_opt {
+                    format!("{},omitempty", json_name)
+                } else {
+                    json_name
+                };
+                if self.options.emit_json_tags {
+                    parts.push(format!("json:\"{}\"", json_val));
+                }
+                if self.options.backend == GoBackend::Sonic {
+                    parts.push(format!("sonic:\"{}\"", json_val));
+                }
             }
         }
 

{polyxml-0.33.0 → polyxml-0.33.2}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -638,7 +638,11 @@ impl PythonCodegen {
             if has_body {
                 out.push('\n');
             }
-            out.push_str("    class Meta:\n");
+            if let Some(ref base_name) = struct_base {
+                let _ = writeln!(out, "    class Meta({}.Meta):", base_name);
+            } else {
+                out.push_str("    class Meta:\n");
+            }
             let _ = writeln!(out, "        name = \"{}\"", s.qname.local);
             if let Some(ref ns) = s.qname.namespace {
                 let _ = writeln!(out, "        namespace = \"{}\"", ns);
@@ -692,7 +696,7 @@ impl PythonCodegen {
             let mut seen_fields = HashSet::new();
             for field in &s.fields {
                 let py_field_name = self.unique_field_name(&field.name, &mut seen_fields);
-                self.emit_field(out, field, &py_field_name);
+                self.emit_field(out, field, &py_field_name, ir);
             }
             has_body = true;
         }
@@ -754,7 +758,7 @@ impl PythonCodegen {
         candidate
     }
 
-    fn emit_field(&self, out: &mut String, field: &FieldDef, py_name: &str) {
+    fn emit_field(&self, out: &mut String, field: &FieldDef, py_name: &str, ir: &SchemaIR) {
         let is_list = field.cardinality.is_list() || field.type_ref.is_list();
         let unwrapped_ref = match &field.type_ref {
             TypeRef::List(inner) => inner.as_ref(),
@@ -765,10 +769,10 @@ impl PythonCodegen {
 
         let (field_type, field_call) = match self.options.backend {
             PythonBackend::Dataclass | PythonBackend::Aot => {
-                self.format_dataclass_field(field, is_list, &inner_type, &meta_dict)
+                self.format_dataclass_field(field, is_list, &inner_type, &meta_dict, ir)
             }
             PythonBackend::Pydantic => {
-                self.format_pydantic_field(field, py_name, is_list, &inner_type, &meta_dict)
+                self.format_pydantic_field(field, py_name, is_list, &inner_type, &meta_dict, ir)
             }
         };
 
@@ -785,7 +789,27 @@ impl PythonCodegen {
         is_list: bool,
         base_type: &str,
         meta_dict: &str,
+        ir: &SchemaIR,
     ) -> (String, String) {
+        let simple_content = match &field.type_ref {
+            TypeRef::Named(qname) => match ir.find_type(qname) {
+                Some(TypeDef::Struct(s)) => s
+                    .fields
+                    .iter()
+                    .find(|f| f.kind == FieldKind::Text)
+                    .map(|tf| (tf.name.clone(), tf.type_ref.clone())),
+                _ => None,
+            },
+            _ => None,
+        };
+
+        if field.kind == FieldKind::AnyAttribute {
+            return (
+                "dict[str, str]".to_string(),
+                format!("field(default_factory=dict, metadata={})", meta_dict),
+            );
+        }
+
         if is_list {
             (
                 format!("list[{}]", base_type),
@@ -793,7 +817,7 @@ impl PythonCodegen {
             )
         } else if field.cardinality.is_optional() || field.nillable {
             if let Some(ref def) = field.default_value {
-                let py_val = self.format_default_value(def, &field.type_ref);
+                let py_val = self.format_default_value(def, &field.type_ref, ir);
                 (
                     format!("{} | None", base_type),
                     format!("field(default={}, metadata={})", py_val, meta_dict),
@@ -805,11 +829,22 @@ impl PythonCodegen {
                 )
             }
         } else if let Some(ref def) = field.default_value {
-            let py_val = self.format_default_value(def, &field.type_ref);
-            (
-                base_type.to_string(),
-                format!("field(default={}, metadata={})", py_val, meta_dict),
-            )
+            if let Some((text_name, text_type)) = simple_content {
+                let py_val = self.format_default_value(def, &text_type, ir);
+                (
+                    base_type.to_string(),
+                    format!(
+                        "field(default_factory=lambda: {}({}={}), metadata={})",
+                        base_type, text_name, py_val, meta_dict
+                    ),
+                )
+            } else {
+                let py_val = self.format_default_value(def, &field.type_ref, ir);
+                (
+                    base_type.to_string(),
+                    format!("field(default={}, metadata={})", py_val, meta_dict),
+                )
+            }
         } else {
             (
                 base_type.to_string(),
@@ -825,6 +860,7 @@ impl PythonCodegen {
         is_list: bool,
         base_type: &str,
         meta_dict: &str,
+        ir: &SchemaIR,
     ) -> (String, String) {
         let facet_args = field
             .facets
@@ -843,6 +879,25 @@ impl PythonCodegen {
         }
         let extra_clause = clauses.join(", ");
 
+        let simple_content = match &field.type_ref {
+            TypeRef::Named(qname) => match ir.find_type(qname) {
+                Some(TypeDef::Struct(s)) => s
+                    .fields
+                    .iter()
+                    .find(|f| f.kind == FieldKind::Text)
+                    .map(|tf| (tf.name.clone(), tf.type_ref.clone())),
+                _ => None,
+            },
+            _ => None,
+        };
+
+        if field.kind == FieldKind::AnyAttribute {
+            return (
+                "dict[str, str]".to_string(),
+                format!("Field(default_factory=dict, {})", extra_clause),
+            );
+        }
+
         if is_list {
             (
                 format!("list[{}]", base_type),
@@ -850,7 +905,7 @@ impl PythonCodegen {
             )
         } else if field.cardinality.is_optional() || field.nillable {
             if let Some(ref def) = field.default_value {
-                let py_val = self.format_default_value(def, &field.type_ref);
+                let py_val = self.format_default_value(def, &field.type_ref, ir);
                 (
                     format!("{} | None", base_type),
                     format!("Field(default={}, {})", py_val, extra_clause),
@@ -862,11 +917,22 @@ impl PythonCodegen {
                 )
             }
         } else if let Some(ref def) = field.default_value {
-            let py_val = self.format_default_value(def, &field.type_ref);
-            (
-                base_type.to_string(),
-                format!("Field(default={}, {})", py_val, extra_clause),
-            )
+            if let Some((text_name, text_type)) = simple_content {
+                let py_val = self.format_default_value(def, &text_type, ir);
+                (
+                    base_type.to_string(),
+                    format!(
+                        "Field(default_factory=lambda: {}({}={}), {})",
+                        base_type, text_name, py_val, extra_clause
+                    ),
+                )
+            } else {
+                let py_val = self.format_default_value(def, &field.type_ref, ir);
+                (
+                    base_type.to_string(),
+                    format!("Field(default={}, {})", py_val, extra_clause),
+                )
+            }
         } else {
             (
                 base_type.to_string(),
@@ -880,7 +946,8 @@ impl PythonCodegen {
             FieldKind::Element => "Element",
             FieldKind::Attribute => "Attribute",
             FieldKind::Text => "Text",
-            FieldKind::Any | FieldKind::AnyAttribute => "Wildcard",
+            FieldKind::Any => "Wildcard",
+            FieldKind::AnyAttribute => "Attributes",
         };
 
         let mut parts = Vec::new();
@@ -901,8 +968,9 @@ impl PythonCodegen {
         format!("{{{}}}", parts.join(", "))
     }
 
-    fn format_default_value(&self, val: &str, type_ref: &TypeRef) -> String {
-        match type_ref {
+    fn format_default_value(&self, val: &str, type_ref: &TypeRef, ir: &SchemaIR) -> String {
+        let base = super::primitive_base(type_ref, ir);
+        match base {
             TypeRef::Primitive(PrimitiveType::Boolean) => match val.trim() {
                 "true" | "1" => "True".to_string(),
                 "false" | "0" => "False".to_string(),