polyxml 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -110,23 +110,20 @@ dependencies = [
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "e1c047a62b0cc3e145fa84415a3191f628e980b194c2755aa12300a4e6cbd928"
 dependencies = [
  "anes",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "is-terminal",
  "itertools",
  "num-traits",
- "once_cell",
  "oorandom",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "walkdir",
@@ -134,9 +131,9 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+checksum = "9b1bcc0dc7dfae599d84ad0b1a55f80cde8af3725da8313b528da95ef783e338"
 dependencies = [
  "cast",
  "itertools",
@@ -187,12 +184,6 @@ 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"
@@ -202,22 +193,11 @@ 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",
 ]
@@ -396,7 +376,7 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "polyxml"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "criterion",
  "lexical-core",
@@ -409,14 +389,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-js"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -426,12 +406,11 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "lexical-core",
  "polyxml",
  "pyo3",
- "quick-xml",
  "smallvec",
 ]
 
@@ -462,9 +441,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.6"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -480,9 +459,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.6"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -490,9 +469,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.6"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -500,9 +479,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.6"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -512,9 +491,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.6"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -525,9 +504,9 @@ dependencies = [
 
 [[package]]
 name = "quick-xml"
-version = "0.36.2"
+version = "0.37.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7649a7b4df05aed9ea7ec6f628c67c9953a43869b8bc50929569b2999d443fe"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
 dependencies = [
  "memchr",
  "serde",

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

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

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

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

{polyxml-0.2.0 → polyxml-0.3.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.37", 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.7", default-features = false, features = ["cargo_bench_support"] }
 pretty_assertions = "1.4"
 
 [[bench]]

{polyxml-0.2.0 → polyxml-0.3.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.0 → polyxml-0.3.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.23", features = ["abi3-py312", "extension-module"] }
 lexical-core = "1.0"
 smallvec = "1.16"

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

@@ -4,6 +4,7 @@
 
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict, PyList, PyString, PyTuple, PyType};
+use pyo3::IntoPyObjectExt;
 use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 
@@ -69,7 +70,7 @@ 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(enum_module) = py.import("enum") {
             if let Ok(enum_cls) = enum_module.getattr("Enum") {
                 if let Ok(py_enum) = enum_cls.downcast::<PyType>() {
                     return py_type.is_subclass(py_enum).unwrap_or(false);
@@ -160,7 +161,7 @@ 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())
@@ -170,7 +171,7 @@ fn extract_schema_from_class<'py>(
         let model_fields: Bound<'py, PyDict> = cls.getattr("model_fields")?.downcast_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;
 
@@ -223,7 +224,7 @@ fn extract_schema_from_class<'py>(
         let fields: Bound<'py, PyDict> = cls.getattr("__dataclass_fields__")?.downcast_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 +334,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 +343,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,52 +369,32 @@ 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());
                     }
-                    "XmlDate" => {
-                        if let Ok(datatype_mod) = py.import_bound("pyxsdata.models.datatype") {
-                            if let Ok(cls) = datatype_mod.getattr("XmlDate") {
-                                if let Ok(val) = cls.call_method1("from_string", (s.as_str(),)) {
-                                    return Ok(val.unbind());
-                                }
-                            }
+                    "XmlDate" | "XmlDateTime" | "XmlTime" => {
+                        if let Ok(val) = target_type.call_method1("from_string", (s.as_str(),)) {
+                            return Ok(val.unbind());
                         }
-                        if let Ok(datetime_mod) = py.import_bound("datetime") {
-                            if let Ok(cls) = datetime_mod.getattr("date") {
-                                if let Ok(val) = cls.call_method1("fromisoformat", (s.as_str(),)) {
-                                    return Ok(val.unbind());
-                                }
-                            }
-                        }
-                    }
-                    "XmlDateTime" => {
-                        if let Ok(datatype_mod) = py.import_bound("pyxsdata.models.datatype") {
-                            if let Ok(cls) = datatype_mod.getattr("XmlDateTime") {
+                        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());
                                 }
                             }
                         }
-                        if let Ok(datetime_mod) = py.import_bound("datetime") {
-                            if let Ok(cls) = datetime_mod.getattr("datetime") {
-                                if let Ok(val) = cls.call_method1("fromisoformat", (s.as_str(),)) {
-                                    return Ok(val.unbind());
-                                }
-                            }
-                        }
-                    }
-                    "XmlTime" => {
-                        if let Ok(datatype_mod) = py.import_bound("pyxsdata.models.datatype") {
-                            if let Ok(cls) = datatype_mod.getattr("XmlTime") {
-                                if let Ok(val) = cls.call_method1("from_string", (s.as_str(),)) {
-                                    return Ok(val.unbind());
-                                }
-                            }
+                        if let Ok(val) = target_type.call1((s.as_str(),)) {
+                            return Ok(val.unbind());
                         }
-                        if let Ok(datetime_mod) = py.import_bound("datetime") {
-                            if let Ok(cls) = datetime_mod.getattr("time") {
+                        let mod_name = match type_name.as_str() {
+                            "XmlDate" => "date",
+                            "XmlDateTime" => "datetime",
+                            "XmlTime" => "time",
+                            _ => "",
+                        };
+                        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());
                                 }
@@ -421,7 +402,10 @@ fn convert_scalar_to_py<'py>(
                         }
                     }
                     "XmlDuration" => {
-                        if let Ok(datatype_mod) = py.import_bound("pyxsdata.models.datatype") {
+                        if let Ok(val) = target_type.call1((s.as_str(),)) {
+                            return Ok(val.unbind());
+                        }
+                        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());
@@ -432,7 +416,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()),
     }
@@ -447,7 +431,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,
@@ -473,10 +457,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())
             }
         }
@@ -525,7 +509,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());
                                 }
@@ -534,7 +518,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() {
@@ -563,7 +547,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));
                             }
                         }
                     }
@@ -573,7 +557,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)?;
@@ -582,7 +566,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)?;
@@ -780,7 +764,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.0 → polyxml-0.3.0}/crates/polyxml-python/tests/test_polyxml.py

@@ -6,7 +6,66 @@ from enum import Enum
 
 import pytest
 from pydantic import BaseModel, Field
-from pyxsdata.models.datatype import XmlDate, XmlDateTime, XmlDuration, XmlTime
+
+try:
+    from pyxsdata.models.datatype import XmlDate, XmlDateTime, XmlDuration, XmlTime
+except ImportError:
+
+    class XmlDate:
+
+        def __init__(self, val: str):
+            self.val = val
+
+        @classmethod
+        def from_string(cls, val: str):
+            return cls(val)
+
+        def __eq__(self, other):
+            return isinstance(other, XmlDate) and self.val == other.val
+
+        def __str__(self):
+            return self.val
+
+    class XmlDateTime:
+
+        def __init__(self, val: str):
+            self.val = val
+
+        @classmethod
+        def from_string(cls, val: str):
+            return cls(val)
+
+        def __eq__(self, other):
+            return isinstance(other, XmlDateTime) and self.val == other.val
+
+        def __str__(self):
+            return self.val
+
+    class XmlTime:
+
+        def __init__(self, val: str):
+            self.val = val
+
+        @classmethod
+        def from_string(cls, val: str):
+            return cls(val)
+
+        def __eq__(self, other):
+            return isinstance(other, XmlTime) and self.val == other.val
+
+        def __str__(self):
+            return self.val
+
+    class XmlDuration:
+
+        def __init__(self, val: str):
+            self.val = val
+
+        def __eq__(self, other):
+            return isinstance(other, XmlDuration) and self.val == other.val
+
+        def __str__(self):
+            return self.val
 
 import polyxml
 

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

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