polyxml 0.2.1__tar.gz → 0.4.0__tar.gz

{polyxml-0.2.1 → polyxml-0.4.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,23 +129,22 @@ dependencies = [
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "950046b2aa2492f9a536f5f4f9a3de7b9e2476e575e05bd6c333371add4d98f3"
 dependencies = [
+ "alloca",
  "anes",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "is-terminal",
  "itertools",
  "num-traits",
- "once_cell",
  "oorandom",
+ "page_size",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "walkdir",
@@ -134,9 +152,9 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.5.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+checksum = "d8d80a2f4f5b554395e47b5d8305bc3d27813bacb73493eb1001e8f76dae29ea"
 dependencies = [
  "cast",
  "itertools",
@@ -170,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"
@@ -187,37 +211,11 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "hermit-abi"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
-
-[[package]]
-name = "indoc"
-version = "2.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
-dependencies = [
- "rustversion",
-]
-
-[[package]]
-name = "is-terminal"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
-dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys",
-]
-
 [[package]]
 name = "itertools"
-version = "0.10.5"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
 dependencies = [
  "either",
 ]
@@ -307,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"
@@ -394,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.2.1"
+version = "0.4.0"
 dependencies = [
  "criterion",
  "lexical-core",
@@ -409,14 +408,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.2.1"
+version = "0.4.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-js"
-version = "0.2.1"
+version = "0.4.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -426,12 +425,11 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.2.1"
+version = "0.4.0"
 dependencies = [
  "lexical-core",
  "polyxml",
  "pyo3",
- "quick-xml",
  "smallvec",
 ]
 
@@ -462,37 +460,32 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.6"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+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.22.6"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.6"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -500,9 +493,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.6"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -512,22 +505,21 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.6"
+version = "0.29.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn 2.0.119",
 ]
 
 [[package]]
 name = "quick-xml"
-version = "0.36.2"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7649a7b4df05aed9ea7ec6f628c67c9953a43869b8bc50929569b2999d443fe"
+checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
 dependencies = [
  "memchr",
  "serde",
@@ -571,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"
@@ -635,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"
@@ -665,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"
@@ -711,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"
@@ -727,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"
@@ -736,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.2.1 → polyxml-0.4.0}/Cargo.toml

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

{polyxml-0.2.1 → polyxml-0.4.0}/PKG-INFO

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

{polyxml-0.2.1 → polyxml-0.4.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.36", 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.5", 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.2.1 → polyxml-0.4.0}/crates/polyxml-core/benches/core_benchmarks.rs

@@ -1,4 +1,6 @@
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use std::hint::black_box;
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use polyxml::schema::{FieldKind, FieldSchema, ModelSchema, ScalarType, ValueType};
 use polyxml::{deserialize, serialize};
 use std::sync::Arc;

{polyxml-0.2.1 → polyxml-0.4.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.2.1 → polyxml-0.4.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.2.1 → polyxml-0.4.0}/crates/polyxml-python/Cargo.toml

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

{polyxml-0.2.1 → polyxml-0.4.0}/crates/polyxml-python/src/lib.rs

@@ -4,12 +4,15 @@
 
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict, PyList, PyString, PyTuple, PyType};
+use pyo3::IntoPyObjectExt;
 use std::collections::HashMap;
 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,
@@ -44,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);
                     }
                 }
             }
@@ -68,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(enum_module) = py.import_bound("enum") {
+    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);
                 }
             }
@@ -107,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)));
@@ -141,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));
         }
@@ -160,17 +191,17 @@ fn extract_schema_from_class<'py>(
     let mut cached_fields = Vec::new();
 
     let type_hints: Option<Bound<'py, PyDict>> = py
-        .import_bound("typing")
+        .import("typing")
         .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_bound(py, &py_name).unbind();
+            let py_string = PyString::new(py, &py_name).unbind();
             let mut xml_name = py_name.clone();
             let mut kind = FieldKind::Element;
 
@@ -220,10 +251,10 @@ 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_bound(py, &py_name).unbind();
+            let py_string = PyString::new(py, &py_name).unbind();
             let mut xml_name = py_name.clone();
             let mut kind = FieldKind::Element;
 
@@ -333,7 +364,7 @@ fn convert_scalar_to_py<'py>(
 ) -> PyResult<PyObject> {
     match val {
         PolyValue::Null => Ok(py.None()),
-        PolyValue::Bool(b) => Ok(b.to_object(py)),
+        PolyValue::Bool(b) => b.into_py_any(py),
         PolyValue::Int(i) => {
             if let Some(target_type) = py_type_opt {
                 if is_enum_class(py, target_type) {
@@ -342,9 +373,9 @@ fn convert_scalar_to_py<'py>(
                     }
                 }
             }
-            Ok(i.to_object(py))
+            i.into_py_any(py)
         }
-        PolyValue::Float(f) => Ok(f.to_object(py)),
+        PolyValue::Float(f) => f.into_py_any(py),
         PolyValue::String(s) => {
             if let Some(target_type) = py_type_opt {
                 if is_enum_class(py, target_type) {
@@ -368,7 +399,7 @@ fn convert_scalar_to_py<'py>(
 
                 match type_name.as_str() {
                     "Decimal" => {
-                        let decimal_cls = py.import_bound("decimal")?.getattr("Decimal")?;
+                        let decimal_cls = py.import("decimal")?.getattr("Decimal")?;
                         let dec = decimal_cls.call1((s.as_str(),))?;
                         return Ok(dec.unbind());
                     }
@@ -376,7 +407,7 @@ fn convert_scalar_to_py<'py>(
                         if let Ok(val) = target_type.call_method1("from_string", (s.as_str(),)) {
                             return Ok(val.unbind());
                         }
-                        if let Ok(datatype_mod) = py.import_bound("pyxsdata.models.datatype") {
+                        if let Ok(datatype_mod) = py.import("pyxsdata.models.datatype") {
                             if let Ok(cls) = datatype_mod.getattr(type_name.as_str()) {
                                 if let Ok(val) = cls.call_method1("from_string", (s.as_str(),)) {
                                     return Ok(val.unbind());
@@ -392,7 +423,7 @@ fn convert_scalar_to_py<'py>(
                             "XmlTime" => "time",
                             _ => "",
                         };
-                        if let Ok(datetime_mod) = py.import_bound("datetime") {
+                        if let Ok(datetime_mod) = py.import("datetime") {
                             if let Ok(cls) = datetime_mod.getattr(mod_name) {
                                 if let Ok(val) = cls.call_method1("fromisoformat", (s.as_str(),)) {
                                     return Ok(val.unbind());
@@ -404,7 +435,7 @@ fn convert_scalar_to_py<'py>(
                         if let Ok(val) = target_type.call1((s.as_str(),)) {
                             return Ok(val.unbind());
                         }
-                        if let Ok(datatype_mod) = py.import_bound("pyxsdata.models.datatype") {
+                        if let Ok(datatype_mod) = py.import("pyxsdata.models.datatype") {
                             if let Ok(cls) = datatype_mod.getattr("XmlDuration") {
                                 if let Ok(val) = cls.call1((s.as_str(),)) {
                                     return Ok(val.unbind());
@@ -415,7 +446,7 @@ fn convert_scalar_to_py<'py>(
                     _ => {}
                 }
             }
-            Ok(PyString::new_bound(py, s).into_any().unbind())
+            Ok(PyString::new(py, s).into_any().unbind())
         }
         _ => Ok(py.None()),
     }
@@ -430,7 +461,7 @@ fn poly_value_to_py<'py>(
 ) -> PyResult<PyObject> {
     match val {
         PolyValue::Null => Ok(py.None()),
-        PolyValue::Bool(b) => Ok(b.to_object(py)),
+        PolyValue::Bool(b) => b.into_py_any(py),
         PolyValue::Int(_) | PolyValue::Float(_) | PolyValue::String(_) => {
             let st = match val_type {
                 ValueType::Scalar(ref s) => s,
@@ -456,10 +487,10 @@ fn poly_value_to_py<'py>(
                         poly_value_to_py(py, item, inner_type, inner_cls.as_ref(), field_meta)?;
                     py_items.push(py_item);
                 }
-                let py_list = PyList::new_bound(py, &py_items);
+                let py_list = PyList::new(py, &py_items)?;
                 Ok(py_list.into_any().unbind())
             } else {
-                let py_list = PyList::empty_bound(py);
+                let py_list = PyList::empty(py);
                 Ok(py_list.into_any().unbind())
             }
         }
@@ -508,7 +539,7 @@ fn poly_value_to_py<'py>(
                                 }
                             }
                             if all_found {
-                                let tuple = pyo3::types::PyTuple::new_bound(py, &args_vec);
+                                let tuple = pyo3::types::PyTuple::new(py, &args_vec)?;
                                 if let Ok(instance) = target_cls.call1(tuple) {
                                     return Ok(instance.unbind());
                                 }
@@ -517,7 +548,7 @@ fn poly_value_to_py<'py>(
                     }
 
                     // Method 2: Keyword arguments with init=False post-init support
-                    let kwargs = PyDict::new_bound(py);
+                    let kwargs = PyDict::new(py);
                     let mut post_init_fields: Vec<(Py<PyString>, PyObject)> = Vec::new();
 
                     for (i, field) in schema.fields.iter().enumerate() {
@@ -546,7 +577,7 @@ fn poly_value_to_py<'py>(
                                 kwargs.set_item(&field.name, py_val)?;
                             } else {
                                 post_init_fields
-                                    .push((PyString::new_bound(py, &field.name).unbind(), py_val));
+                                    .push((PyString::new(py, &field.name).unbind(), py_val));
                             }
                         }
                     }
@@ -556,7 +587,7 @@ fn poly_value_to_py<'py>(
                     }
                     return Ok(instance.unbind());
                 }
-                let dict = PyDict::new_bound(py);
+                let dict = PyDict::new(py);
                 for (k, v) in map {
                     let py_v =
                         poly_value_to_py(py, v, &ValueType::Scalar(ScalarType::Any), None, None)?;
@@ -565,7 +596,7 @@ fn poly_value_to_py<'py>(
                 let instance = target_cls.call((), Some(&dict))?;
                 Ok(instance.unbind())
             } else {
-                let dict = PyDict::new_bound(py);
+                let dict = PyDict::new(py);
                 for (k, v) in map {
                     let py_v =
                         poly_value_to_py(py, v, &ValueType::Scalar(ScalarType::Any), None, None)?;
@@ -630,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)
@@ -763,7 +794,7 @@ fn serialize<'py>(
     let bytes = polyxml::serialize(root_name, &poly_val, &meta.schema, indent)
         .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
 
-    Ok(PyBytes::new_bound(py, &bytes))
+    Ok(PyBytes::new(py, &bytes))
 }
 
 #[pyfunction]

{polyxml-0.2.1 → polyxml-0.4.0}/crates/polyxml-python/tests/test_polyxml.py

@@ -329,3 +329,20 @@ 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
+

{polyxml-0.2.1 → polyxml-0.4.0}/pyproject.toml

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