polyxml 0.3.0__tar.gz → 0.5.0__tar.gz

{polyxml-0.3.0 → polyxml-0.5.0}/Cargo.lock

@@ -11,6 +11,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "alloca"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "anes"
 version = "0.1.6"
@@ -41,6 +50,16 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
+[[package]]
+name = "cc"
+version = "1.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "005ec2760ca554fae18df7a11195552ec576cd665632a881bc011d5bb2fd4d80"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -110,10 +129,11 @@ dependencies = [
 
 [[package]]
 name = "criterion"
-version = "0.7.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1c047a62b0cc3e145fa84415a3191f628e980b194c2755aa12300a4e6cbd928"
+checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
 dependencies = [
+ "alloca",
  "anes",
  "cast",
  "ciborium",
@@ -122,6 +142,7 @@ dependencies = [
  "itertools",
  "num-traits",
  "oorandom",
+ "page_size",
  "regex",
  "serde",
  "serde_json",
@@ -131,9 +152,9 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.6.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b1bcc0dc7dfae599d84ad0b1a55f80cde8af3725da8313b528da95ef783e338"
+checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
 dependencies = [
  "cast",
  "itertools",
@@ -167,6 +188,12 @@ version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d"
+
 [[package]]
 name = "half"
 version = "2.7.1"
@@ -184,15 +211,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "indoc"
-version = "2.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -287,15 +305,6 @@ version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "napi"
 version = "2.16.17"
@@ -374,9 +383,19 @@ version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
+[[package]]
+name = "page_size"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "polyxml"
-version = "0.3.0"
+version = "0.5.0"
 dependencies = [
  "criterion",
  "lexical-core",
@@ -389,14 +408,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.3.0"
+version = "0.5.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-js"
-version = "0.3.0"
+version = "0.5.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -406,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.3.0"
+version = "0.5.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -441,37 +460,32 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
 dependencies = [
- "cfg-if",
- "indoc",
  "libc",
- "memoffset",
  "once_cell",
  "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
- "unindent",
 ]
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -479,9 +493,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -491,22 +505,21 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.5"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
 name = "quick-xml"
-version = "0.37.5"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
+checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
 dependencies = [
  "memchr",
  "serde",
@@ -550,12 +563,6 @@ version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
-[[package]]
-name = "rustversion"
-version = "1.0.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
-
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -614,6 +621,12 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
 [[package]]
 name = "smallvec"
 version = "1.16.0"
@@ -644,9 +657,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "thiserror"
@@ -690,12 +703,6 @@ version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
 
-[[package]]
-name = "unindent"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
-
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -706,6 +713,22 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
 [[package]]
 name = "winapi-util"
 version = "0.1.11"
@@ -715,6 +738,12 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"

{polyxml-0.3.0 → polyxml-0.5.0}/Cargo.toml

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

{polyxml-0.3.0 → polyxml-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.3.0
+Version: 0.5.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -16,7 +16,10 @@ Requires-Dist: pytest>=8.0.0 ; extra == 'dev'
 Requires-Dist: pytest-cov>=5.0.0 ; extra == 'dev'
 Requires-Dist: pydantic>=2.7.0 ; extra == 'dev'
 Requires-Dist: ruff>=0.4.0 ; extra == 'dev'
+Requires-Dist: msgspec>=0.18.0 ; extra == 'dev'
+Requires-Dist: msgspec>=0.18.0 ; extra == 'msgpack'
 Provides-Extra: dev
+Provides-Extra: msgpack
 Summary: High-performance, polyglot XML data-binding engine built in Rust
 Author-email: Bailey Nguyen <bailey.tan.nguyen@gmail.com>
 License: MIT

{polyxml-0.3.0 → polyxml-0.5.0}/crates/polyxml-core/Cargo.toml

@@ -11,14 +11,14 @@ keywords = ["xml", "deserializer", "serializer", "data-binding", "quick-xml"]
 categories = ["parsing", "encoding"]
 
 [dependencies]
-quick-xml = { version = "0.37", features = ["serialize"] }
+quick-xml = { version = "0.42", features = ["serialize"] }
 lexical-core = "1.0"
 memchr = "2.8"
 thiserror = "2.0"
 smallvec = "1.16"
 
 [dev-dependencies]
-criterion = { version = "0.7", default-features = false, features = ["cargo_bench_support"] }
+criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support"] }
 pretty_assertions = "1.4"
 
 [[bench]]

{polyxml-0.3.0 → polyxml-0.5.0}/crates/polyxml-core/src/error.rs

@@ -31,8 +31,11 @@ pub enum PolyXmlError {
     #[error("Maximum XML recursion depth exceeded: current {current} >= limit {max_depth}")]
     MaxDepthExceeded { max_depth: usize, current: usize },
 
-    #[error("XML parsing or unescape error: {0}")]
+    #[error("XML parsing error: {0}")]
     XmlError(#[from] quick_xml::Error),
+
+    #[error("XML unescape error: {0}")]
+    EscapeError(#[from] quick_xml::escape::EscapeError),
 }
 
 pub type Result<T> = std::result::Result<T, PolyXmlError>;

{polyxml-0.3.0 → polyxml-0.5.0}/crates/polyxml-core/src/parser.rs

@@ -86,8 +86,8 @@ pub struct XmlDeserializer;
 fn is_nil_element(e: &BytesStart) -> bool {
     for attr in e.attributes().flatten() {
         let key = attr.key.local_name();
-        if (key.as_ref() == b"nil" || key.as_ref() == b"xsi:nil")
-            && (attr.value.as_ref() == b"true" || attr.value.as_ref() == b"1")
+        if (key.as_ref() == "nil" || key.as_ref() == "xsi:nil")
+            && (attr.value.as_ref() == "true" || attr.value.as_ref() == "1")
         {
             return true;
         }
@@ -95,6 +95,33 @@ fn is_nil_element(e: &BytesStart) -> bool {
     false
 }
 
+fn append_general_ref(
+    e: &quick_xml::events::BytesRef,
+    active_scalar: bool,
+    text_buf: &mut Vec<u8>,
+    frame_text_buf: Option<&mut Vec<u8>>,
+) -> Result<()> {
+    let mut char_buf = [0u8; 4];
+    let resolved_bytes: &[u8] = if e.is_char_ref() {
+        if let Some(ch) = e.resolve_char_ref().map_err(PolyXmlError::XmlError)? {
+            ch.encode_utf8(&mut char_buf).as_bytes()
+        } else {
+            b""
+        }
+    } else if let Some(s) = quick_xml::escape::resolve_xml_entity(e.as_ref()) {
+        s.as_bytes()
+    } else {
+        e.as_ref().as_bytes()
+    };
+
+    if active_scalar {
+        text_buf.extend_from_slice(resolved_bytes);
+    } else if let Some(tb) = frame_text_buf {
+        tb.extend_from_slice(resolved_bytes);
+    }
+    Ok(())
+}
+
 pub const DEFAULT_MAX_DEPTH: usize = 256;
 
 impl XmlDeserializer {
@@ -108,7 +135,6 @@ impl XmlDeserializer {
         max_depth: usize,
     ) -> Result<PolyValue> {
         let mut reader = Reader::from_reader(xml_bytes);
-        reader.config_mut().trim_text(true);
         let mut buf = Vec::new();
 
         loop {
@@ -166,7 +192,10 @@ impl XmlDeserializer {
                     let is_nil = is_nil_element(e);
 
                     let current_schema = Arc::clone(&stack.last().unwrap().schema);
-                    if let Some(&field_idx) = current_schema.element_map.get(local_name.as_ref()) {
+                    if let Some(&field_idx) = current_schema
+                        .element_map
+                        .get(local_name.as_ref().as_bytes())
+                    {
                         let field = &current_schema.fields[field_idx];
                         match &field.val_type {
                             ValueType::Scalar(st) => {
@@ -210,7 +239,10 @@ impl XmlDeserializer {
                     let is_nil = is_nil_element(e);
 
                     let current_schema = Arc::clone(&stack.last().unwrap().schema);
-                    if let Some(&field_idx) = current_schema.element_map.get(local_name.as_ref()) {
+                    if let Some(&field_idx) = current_schema
+                        .element_map
+                        .get(local_name.as_ref().as_bytes())
+                    {
                         let field = &current_schema.fields[field_idx];
                         match &field.val_type {
                             ValueType::Scalar(_) => {
@@ -251,7 +283,7 @@ impl XmlDeserializer {
                     }
                 }
                 Ok(Event::Text(ref e)) => {
-                    let unescaped = e.unescape().map_err(PolyXmlError::XmlError)?;
+                    let unescaped = quick_xml::escape::unescape(e.as_ref())?;
                     if active_scalar_field.is_some() {
                         text_buf.extend_from_slice(unescaped.as_bytes());
                     } else if let Some(frame) = stack.last_mut() {
@@ -262,13 +294,17 @@ impl XmlDeserializer {
                 }
                 Ok(Event::CData(ref e)) => {
                     if active_scalar_field.is_some() {
-                        text_buf.extend_from_slice(e.as_ref());
+                        text_buf.extend_from_slice(e.as_ref().as_bytes());
                     } else if let Some(frame) = stack.last_mut() {
                         if let Some(ref mut tb) = frame.frame_text_buf {
-                            tb.extend_from_slice(e.as_ref());
+                            tb.extend_from_slice(e.as_ref().as_bytes());
                         }
                     }
                 }
+                Ok(Event::GeneralRef(ref e)) => {
+                    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 let Some((field_idx, ref scalar_type, is_list)) = active_scalar_field.take()
                     {
@@ -287,7 +323,10 @@ impl XmlDeserializer {
                         let instance = finished_frame.finish()?;
                         let parent = stack.last_mut().unwrap();
 
-                        if let Some(&field_idx) = parent.schema.element_map.get(local_name.as_ref())
+                        if let Some(&field_idx) = parent
+                            .schema
+                            .element_map
+                            .get(local_name.as_ref().as_bytes())
                         {
                             let field = &parent.schema.fields[field_idx];
                             if matches!(field.val_type, ValueType::List(_)) {
@@ -321,11 +360,15 @@ impl XmlDeserializer {
     pub(crate) fn parse_attributes(e: &BytesStart, frame: &mut StackFrame) -> Result<()> {
         for attr in e.attributes().flatten() {
             let key = attr.key.local_name();
-            if let Some(&field_idx) = frame.schema.attribute_map.get(key.as_ref()) {
+            if let Some(&field_idx) = frame.schema.attribute_map.get(key.as_ref().as_bytes()) {
                 let field = &frame.schema.fields[field_idx];
                 if let ValueType::Scalar(ref st) = field.val_type {
-                    let unescaped = attr.unescape_value().map_err(PolyXmlError::XmlError)?;
-                    let val = ValueConverter::parse_scalar(st, unescaped.as_bytes(), &field.name)?;
+                    let unescaped = quick_xml::escape::unescape(attr.value.as_ref())?;
+                    let val = ValueConverter::parse_scalar(
+                        st,
+                        unescaped.as_ref().as_bytes(),
+                        &field.name,
+                    )?;
                     frame.values[field_idx] = Some(val);
                 }
             }
@@ -344,8 +387,7 @@ pub struct XmlItemStream<R: std::io::BufRead> {
 
 impl<R: std::io::BufRead> XmlItemStream<R> {
     pub fn new(reader: R, schema: Arc<ModelSchema>, target_tag: &[u8]) -> Self {
-        let mut xml_reader = Reader::from_reader(reader);
-        xml_reader.config_mut().trim_text(true);
+        let xml_reader = Reader::from_reader(reader);
         Self {
             reader: xml_reader,
             schema,
@@ -361,7 +403,7 @@ impl<R: std::io::BufRead> XmlItemStream<R> {
             match self.reader.read_event_into(&mut self.buf) {
                 Ok(Event::Start(ref e)) => {
                     let local = e.local_name();
-                    if local.as_ref() == self.target_tag.as_slice() {
+                    if local.as_ref().as_bytes() == self.target_tag.as_slice() {
                         let item = XmlDeserializer::parse_sub_tree(
                             &mut self.reader,
                             Arc::clone(&self.schema),
@@ -373,7 +415,7 @@ impl<R: std::io::BufRead> XmlItemStream<R> {
                 }
                 Ok(Event::Empty(ref e)) => {
                     let local = e.local_name();
-                    if local.as_ref() == self.target_tag.as_slice() {
+                    if local.as_ref().as_bytes() == self.target_tag.as_slice() {
                         let mut frame = StackFrame::new(Arc::clone(&self.schema));
                         XmlDeserializer::parse_attributes(e, &mut frame)?;
                         return Ok(Some(frame.finish()?));

{polyxml-0.3.0 → polyxml-0.5.0}/crates/polyxml-python/Cargo.toml

@@ -14,6 +14,6 @@ crate-type = ["cdylib"]
 
 [dependencies]
 polyxml = { path = "../polyxml-core" }
-pyo3 = { version = "0.23", features = ["abi3-py312", "extension-module"] }
+pyo3 = { version = "0.29", features = ["abi3-py312", "extension-module"] }
 lexical-core = "1.0"
 smallvec = "1.16"

{polyxml-0.3.0 → polyxml-0.5.0}/crates/polyxml-python/src/lib.rs

@@ -11,6 +11,8 @@ use std::sync::{Arc, RwLock};
 use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType};
 use polyxml::value::PolyValue;
 
+type PyObject = Py<PyAny>;
+
 struct CachedFieldMeta {
     py_string: Py<PyString>,
     is_init: bool,
@@ -45,21 +47,31 @@ fn lookup_py_class<'py>(py: Python<'py>, schema_name: &str) -> Option<Bound<'py,
 }
 
 fn unwrap_optional_type<'py>(type_obj: &Bound<'py, PyAny>) -> Bound<'py, PyAny> {
-    if let Ok(origin) = type_obj.getattr("__origin__") {
+    let is_union = if let Ok(origin) = type_obj.getattr("__origin__") {
         if let Ok(origin_name) = origin.getattr("__name__") {
             let origin_str: String = origin_name.extract().unwrap_or_default();
-            if origin_str == "Union" || origin_str == "UnionType" {
-                if let Ok(args) = type_obj.getattr("__args__") {
-                    if let Ok(tuple) = args.downcast::<PyTuple>() {
-                        for arg in tuple.iter() {
-                            let arg_name: String = arg
-                                .getattr("__name__")
-                                .and_then(|n| n.extract())
-                                .unwrap_or_default();
-                            if arg_name != "NoneType" {
-                                return unwrap_optional_type(&arg);
-                            }
-                        }
+            origin_str == "Union" || origin_str == "UnionType"
+        } else {
+            false
+        }
+    } else {
+        type_obj
+            .get_type()
+            .name()
+            .map(|n| n == "UnionType")
+            .unwrap_or(false)
+    };
+
+    if is_union {
+        if let Ok(args) = type_obj.getattr("__args__") {
+            if let Ok(tuple) = args.cast::<PyTuple>() {
+                for arg in tuple.iter() {
+                    let arg_name: String = arg
+                        .getattr("__name__")
+                        .and_then(|n| n.extract())
+                        .unwrap_or_default();
+                    if arg_name != "NoneType" {
+                        return unwrap_optional_type(&arg);
                     }
                 }
             }
@@ -69,10 +81,10 @@ fn unwrap_optional_type<'py>(type_obj: &Bound<'py, PyAny>) -> Bound<'py, PyAny>
 }
 
 fn is_enum_class<'py>(py: Python<'py>, cls: &Bound<'py, PyAny>) -> bool {
-    if let Ok(py_type) = cls.downcast::<PyType>() {
+    if let Ok(py_type) = cls.cast::<PyType>() {
         if let Ok(enum_module) = py.import("enum") {
             if let Ok(enum_cls) = enum_module.getattr("Enum") {
-                if let Ok(py_enum) = enum_cls.downcast::<PyType>() {
+                if let Ok(py_enum) = enum_cls.cast::<PyType>() {
                     return py_type.is_subclass(py_enum).unwrap_or(false);
                 }
             }
@@ -108,26 +120,44 @@ fn resolve_scalar_type(py: Python<'_>, type_obj: &Bound<'_, PyAny>) -> PyResult<
 }
 
 fn resolve_value_type(py: Python<'_>, type_obj: &Bound<'_, PyAny>) -> PyResult<ValueType> {
-    // Handle typing.Optional / Union
-    if let Ok(origin) = type_obj.getattr("__origin__") {
+    // Handle typing.Optional / Union and PEP 604 UnionType
+    let is_union = if let Ok(origin) = type_obj.getattr("__origin__") {
         if let Ok(origin_name) = origin.getattr("__name__") {
             let origin_str: String = origin_name.extract().unwrap_or_default();
-            if origin_str == "Union" || origin_str == "UnionType" {
-                if let Ok(args) = type_obj.getattr("__args__") {
-                    let tuple: Bound<'_, pyo3::types::PyTuple> = args.downcast_into()?;
-                    for arg in tuple.iter() {
-                        let arg_name: String = arg
-                            .getattr("__name__")
-                            .and_then(|n| n.extract())
-                            .unwrap_or_default();
-                        if arg_name != "NoneType" {
-                            return resolve_value_type(py, &arg);
-                        }
+            origin_str == "Union" || origin_str == "UnionType"
+        } else {
+            false
+        }
+    } else {
+        type_obj
+            .get_type()
+            .name()
+            .map(|n| n == "UnionType")
+            .unwrap_or(false)
+    };
+
+    if is_union {
+        if let Ok(args) = type_obj.getattr("__args__") {
+            if let Ok(tuple) = args.cast_into::<PyTuple>() {
+                for arg in tuple.iter() {
+                    let arg_name: String = arg
+                        .getattr("__name__")
+                        .and_then(|n| n.extract())
+                        .unwrap_or_default();
+                    if arg_name != "NoneType" {
+                        return resolve_value_type(py, &arg);
                     }
                 }
-            } else if origin_str == "list" || origin_str == "List" {
+            }
+        }
+    }
+
+    if let Ok(origin) = type_obj.getattr("__origin__") {
+        if let Ok(origin_name) = origin.getattr("__name__") {
+            let origin_str: String = origin_name.extract().unwrap_or_default();
+            if origin_str == "list" || origin_str == "List" {
                 if let Ok(args) = type_obj.getattr("__args__") {
-                    let tuple: Bound<'_, pyo3::types::PyTuple> = args.downcast_into()?;
+                    let tuple: Bound<'_, pyo3::types::PyTuple> = args.cast_into()?;
                     if let Some(first) = tuple.iter().next() {
                         let inner = resolve_value_type(py, &first)?;
                         return Ok(ValueType::List(Box::new(inner)));
@@ -142,7 +172,7 @@ fn resolve_value_type(py: Python<'_>, type_obj: &Bound<'_, PyAny>) -> PyResult<V
 
     // Check if target is a nested dataclass or Pydantic model
     if type_obj.hasattr("__dataclass_fields__")? || type_obj.hasattr("model_fields")? {
-        if let Ok(py_type) = type_obj.downcast::<PyType>() {
+        if let Ok(py_type) = type_obj.cast::<PyType>() {
             let (nested_schema, _) = get_or_create_schema(py_type)?;
             return Ok(ValueType::Nested(nested_schema));
         }
@@ -165,10 +195,10 @@ fn extract_schema_from_class<'py>(
         .ok()
         .and_then(|m| m.getattr("get_type_hints").ok())
         .and_then(|f| f.call1((cls,)).ok())
-        .and_then(|h| h.downcast_into::<PyDict>().ok());
+        .and_then(|h| h.cast_into::<PyDict>().ok());
 
     if cls.hasattr("model_fields")? {
-        let model_fields: Bound<'py, PyDict> = cls.getattr("model_fields")?.downcast_into()?;
+        let model_fields: Bound<'py, PyDict> = cls.getattr("model_fields")?.cast_into()?;
         for (name_obj, field_obj) in model_fields.iter() {
             let py_name: String = name_obj.extract()?;
             let py_string = PyString::new(py, &py_name).unbind();
@@ -221,7 +251,7 @@ fn extract_schema_from_class<'py>(
             ));
         }
     } else if cls.hasattr("__dataclass_fields__")? {
-        let fields: Bound<'py, PyDict> = cls.getattr("__dataclass_fields__")?.downcast_into()?;
+        let fields: Bound<'py, PyDict> = cls.getattr("__dataclass_fields__")?.cast_into()?;
         for (name_obj, field_obj) in fields.iter() {
             let py_name: String = name_obj.extract()?;
             let py_string = PyString::new(py, &py_name).unbind();
@@ -631,7 +661,7 @@ fn py_to_poly_value<'py>(
                     }
                 },
                 ValueType::List(inner) => {
-                    if let Ok(list) = val.downcast::<PyList>() {
+                    if let Ok(list) = val.cast::<PyList>() {
                         let mut poly_items = Vec::with_capacity(list.len());
                         let child_meta = if let ValueType::Nested(sub_schema) = inner.as_ref() {
                             lookup_cached_meta(&sub_schema.name)

{polyxml-0.3.0 → polyxml-0.5.0}/crates/polyxml-python/tests/test_polyxml.py

@@ -12,7 +12,6 @@ try:
 except ImportError:
 
     class XmlDate:
-
         def __init__(self, val: str):
             self.val = val
 
@@ -27,7 +26,6 @@ except ImportError:
             return self.val
 
     class XmlDateTime:
-
         def __init__(self, val: str):
             self.val = val
 
@@ -42,7 +40,6 @@ except ImportError:
             return self.val
 
     class XmlTime:
-
         def __init__(self, val: str):
             self.val = val
 
@@ -57,7 +54,6 @@ except ImportError:
             return self.val
 
     class XmlDuration:
-
         def __init__(self, val: str):
             self.val = val
 
@@ -67,6 +63,7 @@ except ImportError:
         def __str__(self):
             return self.val
 
+
 import polyxml
 
 
@@ -329,3 +326,79 @@ def test_to_bytes_streams():
 def test_to_bytes_invalid_type():
     with pytest.raises(TypeError, match="Unsupported XML source type"):
         polyxml.deserialize(12345, SimpleItem)  # type: ignore[arg-type]
+
+
+@dataclass
+class UnionWrapper:
+    child: None | ChildNode = field(default=None, metadata={"type": "Element", "name": "child"})
+    count: int | None = field(default=None, metadata={"type": "Element"})
+
+
+def test_pep604_union_nested_dataclass():
+    xml = "<UnionWrapper><child><tag>Payload</tag></child><count>42</count></UnionWrapper>"
+    res = polyxml.deserialize(xml, UnionWrapper)
+    assert res.child is not None
+    assert res.child.tag == "Payload"
+    assert res.count == 42
+
+
+def test_binary_serialization_dataclass():
+    item = SimpleItem(id=42, name="TestItem", price=19.99, active=True)
+    payload = polyxml.dumps_binary(item)
+    assert isinstance(payload, bytes)
+    assert len(payload) > 0
+
+    decoded = polyxml.loads_binary(payload, SimpleItem)
+    assert isinstance(decoded, SimpleItem)
+    assert decoded.id == 42
+    assert decoded.name == "TestItem"
+    assert decoded.price == 19.99
+    assert decoded.active is True
+
+
+def test_binary_serialization_decimal():
+    @dataclass
+    class DecimalItem:
+        val: Decimal
+
+    item = DecimalItem(val=Decimal("19.99"))
+    payload = polyxml.dumps_binary(item)
+    decoded = polyxml.loads_binary(payload, DecimalItem)
+    assert decoded.val == Decimal("19.99")
+
+
+def test_binary_serialization_untyped():
+    data = {"name": "Alice", "score": 100}
+    payload = polyxml.dumps_binary(data)
+    decoded = polyxml.loads_binary(payload)
+    assert decoded == data
+
+
+def test_binary_serialization_xmldate_and_path():
+    @dataclass
+    class ExtraItem:
+        date: XmlDate
+        path: pathlib.Path
+
+    orig = ExtraItem(date=XmlDate("2026-09-12"), path=pathlib.Path("/tmp/test.xml"))
+    payload = polyxml.dumps_binary(orig)
+    decoded = polyxml.loads_binary(payload, ExtraItem)
+    assert decoded.date == XmlDate("2026-09-12")
+    assert decoded.path == pathlib.Path("/tmp/test.xml")
+
+
+def test_binary_serialization_unsupported_type():
+    class CustomObject:
+        pass
+
+    with pytest.raises(NotImplementedError, match="PolyXML binary serializer cannot serialize"):
+        polyxml.dumps_binary(CustomObject())
+
+
+def test_binary_deserialization_unsupported_type():
+    class UnhandledClass:
+        pass
+
+    payload = polyxml.dumps_binary({"a": 1})
+    with pytest.raises(NotImplementedError, match="PolyXML binary deserializer cannot deserialize"):
+        polyxml.loads_binary(payload, UnhandledClass)

{polyxml-0.3.0 → polyxml-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "polyxml"
-version = "0.3.0"
+version = "0.5.0"
 description = "High-performance, polyglot XML data-binding engine built in Rust"
 authors = [
     { name = "Bailey Nguyen", email = "bailey.tan.nguyen@gmail.com" }
@@ -28,11 +28,15 @@ classifiers = [
 dependencies = []
 
 [project.optional-dependencies]
+msgpack = [
+    "msgspec>=0.18.0",
+]
 dev = [
     "pytest>=8.0.0",
     "pytest-cov>=5.0.0",
     "pydantic>=2.7.0",
     "ruff>=0.4.0",
+    "msgspec>=0.18.0",
 ]
 
 [project.urls]

polyxml-0.5.0/python/polyxml/AGENT_GUIDE.md

@@ -0,0 +1,89 @@
+# PolyXML AI Agent Guide
+
+Quick-reference instructions for AI coding assistants (Claude, Cursor, Copilot, Antigravity, etc.) using `polyxml` in Python projects.
+
+---
+
+## 1. Overview & Capabilities
+
+`polyxml` is an ultra-fast, native XML data-binding engine written in pure Rust (using `quick-xml` and `lexical-core`) with stable ABI (`abi3-py312`) Python bindings. It provides bidirectional deserialization and serialization for Python 3.12+ `dataclasses` and Pydantic v2 models.
+
+---
+
+## 2. Common Recipes
+
+### A. Deserializing XML (Strings, Bytes, or Files)
+```python
+from dataclasses import dataclass, field
+import pathlib
+import polyxml
+
+
+@dataclass
+class Item:
+    id: int = field(metadata={"type": "Attribute"})
+    name: str = field(metadata={"type": "Element"})
+    price: float = field(metadata={"type": "Element"})
+
+
+# 1. From raw XML string:
+item = polyxml.deserialize('<Item id="1"><name>Bolt</name><price>0.99</price></Item>', Item)
+
+# 2. From raw bytes:
+item = polyxml.deserialize(b"<Item ...>...</Item>", Item)
+
+# 3. From pathlib.Path:
+item = polyxml.deserialize(pathlib.Path("item.xml"), Item)
+```
+
+### B. Streaming Massive XML Files with O(1) Constant Memory
+For large datasets (hundreds of MBs or GBs such as transit timetables or feeds), do **NOT** load the entire XML tree at once. Use `iterparse`:
+
+```python
+import polyxml
+from my_models import VehicleJourney
+
+# Streams elements one-by-one with zero intermediate DOM allocations
+for journey in polyxml.iterparse("large_transit_dump.xml", VehicleJourney, tag="VehicleJourney"):
+    process_journey(journey)
+```
+
+### C. Pydantic v2 Models
+PolyXML natively deserializes into Pydantic v2 `BaseModel` classes with the same API:
+
+```python
+from pydantic import BaseModel, Field
+import polyxml
+
+
+class StopPoint(BaseModel):
+    id: str = Field(json_schema_extra={"type": "Attribute"})
+    name: str
+
+
+stop = polyxml.deserialize(
+    '<StopPoint id="SP1"><name>Central Station</name></StopPoint>', StopPoint
+)
+```
+
+### D. Serializing to XML
+```python
+import polyxml
+
+# Serialize model to UTF-8 XML bytes
+xml_bytes = polyxml.serialize(item, indent=2)
+
+# If string is required:
+xml_string = xml_bytes.decode("utf-8")
+```
+
+---
+
+## 3. Common Pitfalls & Quick Fixes
+
+- **Pitfall**: Attempting `polyxml.XmlParser()`  
+  **Fix**: PolyXML uses module-level functional entrypoints: `polyxml.deserialize(...)` and `polyxml.iterparse(...)`.
+- **Pitfall**: Passing file handles or paths without reading  
+  **Fix**: `polyxml.deserialize(...)` accepts strings, byte buffers, `pathlib.Path`, or `IO` streams directly.
+- **Pitfall**: High memory usage on massive XML files  
+  **Fix**: Switch from `polyxml.deserialize` to `polyxml.iterparse(source, ModelClass, tag="TagName")`.

polyxml-0.5.0/python/polyxml/__init__.py

@@ -0,0 +1,194 @@
+"""PolyXML: High-performance, polyglot native XML data-binding engine.
+
+QUICKSTART FOR AI AGENTS & DEVELOPERS:
+
+1. Deserialize XML (string, bytes, or file Path) into a typed Dataclass or Pydantic model:
+    >>> import polyxml
+    >>> from dataclasses import dataclass, field
+    >>>
+    >>> @dataclass
+    >>> class User:
+    ...     name: str = field(metadata={"type": "Element"})
+    >>>
+    >>> user = polyxml.deserialize("<User><name>Alice</name></User>", User)
+    >>> user.name
+    'Alice'
+
+2. Stream large XML files with O(1) constant memory (Streaming / Facet Extraction):
+    >>> for user in polyxml.iterparse("massive_users.xml", User, tag="User"):
+    ...     process(user)
+
+3. Serialize a model instance back into XML bytes:
+    >>> xml_bytes = polyxml.serialize(user, indent=2)
+
+See `AGENT_GUIDE.md` or https://nth-bailey.github.io/PolyXML/ for complete documentation.
+"""
+
+import pathlib
+from collections.abc import Iterator
+from decimal import Decimal
+from typing import IO
+
+from polyxml._polyxml import (  # type: ignore[import-not-found]
+    deserialize as _deserialize,
+)
+from polyxml._polyxml import (
+    iterparse as _iterparse,
+)
+from polyxml._polyxml import (
+    serialize as _serialize,
+)
+from polyxml._polyxml import (
+    version as _version,
+)
+
+__version__: str = _version()
+
+
+def _to_bytes(source: bytes | str | pathlib.Path | IO[bytes] | IO[str]) -> bytes:
+    if isinstance(source, bytes):
+        return source
+    if isinstance(source, str):
+        if source.lstrip().startswith("<"):
+            return source.encode("utf-8")
+        path = pathlib.Path(source)
+        if path.is_file():
+            return path.read_bytes()
+        return source.encode("utf-8")
+    if isinstance(source, pathlib.Path):
+        return source.read_bytes()
+    if hasattr(source, "read"):
+        data = source.read()
+        return data.encode("utf-8") if isinstance(data, str) else data
+    raise TypeError(
+        f"Unsupported XML source type: {type(source).__name__}. "
+        "Expected bytes, str (XML string or file path), pathlib.Path, or a binary/text IO stream."
+    )
+
+
+def deserialize[T](
+    source: bytes | str | pathlib.Path | IO[bytes] | IO[str], target_type: type[T]
+) -> T:
+    """Deserialize XML bytes, string, file path, or stream into a typed model.
+
+    Args:
+        source: XML content as raw bytes, string, Path, or file stream.
+        target_type: The target dataclass or model class.
+
+    Returns:
+        The deserialized model instance.
+    """
+    return _deserialize(_to_bytes(source), target_type)
+
+
+def iterparse[T](
+    source: bytes | str | pathlib.Path | IO[bytes] | IO[str],
+    target_type: type[T],
+    tag: str | None = None,
+) -> Iterator[T]:
+    """Stream and deserialize XML elements one-by-one with O(1) constant memory.
+
+    Args:
+        source: XML content as raw bytes, string, Path, or file stream.
+        target_type: The target dataclass or model class for each element.
+        tag: Optional XML element tag name to match. Defaults to the model schema name.
+
+    Yields:
+        Deserialized model instances as they are streamed.
+    """
+    return _iterparse(_to_bytes(source), target_type, tag)
+
+
+def serialize(obj: object, *, indent: int | None = None) -> bytes:
+    """Serialize a strongly-typed model instance back into XML bytes.
+
+    Args:
+        obj: Python dataclass or Pydantic model instance.
+        indent: Optional indentation size in spaces for pretty-printing.
+
+    Returns:
+        UTF-8 encoded XML bytes representing the model instance.
+    """
+    return _serialize(obj, indent=indent)
+
+
+try:
+    import msgspec
+
+    _HAS_MSGSPEC = True
+except ImportError:  # pragma: no cover
+    msgspec = None  # type: ignore[assignment]
+    _HAS_MSGSPEC = False
+
+
+def _enc_hook(obj: object) -> str:
+    if isinstance(obj, pathlib.Path | Decimal):
+        return str(obj)
+    if hasattr(obj, "from_string") and hasattr(obj, "val"):
+        return str(obj)
+    raise NotImplementedError(
+        f"PolyXML binary serializer cannot serialize object of type {type(obj).__name__}"
+    )
+
+
+def _dec_hook(target_type: type[object], obj: object) -> object:
+    if target_type is pathlib.Path:
+        return pathlib.Path(str(obj))
+    if hasattr(target_type, "from_string"):
+        return target_type.from_string(str(obj))
+    raise NotImplementedError(
+        f"PolyXML binary deserializer cannot deserialize object into type {target_type.__name__}"
+    )
+
+
+def dumps_binary(obj: object) -> bytes:
+    """Serialize a model or dataclass into a high-throughput binary MessagePack buffer.
+
+    Args:
+        obj: Python dataclass, Pydantic model, or object.
+
+    Returns:
+        Compact binary MessagePack bytes.
+
+    Raises:
+        RuntimeError: If msgspec is not installed.
+    """
+    if not _HAS_MSGSPEC:  # pragma: no cover
+        raise RuntimeError(
+            "PolyXML binary serialization requires 'msgspec'. "
+            "Install it via: pip install 'polyxml[msgpack]' or pip install msgspec"
+        )
+    return msgspec.msgpack.encode(obj, enc_hook=_enc_hook)
+
+
+def loads_binary[T](data: bytes, target_type: type[T] | None = None) -> T | object:
+    """Deserialize binary MessagePack bytes into a strongly-typed model or object.
+
+    Args:
+        data: Binary MessagePack bytes to decode.
+        target_type: Optional target dataclass or model class. If omitted, returns dynamic structure.
+
+    Returns:
+        The deserialized model instance or object.
+
+    Raises:
+        RuntimeError: If msgspec is not installed.
+    """
+    if not _HAS_MSGSPEC:  # pragma: no cover
+        raise RuntimeError(
+            "PolyXML binary deserialization requires 'msgspec'. "
+            "Install it via: pip install 'polyxml[msgpack]' or pip install msgspec"
+        )
+    if target_type is not None:
+        return msgspec.msgpack.decode(data, type=target_type, dec_hook=_dec_hook)
+    return msgspec.msgpack.decode(data, dec_hook=_dec_hook)
+
+
+__all__ = [
+    "__version__",
+    "deserialize",
+    "dumps_binary",
+    "iterparse",
+    "loads_binary",
+    "serialize",
+]

polyxml-0.3.0/python/polyxml/__init__.py

@@ -1,87 +0,0 @@
-"""PolyXML: High-performance, polyglot XML data-binding engine."""
-
-import pathlib
-from collections.abc import Iterator
-from typing import IO
-
-from polyxml._polyxml import (  # type: ignore[import-not-found]
-    deserialize as _deserialize,
-)
-from polyxml._polyxml import (
-    iterparse as _iterparse,
-)
-from polyxml._polyxml import (
-    serialize as _serialize,
-)
-from polyxml._polyxml import (
-    version as _version,
-)
-
-__version__: str = _version()
-
-
-def _to_bytes(source: bytes | str | pathlib.Path | IO[bytes] | IO[str]) -> bytes:
-    if isinstance(source, bytes):
-        return source
-    if isinstance(source, str):
-        if source.lstrip().startswith("<"):
-            return source.encode("utf-8")
-        path = pathlib.Path(source)
-        if path.is_file():
-            return path.read_bytes()
-        return source.encode("utf-8")
-    if isinstance(source, pathlib.Path):
-        return source.read_bytes()
-    if hasattr(source, "read"):
-        data = source.read()
-        return data.encode("utf-8") if isinstance(data, str) else data
-    raise TypeError(f"Unsupported XML source type: {type(source)}")
-
-
-def deserialize[T](
-    source: bytes | str | pathlib.Path | IO[bytes] | IO[str], target_type: type[T]
-) -> T:
-    """Deserialize XML bytes, string, file path, or stream into a typed model.
-
-    Args:
-        source: XML content as raw bytes, string, Path, or file stream.
-        target_type: The target dataclass or model class.
-
-    Returns:
-        The deserialized model instance.
-    """
-    return _deserialize(_to_bytes(source), target_type)
-
-
-def iterparse[T](
-    source: bytes | str | pathlib.Path | IO[bytes] | IO[str],
-    target_type: type[T],
-    tag: str | None = None,
-) -> Iterator[T]:
-    """Stream and deserialize XML elements one-by-one with O(1) constant memory.
-
-    Args:
-        source: XML content as raw bytes, string, Path, or file stream.
-        target_type: The target dataclass or model class for each element.
-        tag: Optional XML element tag name to match. Defaults to the model schema name.
-
-    Yields:
-        Deserialized model instances as they are streamed.
-    """
-    return _iterparse(_to_bytes(source), target_type, tag)
-
-
-def serialize(obj: object, *, indent: int | None = None) -> bytes:
-    """Serialize a strongly-typed model instance back into XML bytes.
-
-    Args:
-        obj: Python dataclass or Pydantic model instance.
-        indent: Optional indentation size in spaces for pretty-printing.
-
-    Returns:
-        UTF-8 encoded XML bytes representing the model instance.
-    """
-    return _serialize(obj, indent=indent)
-
-
-__all__ = ["__version__", "deserialize", "iterparse", "serialize"]