polyxml 0.10.0__tar.gz → 0.11.1__tar.gz

{polyxml-0.10.0 → polyxml-0.11.1}/Cargo.lock

@@ -395,7 +395,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.10.0"
+version = "0.11.1"
 dependencies = [
  "criterion",
  "lexical-core",
@@ -408,14 +408,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.10.0"
+version = "0.11.1"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-js"
-version = "0.10.0"
+version = "0.11.1"
 dependencies = [
  "napi",
  "napi-build",
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.10.0"
+version = "0.11.1"
 dependencies = [
  "lexical-core",
  "polyxml",

{polyxml-0.10.0 → polyxml-0.11.1}/Cargo.toml

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

{polyxml-0.10.0 → polyxml-0.11.1}/PKG-INFO

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

{polyxml-0.10.0 → polyxml-0.11.1}/crates/polyxml-core/src/parser.rs

@@ -189,12 +189,21 @@ impl XmlDeserializer {
         stack.push(root_frame);
 
         let mut active_scalar_field: Option<(usize, ScalarType, bool)> = None;
+        let mut unknown_depth: usize = 0;
         let mut text_buf: Vec<u8> = Vec::new();
         let mut buf = Vec::new();
 
         loop {
             match reader.read_event_into(&mut buf) {
                 Ok(Event::Start(ref e)) => {
+                    if unknown_depth > 0 {
+                        unknown_depth += 1;
+                        continue;
+                    }
+                    if active_scalar_field.is_some() {
+                        unknown_depth = 1;
+                        continue;
+                    }
                     if stack.len() >= max_depth {
                         return Err(PolyXmlError::MaxDepthExceeded {
                             max_depth,
@@ -245,9 +254,14 @@ impl XmlDeserializer {
                                 stack.push(frame);
                             }
                         }
+                    } else {
+                        unknown_depth = 1;
                     }
                 }
                 Ok(Event::Empty(ref e)) => {
+                    if unknown_depth > 0 || active_scalar_field.is_some() {
+                        continue;
+                    }
                     let local_name = e.local_name();
                     let is_nil = is_nil_element(e);
 
@@ -296,6 +310,9 @@ impl XmlDeserializer {
                     }
                 }
                 Ok(Event::Text(ref e)) => {
+                    if unknown_depth > 0 {
+                        continue;
+                    }
                     let unescaped = quick_xml::escape::unescape(e.as_ref())?;
                     if active_scalar_field.is_some() {
                         text_buf.extend_from_slice(unescaped.as_bytes());
@@ -306,6 +323,9 @@ impl XmlDeserializer {
                     }
                 }
                 Ok(Event::CData(ref e)) => {
+                    if unknown_depth > 0 {
+                        continue;
+                    }
                     if active_scalar_field.is_some() {
                         text_buf.extend_from_slice(e.as_ref().as_bytes());
                     } else if let Some(frame) = stack.last_mut() {
@@ -315,10 +335,17 @@ impl XmlDeserializer {
                     }
                 }
                 Ok(Event::GeneralRef(ref e)) => {
+                    if unknown_depth > 0 {
+                        continue;
+                    }
                     let frame_tb = stack.last_mut().and_then(|f| f.frame_text_buf.as_mut());
                     append_general_ref(e, active_scalar_field.is_some(), &mut text_buf, frame_tb)?;
                 }
                 Ok(Event::End(ref e)) => {
+                    if unknown_depth > 0 {
+                        unknown_depth -= 1;
+                        continue;
+                    }
                     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;

{polyxml-0.10.0 → polyxml-0.11.1}/crates/polyxml-core/src/schema.rs

@@ -61,6 +61,10 @@ impl FieldSchema {
         self
     }
 
+    pub fn with_namespace(self, ns: impl Into<String>) -> Self {
+        self.namespace(ns)
+    }
+
     pub fn required(mut self) -> Self {
         self.required = true;
         self
@@ -111,6 +115,10 @@ impl ModelSchemaBuilder {
         self
     }
 
+    pub fn with_namespace(self, ns: impl Into<String>) -> Self {
+        self.namespace(ns)
+    }
+
     pub fn field(mut self, field: FieldSchema) -> Self {
         self.fields.push(field);
         self

{polyxml-0.10.0 → polyxml-0.11.1}/crates/polyxml-core/src/serializer.rs

@@ -106,22 +106,34 @@ impl NamespaceContext {
     }
 
     pub fn qualify_element<'a>(&'a self, local_name: &'a str, ns: Option<&str>) -> Cow<'a, str> {
+        let clean_name = if let Some(pos) = local_name.find(':') {
+            &local_name[pos + 1..]
+        } else {
+            local_name
+        };
         if let Some(ns_uri) = ns {
             if let Some(prefix) = self.uri_to_prefix.get(ns_uri) {
                 if !prefix.is_empty() {
-                    return Cow::Owned(format!("{}:{}", prefix, local_name));
+                    return Cow::Owned(format!("{}:{}", prefix, clean_name));
                 }
+                return Cow::Borrowed(clean_name);
             }
         }
         Cow::Borrowed(local_name)
     }
 
     pub fn qualify_attribute<'a>(&'a self, local_name: &'a str, ns: Option<&str>) -> Cow<'a, str> {
+        let clean_name = if let Some(pos) = local_name.find(':') {
+            &local_name[pos + 1..]
+        } else {
+            local_name
+        };
         if let Some(ns_uri) = ns {
             if let Some(prefix) = self.uri_to_prefix.get(ns_uri) {
                 if !prefix.is_empty() {
-                    return Cow::Owned(format!("{}:{}", prefix, local_name));
+                    return Cow::Owned(format!("{}:{}", prefix, clean_name));
                 }
+                return Cow::Borrowed(clean_name);
             }
         }
         Cow::Borrowed(local_name)

polyxml-0.11.1/crates/polyxml-core/tests/test_conformance.rs

@@ -0,0 +1,493 @@
+use std::collections::HashMap;
+use std::fs;
+use std::io::BufReader;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType};
+use polyxml::value::PolyValue;
+use polyxml::{deserialize, serialize_with_options, XmlItemStream};
+
+fn fixture_path(name: &str) -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../tests/fixtures")
+        .join(name)
+}
+
+#[test]
+fn test_soap_envelope_conformance() {
+    let path = fixture_path("soap_envelope.xml");
+    let xml_bytes = fs::read(&path).expect("Failed to read soap_envelope.xml");
+
+    let sec_token_schema = ModelSchema::builder("SecurityToken")
+        .with_namespace("http://example.com/security")
+        .field(
+            FieldSchema::new(
+                "must_understand",
+                b"env:mustUnderstand",
+                FieldKind::Attribute,
+                ValueType::Scalar(ScalarType::Bool),
+            )
+            .with_namespace("http://www.w3.org/2003/05/soap-envelope"),
+        )
+        .field(FieldSchema::new(
+            "token",
+            b"token",
+            FieldKind::Text,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .build();
+
+    let header_schema = ModelSchema::builder("Header")
+        .with_namespace("http://www.w3.org/2003/05/soap-envelope")
+        .field(FieldSchema::new(
+            "security_token",
+            b"auth:SecurityToken",
+            FieldKind::Element,
+            ValueType::Nested(Arc::clone(&sec_token_schema)),
+        ))
+        .build();
+
+    let stock_schema = ModelSchema::builder("GetStockPrice")
+        .with_namespace("http://example.com/stock")
+        .field(FieldSchema::new(
+            "stock_name",
+            b"m:StockName",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "currency",
+            b"m:Currency",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "target_date",
+            b"m:TargetDate",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::XmlDate),
+        ))
+        .build();
+
+    let body_schema = ModelSchema::builder("Body")
+        .with_namespace("http://www.w3.org/2003/05/soap-envelope")
+        .field(FieldSchema::new(
+            "get_stock_price",
+            b"m:GetStockPrice",
+            FieldKind::Element,
+            ValueType::Nested(Arc::clone(&stock_schema)),
+        ))
+        .build();
+
+    let envelope_schema = ModelSchema::builder("Envelope")
+        .with_namespace("http://www.w3.org/2003/05/soap-envelope")
+        .field(FieldSchema::new(
+            "header",
+            b"env:Header",
+            FieldKind::Element,
+            ValueType::Nested(header_schema),
+        ))
+        .field(FieldSchema::new(
+            "body",
+            b"env:Body",
+            FieldKind::Element,
+            ValueType::Nested(body_schema),
+        ))
+        .build();
+
+    // 1. Deserialize
+    let val = deserialize(&xml_bytes, Arc::clone(&envelope_schema))
+        .expect("Failed to deserialize SOAP envelope");
+
+    let header = val.get("header").unwrap();
+    let sec = header.get("security_token").unwrap();
+    assert_eq!(sec.get("must_understand"), Some(&PolyValue::Bool(true)));
+    assert_eq!(
+        sec.get("token"),
+        Some(&PolyValue::String("sec-tok-987654321".into()))
+    );
+
+    let body = val.get("body").unwrap();
+    let req = body.get("get_stock_price").unwrap();
+    assert_eq!(
+        req.get("stock_name"),
+        Some(&PolyValue::String("ACME".into()))
+    );
+    assert_eq!(req.get("currency"), Some(&PolyValue::String("USD".into())));
+    assert_eq!(
+        req.get("target_date"),
+        Some(&PolyValue::String("2026-09-17".into()))
+    );
+
+    // 2. Roundtrip serialize with prefixes
+    let mut ns_map = HashMap::new();
+    ns_map.insert(
+        "http://www.w3.org/2003/05/soap-envelope".to_string(),
+        "env".to_string(),
+    );
+    ns_map.insert("http://example.com/stock".to_string(), "m".to_string());
+    ns_map.insert(
+        "http://example.com/security".to_string(),
+        "auth".to_string(),
+    );
+
+    let serialized = serialize_with_options(
+        "Envelope",
+        &val,
+        &envelope_schema,
+        Some(4),
+        Some(true),
+        Some(&ns_map),
+    )
+    .expect("Failed to serialize SOAP envelope");
+
+    let serialized_str = std::str::from_utf8(&serialized).unwrap();
+    assert!(serialized_str.contains("xmlns:env=\"http://www.w3.org/2003/05/soap-envelope\""));
+    assert!(serialized_str.contains("<env:Envelope"));
+    assert!(serialized_str.contains("<env:Header>"));
+    assert!(serialized_str.contains("<env:Body>"));
+
+    // 3. Re-deserialize to ensure semantic identity
+    let val_re = deserialize(&serialized, Arc::clone(&envelope_schema))
+        .expect("Failed to re-deserialize SOAP envelope");
+    assert_eq!(val, val_re);
+}
+
+#[test]
+fn test_atom_feed_conformance() {
+    let path = fixture_path("atom_feed.xml");
+    let xml_bytes = fs::read(&path).expect("Failed to read atom_feed.xml");
+
+    let author_schema = ModelSchema::builder("author")
+        .with_namespace("http://www.w3.org/2005/Atom")
+        .field(FieldSchema::new(
+            "name",
+            b"name",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "email",
+            b"email",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .build();
+
+    let entry_schema = ModelSchema::builder("entry")
+        .with_namespace("http://www.w3.org/2005/Atom")
+        .field(FieldSchema::new(
+            "title",
+            b"title",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "id",
+            b"id",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "updated",
+            b"updated",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::XmlDateTime),
+        ))
+        .field(FieldSchema::new(
+            "summary",
+            b"summary",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "author",
+            b"author",
+            FieldKind::Element,
+            ValueType::Nested(author_schema),
+        ))
+        .build();
+
+    let feed_schema = ModelSchema::builder("feed")
+        .with_namespace("http://www.w3.org/2005/Atom")
+        .field(FieldSchema::new(
+            "title",
+            b"title",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "id",
+            b"id",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "updated",
+            b"updated",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::XmlDateTime),
+        ))
+        .field(FieldSchema::new(
+            "entries",
+            b"entry",
+            FieldKind::Element,
+            ValueType::List(Box::new(ValueType::Nested(entry_schema))),
+        ))
+        .build();
+
+    // 1. Deserialize
+    let val =
+        deserialize(&xml_bytes, Arc::clone(&feed_schema)).expect("Failed to deserialize Atom feed");
+
+    assert_eq!(
+        val.get("title"),
+        Some(&PolyValue::String("PolyXML Engineering Updates".into()))
+    );
+
+    if let Some(PolyValue::List(entries)) = val.get("entries") {
+        assert_eq!(entries.len(), 2);
+        assert_eq!(
+            entries[0].get("title"),
+            Some(&PolyValue::String("Release v0.10.0".into()))
+        );
+        let author = entries[0].get("author").unwrap();
+        assert_eq!(
+            author.get("name"),
+            Some(&PolyValue::String("Bailey Nguyen".into()))
+        );
+    } else {
+        panic!("Expected entries list");
+    }
+
+    // 2. Roundtrip serialize with default namespace
+    let mut ns_map = HashMap::new();
+    ns_map.insert("http://www.w3.org/2005/Atom".to_string(), "".to_string());
+
+    let serialized = serialize_with_options(
+        "feed",
+        &val,
+        &feed_schema,
+        Some(2),
+        Some(true),
+        Some(&ns_map),
+    )
+    .expect("Failed to serialize Atom feed");
+
+    let val_re = deserialize(&serialized, Arc::clone(&feed_schema))
+        .expect("Failed to re-deserialize Atom feed");
+    assert_eq!(val, val_re);
+}
+
+#[test]
+fn test_ubl_invoice_conformance() {
+    let path = fixture_path("ubl_invoice.xml");
+    let xml_bytes = fs::read(&path).expect("Failed to read ubl_invoice.xml");
+
+    let party_schema = ModelSchema::builder("Party")
+        .with_namespace("urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2")
+        .field(FieldSchema::new(
+            "name",
+            b"cbc:RegistrationName",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "company_id",
+            b"cbc:CompanyID",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .build();
+
+    let supplier_schema = ModelSchema::builder("AccountingSupplierParty")
+        .with_namespace("urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2")
+        .field(FieldSchema::new(
+            "party",
+            b"cac:Party",
+            FieldKind::Element,
+            ValueType::Nested(Arc::clone(&party_schema)),
+        ))
+        .build();
+
+    let total_schema = ModelSchema::builder("LegalMonetaryTotal")
+        .with_namespace("urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2")
+        .field(FieldSchema::new(
+            "payable_amount",
+            b"cbc:PayableAmount",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::Float),
+        ))
+        .build();
+
+    let invoice_schema = ModelSchema::builder("Invoice")
+        .with_namespace("urn:oasis:names:specification:ubl:schema:xsd:Invoice-2")
+        .field(FieldSchema::new(
+            "id",
+            b"cbc:ID",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "issue_date",
+            b"cbc:IssueDate",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::XmlDate),
+        ))
+        .field(FieldSchema::new(
+            "currency",
+            b"cbc:DocumentCurrencyCode",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "supplier",
+            b"cac:AccountingSupplierParty",
+            FieldKind::Element,
+            ValueType::Nested(supplier_schema),
+        ))
+        .field(FieldSchema::new(
+            "totals",
+            b"cac:LegalMonetaryTotal",
+            FieldKind::Element,
+            ValueType::Nested(total_schema),
+        ))
+        .build();
+
+    // 1. Deserialize
+    let val = deserialize(&xml_bytes, Arc::clone(&invoice_schema))
+        .expect("Failed to deserialize UBL Invoice");
+
+    assert_eq!(
+        val.get("id"),
+        Some(&PolyValue::String("INV-2026-0042".into()))
+    );
+    assert_eq!(
+        val.get("issue_date"),
+        Some(&PolyValue::String("2026-09-17".into()))
+    );
+    assert_eq!(val.get("currency"), Some(&PolyValue::String("USD".into())));
+
+    let supplier = val.get("supplier").unwrap();
+    let party = supplier.get("party").unwrap();
+    assert_eq!(
+        party.get("name"),
+        Some(&PolyValue::String("PolyXML Tech Inc.".into()))
+    );
+
+    let totals = val.get("totals").unwrap();
+    assert_eq!(
+        totals.get("payable_amount"),
+        Some(&PolyValue::Float(1620.0))
+    );
+
+    // 2. Roundtrip serialize
+    let mut ns_map = HashMap::new();
+    ns_map.insert(
+        "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2".to_string(),
+        "".to_string(),
+    );
+    ns_map.insert(
+        "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2".to_string(),
+        "cac".to_string(),
+    );
+    ns_map.insert(
+        "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2".to_string(),
+        "cbc".to_string(),
+    );
+
+    let serialized = serialize_with_options(
+        "Invoice",
+        &val,
+        &invoice_schema,
+        Some(2),
+        Some(true),
+        Some(&ns_map),
+    )
+    .expect("Failed to serialize UBL Invoice");
+
+    let val_re = deserialize(&serialized, Arc::clone(&invoice_schema))
+        .expect("Failed to re-deserialize UBL Invoice");
+    assert_eq!(val, val_re);
+}
+
+#[test]
+fn test_streaming_catalog_conformance() {
+    let path = fixture_path("streaming_catalog.xml");
+    let file = fs::File::open(&path).expect("Failed to open streaming_catalog.xml");
+    let reader = BufReader::new(file);
+
+    let item_schema = ModelSchema::builder("Item")
+        .field(FieldSchema::new(
+            "id",
+            b"id",
+            FieldKind::Attribute,
+            ValueType::Scalar(ScalarType::Int),
+        ))
+        .field(FieldSchema::new(
+            "name",
+            b"Name",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::String),
+        ))
+        .field(FieldSchema::new(
+            "price",
+            b"Price",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::Float),
+        ))
+        .field(FieldSchema::new(
+            "in_stock",
+            b"InStock",
+            FieldKind::Element,
+            ValueType::Scalar(ScalarType::Bool),
+        ))
+        .build();
+
+    let mut stream = XmlItemStream::new(reader, Arc::clone(&item_schema), b"Item");
+    let mut count = 0;
+    let mut first_item = None;
+    let mut mid_item = None;
+    let mut last_item = None;
+
+    while let Some(item) = stream.next_item().expect("Failed to stream item") {
+        count += 1;
+        if count == 1 {
+            first_item = Some(item.clone());
+        } else if count == 500 {
+            mid_item = Some(item.clone());
+        } else if count == 1000 {
+            last_item = Some(item);
+        }
+    }
+
+    assert_eq!(count, 1000);
+
+    let item1 = first_item.unwrap();
+    assert_eq!(item1.get("id"), Some(&PolyValue::Int(1)));
+    assert_eq!(
+        item1.get("name"),
+        Some(&PolyValue::String("Widget #1".into()))
+    );
+    assert_eq!(item1.get("price"), Some(&PolyValue::Float(1.50)));
+    assert_eq!(item1.get("in_stock"), Some(&PolyValue::Bool(false)));
+
+    let item500 = mid_item.unwrap();
+    assert_eq!(item500.get("id"), Some(&PolyValue::Int(500)));
+    assert_eq!(
+        item500.get("name"),
+        Some(&PolyValue::String("Widget #500".into()))
+    );
+    assert_eq!(item500.get("price"), Some(&PolyValue::Float(750.0)));
+    assert_eq!(item500.get("in_stock"), Some(&PolyValue::Bool(true)));
+
+    let item1000 = last_item.unwrap();
+    assert_eq!(item1000.get("id"), Some(&PolyValue::Int(1000)));
+    assert_eq!(
+        item1000.get("name"),
+        Some(&PolyValue::String("Widget #1000".into()))
+    );
+    assert_eq!(item1000.get("price"), Some(&PolyValue::Float(1500.0)));
+    assert_eq!(item1000.get("in_stock"), Some(&PolyValue::Bool(true)));
+}

polyxml-0.11.1/crates/polyxml-python/tests/test_conformance.py

@@ -0,0 +1,422 @@
+import pathlib
+from dataclasses import dataclass, field
+
+from pydantic import BaseModel, Field
+
+import polyxml
+
+FIXTURES_DIR = pathlib.Path(__file__).parents[3] / "tests" / "fixtures"
+
+
+# -------------------------------------------------------------
+# 1. SOAP 1.2 Envelope (Dataclasses)
+# -------------------------------------------------------------
+
+
+@dataclass
+class SoapSecurityToken:
+    class Meta:
+        name = "SecurityToken"
+        namespace = "http://example.com/security"
+
+    token: str = field(
+        metadata={"type": "Text"},
+        default="",
+    )
+    must_understand: bool = field(
+        metadata={
+            "name": "mustUnderstand",
+            "type": "Attribute",
+            "namespace": "http://www.w3.org/2003/05/soap-envelope",
+        },
+        default=False,
+    )
+
+
+@dataclass
+class SoapHeader:
+    class Meta:
+        name = "Header"
+        namespace = "http://www.w3.org/2003/05/soap-envelope"
+
+    security_token: SoapSecurityToken = field(
+        metadata={
+            "name": "SecurityToken",
+            "type": "Element",
+            "namespace": "http://example.com/security",
+        },
+        default_factory=SoapSecurityToken,
+    )
+
+
+@dataclass
+class GetStockPrice:
+    class Meta:
+        name = "GetStockPrice"
+        namespace = "http://example.com/stock"
+
+    stock_name: str = field(
+        metadata={
+            "name": "StockName",
+            "type": "Element",
+            "namespace": "http://example.com/stock",
+        },
+        default="",
+    )
+    currency: str = field(
+        metadata={
+            "name": "Currency",
+            "type": "Element",
+            "namespace": "http://example.com/stock",
+        },
+        default="",
+    )
+    target_date: str = field(
+        metadata={
+            "name": "TargetDate",
+            "type": "Element",
+            "namespace": "http://example.com/stock",
+        },
+        default="",
+    )
+
+
+@dataclass
+class SoapBody:
+    class Meta:
+        name = "Body"
+        namespace = "http://www.w3.org/2003/05/soap-envelope"
+
+    get_stock_price: GetStockPrice = field(
+        metadata={
+            "name": "GetStockPrice",
+            "type": "Element",
+            "namespace": "http://example.com/stock",
+        },
+        default_factory=GetStockPrice,
+    )
+
+
+@dataclass
+class SoapEnvelope:
+    class Meta:
+        name = "Envelope"
+        namespace = "http://www.w3.org/2003/05/soap-envelope"
+
+    header: SoapHeader = field(
+        metadata={
+            "name": "Header",
+            "type": "Element",
+            "namespace": "http://www.w3.org/2003/05/soap-envelope",
+        },
+        default_factory=SoapHeader,
+    )
+    body: SoapBody = field(
+        metadata={
+            "name": "Body",
+            "type": "Element",
+            "namespace": "http://www.w3.org/2003/05/soap-envelope",
+        },
+        default_factory=SoapBody,
+    )
+
+
+def test_soap_envelope_conformance():
+    xml_path = FIXTURES_DIR / "soap_envelope.xml"
+    xml_bytes = xml_path.read_bytes()
+
+    env = polyxml.deserialize(xml_bytes, SoapEnvelope)
+    assert env.header.security_token.must_understand is True
+    assert env.header.security_token.token.strip() == "sec-tok-987654321"
+    assert env.body.get_stock_price.stock_name == "ACME"
+    assert env.body.get_stock_price.currency == "USD"
+    assert env.body.get_stock_price.target_date == "2026-09-17"
+
+    # Roundtrip serialization with prefix mapping
+    ns_map = {
+        "env": "http://www.w3.org/2003/05/soap-envelope",
+        "m": "http://example.com/stock",
+        "auth": "http://example.com/security",
+    }
+    serialized = polyxml.serialize(env, indent=4, ns_map=ns_map)
+    xml_str = serialized.decode("utf-8")
+    assert "xmlns:env=\"http://www.w3.org/2003/05/soap-envelope\"" in xml_str
+    assert "<env:Envelope" in xml_str
+    assert "<env:Header>" in xml_str
+    assert "<auth:SecurityToken" in xml_str
+
+    re_env = polyxml.deserialize(serialized, SoapEnvelope)
+    assert re_env.body.get_stock_price.stock_name == "ACME"
+    assert re_env.header.security_token.must_understand is True
+
+
+# -------------------------------------------------------------
+# 2. Atom 1.0 Feed (Pydantic v2)
+# -------------------------------------------------------------
+
+
+class AtomAuthor(BaseModel):
+    class Meta:
+        name = "author"
+        namespace = "http://www.w3.org/2005/Atom"
+
+    name: str = Field(
+        json_schema_extra={"name": "name", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    email: str = Field(
+        json_schema_extra={"name": "email", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+
+
+class AtomEntry(BaseModel):
+    class Meta:
+        name = "entry"
+        namespace = "http://www.w3.org/2005/Atom"
+
+    title: str = Field(
+        json_schema_extra={"name": "title", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    id: str = Field(
+        json_schema_extra={"name": "id", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    updated: str = Field(
+        json_schema_extra={"name": "updated", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    summary: str = Field(
+        json_schema_extra={"name": "summary", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    author: AtomAuthor = Field(
+        json_schema_extra={"name": "author", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+
+
+class AtomFeed(BaseModel):
+    class Meta:
+        name = "feed"
+        namespace = "http://www.w3.org/2005/Atom"
+
+    title: str = Field(
+        json_schema_extra={"name": "title", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    id: str = Field(
+        json_schema_extra={"name": "id", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    updated: str = Field(
+        json_schema_extra={"name": "updated", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"}
+    )
+    entries: list[AtomEntry] = Field(
+        default_factory=list,
+        json_schema_extra={"name": "entry", "type": "Element", "namespace": "http://www.w3.org/2005/Atom"},
+    )
+
+
+def test_atom_feed_conformance():
+    xml_path = FIXTURES_DIR / "atom_feed.xml"
+    xml_text = xml_path.read_text(encoding="utf-8")
+
+    feed = polyxml.deserialize(xml_text, AtomFeed)
+    assert feed.title == "PolyXML Engineering Updates"
+    assert len(feed.entries) == 2
+    assert feed.entries[0].title == "Release v0.10.0"
+    assert feed.entries[0].author.name == "Bailey Nguyen"
+    assert feed.entries[1].title == "Performance Milestone"
+    assert feed.entries[1].author.email == "core@polyxml.org"
+
+    # Roundtrip serialize with default namespace
+    ns_map = {None: "http://www.w3.org/2005/Atom"}
+    serialized = polyxml.serialize(feed, indent=2, ns_map=ns_map)
+    xml_str = serialized.decode("utf-8")
+    assert 'xmlns="http://www.w3.org/2005/Atom"' in xml_str
+    assert "<feed" in xml_str
+
+    re_feed = polyxml.deserialize(serialized, AtomFeed)
+    assert re_feed.title == feed.title
+    assert len(re_feed.entries) == 2
+
+
+# -------------------------------------------------------------
+# 3. OASIS UBL 2.1 Invoice (Dataclasses)
+# -------------------------------------------------------------
+
+
+@dataclass
+class UblParty:
+    class Meta:
+        name = "Party"
+        namespace = "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
+
+    name: str = field(
+        metadata={
+            "name": "RegistrationName",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+        },
+        default="",
+    )
+    company_id: str = field(
+        metadata={
+            "name": "CompanyID",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+        },
+        default="",
+    )
+
+
+@dataclass
+class UblSupplier:
+    class Meta:
+        name = "AccountingSupplierParty"
+        namespace = "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
+
+    party: UblParty = field(
+        metadata={
+            "name": "Party",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
+        },
+        default_factory=UblParty,
+    )
+
+
+@dataclass
+class UblMonetaryTotal:
+    class Meta:
+        name = "LegalMonetaryTotal"
+        namespace = "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
+
+    payable_amount: float = field(
+        metadata={
+            "name": "PayableAmount",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+        },
+        default=0.0,
+    )
+
+
+@dataclass
+class UblInvoice:
+    class Meta:
+        name = "Invoice"
+        namespace = "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
+
+    id: str = field(
+        metadata={
+            "name": "ID",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+        },
+        default="",
+    )
+    issue_date: str = field(
+        metadata={
+            "name": "IssueDate",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+        },
+        default="",
+    )
+    currency: str = field(
+        metadata={
+            "name": "DocumentCurrencyCode",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+        },
+        default="",
+    )
+    supplier: UblSupplier = field(
+        metadata={
+            "name": "AccountingSupplierParty",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
+        },
+        default_factory=UblSupplier,
+    )
+    totals: UblMonetaryTotal = field(
+        metadata={
+            "name": "LegalMonetaryTotal",
+            "type": "Element",
+            "namespace": "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
+        },
+        default_factory=UblMonetaryTotal,
+    )
+
+
+def test_ubl_invoice_conformance():
+    xml_path = FIXTURES_DIR / "ubl_invoice.xml"
+    xml_bytes = xml_path.read_bytes()
+
+    inv = polyxml.deserialize(xml_bytes, UblInvoice)
+    assert inv.id == "INV-2026-0042"
+    assert inv.issue_date == "2026-09-17"
+    assert inv.currency == "USD"
+    assert inv.supplier.party.name == "PolyXML Tech Inc."
+    assert inv.supplier.party.company_id == "US-987654321"
+    assert inv.totals.payable_amount == 1620.0
+
+    # Roundtrip serialize
+    ns_map = {
+        None: "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2",
+        "cac": "urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2",
+        "cbc": "urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2",
+    }
+    serialized = polyxml.serialize(inv, indent=2, ns_map=ns_map)
+    xml_str = serialized.decode("utf-8")
+    assert 'xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"' in xml_str
+    assert 'xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"' in xml_str
+    assert 'xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"' in xml_str
+
+    re_inv = polyxml.deserialize(serialized, UblInvoice)
+    assert re_inv.id == inv.id
+    assert re_inv.totals.payable_amount == 1620.0
+
+
+# -------------------------------------------------------------
+# 4. Streaming Catalog Iterparse Conformance
+# -------------------------------------------------------------
+
+
+@dataclass
+class CatalogItem:
+    id: int = field(metadata={"name": "id", "type": "Attribute"}, default=0)
+    name: str = field(metadata={"name": "Name", "type": "Element"}, default="")
+    price: float = field(metadata={"name": "Price", "type": "Element"}, default=0.0)
+    in_stock: bool = field(metadata={"name": "InStock", "type": "Element"}, default=False)
+
+
+def test_streaming_catalog_iterparse_conformance():
+    xml_path = FIXTURES_DIR / "streaming_catalog.xml"
+
+    count = 0
+    first_item = None
+    mid_item = None
+    last_item = None
+
+    for item in polyxml.iterparse(xml_path, CatalogItem, tag="Item"):
+        count += 1
+        if count == 1:
+            first_item = item
+        elif count == 500:
+            mid_item = item
+        elif count == 1000:
+            last_item = item
+
+    assert count == 1000
+    assert first_item is not None
+    assert first_item.id == 1
+    assert first_item.name == "Widget #1"
+    assert first_item.price == 1.50
+    assert first_item.in_stock is False
+
+    assert mid_item is not None
+    assert mid_item.id == 500
+    assert mid_item.name == "Widget #500"
+    assert mid_item.price == 750.0
+    assert mid_item.in_stock is True
+
+    assert last_item is not None
+    assert last_item.id == 1000
+    assert last_item.name == "Widget #1000"
+    assert last_item.price == 1500.0
+    assert last_item.in_stock is True

{polyxml-0.10.0 → polyxml-0.11.1}/pyproject.toml

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