polyxml 0.34.8__tar.gz → 0.35.0__tar.gz

{polyxml-0.34.8 → polyxml-0.35.0}/Cargo.lock

@@ -474,9 +474,9 @@ dependencies = [
 
 [[package]]
 name = "napi-build"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0941983559cd62bfa7f04646a16428967a847365adeef27711e4e3927046bbed"
+checksum = "b899b545d3aa6dca985939059f258c5488d34e4ecf39c274e20009748f4b846d"
 
 [[package]]
 name = "napi-derive"
@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.34.8"
+version = "0.35.0"
 dependencies = [
  "criterion",
  "heck",
@@ -629,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.34.8"
+version = "0.35.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.34.8"
+version = "0.35.0"
 dependencies = [
  "clap",
  "glob",
@@ -650,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.34.8"
+version = "0.35.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -660,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.34.8"
+version = "0.35.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -670,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.34.8"
+version = "0.35.0"
 dependencies = [
  "polyxml",
  "quick-xml",
@@ -704,9 +704,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4688ddedf473e32662b9b067670129a8afb8c18e351482c70d62ba4a88171e8b"
+checksum = "700d18fa267b73b9b521fd7e13580e2f446916f176cacee1ab63fcc8191f1655"
 dependencies = [
  "libc",
  "once_cell",
@@ -718,18 +718,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f41027e41b4bd03f6e60f9f417fe24a6341a6bb744edd62b6f709f2a52ea30e9"
+checksum = "7b3fc0c4d08f6bb10e71fe39dfb9e2f59c6eb6854e22ec8092f50c69a4499adb"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e591a95526fead067432c3b3a33fc74770b87b1e04e73671090d9c2055a2b327"
+checksum = "dfc0b8e19df29aad7086cf977bb0c2a2f143e30567eb113e9cf72b62ca698330"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -737,9 +737,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73225868fc1cd84eef2c3c230ddb91273bf1de46aeb8a4248da76d32a0924a1c"
+checksum = "6100e8a4b5eba53afaa5ed078364851a0b2499c553a44c31026b929049b49dc6"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -749,9 +749,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.29.2"
+version = "0.29.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "571575aa3749fa6216757dd47d2a3e7ef360f329a40f0666a9fbd14889024952"
+checksum = "6143877a16e82b5a727b7127ff4cd86858a24a28d745d72f43e6f227c7b1bdb3"
 dependencies = [
  "heck",
  "proc-macro2",

{polyxml-0.34.8 → polyxml-0.35.0}/Cargo.toml

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

{polyxml-0.34.8 → polyxml-0.35.0}/PKG-INFO

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

{polyxml-0.34.8 → polyxml-0.35.0}/crates/polyxml-core/src/codegen/rust/mod.rs

@@ -1940,6 +1940,136 @@ impl RustCodegen {
         out.push_str("    }\n");
 
         out.push_str("}\n");
+        self.emit_incremental_roots(out, s, ir, types_with_lifetime);
+    }
+
+    /// Only expose the producer API where ordinary item codecs preserve the schema.
+    fn emit_incremental_roots(
+        &self,
+        out: &mut String,
+        s: &StructDef,
+        ir: &SchemaIR,
+        lifetimes: &HashSet<QName>,
+    ) {
+        fn supported(
+            s: &StructDef,
+            ir: &SchemaIR,
+            namespace: &Option<String>,
+            seen: &mut HashSet<QName>,
+        ) -> bool {
+            if ir
+                .upa_documents
+                .iter()
+                .find_map(|doc| doc.uniform_sequence(&s.qname, namespace))
+                != Some(true)
+            {
+                return false;
+            }
+            if !seen.insert(s.qname.clone()) {
+                return false;
+            }
+            if s.base_type.is_some()
+                || s.is_abstract
+                || s.is_mixed
+                || ir.ordered_types.contains(&s.qname)
+            {
+                return false;
+            }
+            if ir
+                .content_models
+                .get(&s.qname)
+                .is_some_and(|p| p.has_choice() || p.has_reference() || p.has_repeated_sequence())
+            {
+                return false;
+            }
+            s.fields.iter().all(|f| {
+                if f.nillable
+                    || f.is_cycle_cut
+                    || f.xml_name.contains(':')
+                    || f.type_ref.is_list()
+                    || f.type_ref.is_boxed()
+                {
+                    return false;
+                }
+                match f.kind {
+                    FieldKind::Element if &f.namespace != namespace => return false,
+                    FieldKind::Attribute if f.namespace.is_some() => return false,
+                    FieldKind::Element | FieldKind::Attribute | FieldKind::Text => {}
+                    _ => return false,
+                }
+                match &f.type_ref {
+                    TypeRef::Named(q) => match ir.types.get(q) {
+                        Some(TypeDef::Struct(child)) => {
+                            supported(child, ir, namespace, &mut seen.clone())
+                        }
+                        Some(TypeDef::Enum(_)) => true,
+                        _ => false,
+                    },
+                    TypeRef::Primitive(_) => true,
+                    _ => false,
+                }
+            })
+        }
+        if s.fields.len() != 1
+            || s.fields[0].kind != FieldKind::Element
+            || !s.fields[0].cardinality.is_list()
+        {
+            return;
+        }
+        let field = &s.fields[0];
+        let mut methods = HashSet::new();
+        for root in ir.elements.values() {
+            if root.type_ref != TypeRef::Named(s.qname.clone())
+                || root.nillable
+                || !supported(s, ir, &root.qname.namespace, &mut HashSet::new())
+            {
+                continue;
+            }
+            let name = type_ident(&s.qname);
+            let item_type = self.format_rust_type_ref(&field.type_ref, lifetimes);
+            let impl_type = if self.options.zero_copy && lifetimes.contains(&s.qname) {
+                format!("impl<'a> {name}<'a>")
+            } else {
+                format!("impl {name}")
+            };
+            let base_method = format!("write_{}_items", AsSnakeCase(&root.qname.local));
+            let mut method = base_method.clone();
+            let mut suffix = 2;
+            while !methods.insert(method.clone()) {
+                method = format!("{base_method}_{suffix}");
+                suffix += 1;
+            }
+            writeln!(out, "\n{impl_type} {{").unwrap();
+            out.push_str("    /// Produce a document incrementally, retaining only the current item.\n    /// Errors may leave partial XML in the sink; publish files only after success.\n");
+            writeln!(out, "    pub fn {method}<W: std::io::Write, I: IntoIterator<Item = {item_type}>>(sink: &mut W, items: I) -> Result<()> {{").unwrap();
+            out.push_str("        let writer = &mut Writer::new(sink);\n");
+            writeln!(
+                out,
+                "        let {}start = BytesStart::new({:?});",
+                if root.qname.namespace.is_some() {
+                    "mut "
+                } else {
+                    ""
+                },
+                root.qname.local
+            )
+            .unwrap();
+            if let Some(ns) = &root.qname.namespace {
+                writeln!(out, "        start.push_attribute((\"xmlns\", {ns:?}));").unwrap();
+            }
+            out.push_str("        writer.write_event(Event::Start(start))?;\n        let mut count = 0usize;\n");
+            let mut checks = String::new();
+            if let crate::ir::OccursLimit::Count(max) = field.cardinality.max_occurs {
+                writeln!(checks, "            if count == {max} {{ return Err(PolyXmlError::SchemaError(\"maxOccurs exceeded\".into())); }}").unwrap();
+            }
+            checks.push_str("            count = count.checked_add(1).ok_or_else(|| PolyXmlError::SchemaError(\"item count overflow\".into()))?;\n");
+            self.emit_pattern_check(&mut checks, field, "&item.to_string()", ir);
+            self.emit_element_serialize_from(out, field, "items", ir, Some("items"), &checks);
+            if field.cardinality.min_occurs > 0 {
+                writeln!(out, "        if count < {} {{ return Err(PolyXmlError::SchemaError(\"minOccurs not satisfied\".into())); }}", field.cardinality.min_occurs).unwrap();
+            }
+            writeln!(out, "        writer.write_event(Event::End(BytesEnd::new({:?})))?;\n        Ok(())\n    }}\n}}", root.qname.local).unwrap();
+        }
     }
 
     fn emit_integer_bounds(
@@ -2406,6 +2536,18 @@ impl RustCodegen {
         field: &FieldDef,
         rust_name: &str,
         ir: &SchemaIR,
+    ) {
+        self.emit_element_serialize_from(out, field, rust_name, ir, None, "");
+    }
+
+    fn emit_element_serialize_from(
+        &self,
+        out: &mut String,
+        field: &FieldDef,
+        rust_name: &str,
+        ir: &SchemaIR,
+        source: Option<&str>,
+        before_item: &str,
     ) {
         let is_list = field.cardinality.is_list() || field.type_ref.is_list();
         let is_optional = field.cardinality.is_optional() || field.nillable;
@@ -2415,7 +2557,11 @@ impl RustCodegen {
         let is_enum = self.field_is_enum(&field.type_ref, ir).is_some();
 
         if is_list {
-            let _ = writeln!(out, "        for item in &self.{} {{", rust_name);
+            let source = source
+                .map(str::to_owned)
+                .unwrap_or_else(|| format!("&self.{rust_name}"));
+            let _ = writeln!(out, "        for item in {source} {{");
+            out.push_str(before_item);
             if is_string {
                 let _ = writeln!(
                     out,

{polyxml-0.34.8 → polyxml-0.35.0}/crates/polyxml-core/src/schema.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -106,6 +107,12 @@ impl FieldSchema {
     }
 }
 
+#[derive(Debug, Default)]
+struct VariantRegistry {
+    schemas: RwLock<Vec<Arc<ModelSchema>>>,
+    populated: AtomicBool,
+}
+
 #[derive(Debug, Clone)]
 pub struct ModelSchema {
     pub name: String,
@@ -125,7 +132,7 @@ pub struct ModelSchema {
     pub content_pattern: Option<regex::Regex>,
     /// Concrete derivations eligible for `xsi:type` dispatch. Python may
     /// refresh this registry when subclasses are defined after first use.
-    variants: Arc<RwLock<Vec<Arc<ModelSchema>>>>,
+    variants: Arc<VariantRegistry>,
 }
 
 impl ModelSchema {
@@ -136,12 +143,27 @@ impl ModelSchema {
     /// Register the concrete derivations eligible for `xsi:type` dispatch.
     /// Replaces the registry when subclasses are discovered after first use.
     pub fn set_variants(&self, variants: Vec<Arc<ModelSchema>>) {
-        *self.variants.write().unwrap_or_else(|p| p.into_inner()) = variants;
+        let mut registered = self
+            .variants
+            .schemas
+            .write()
+            .unwrap_or_else(|p| p.into_inner());
+        *registered = variants;
+        // Publish emptiness while holding the registry lock. Cloned schemas
+        // share this flag, so later registration/clearing cannot leave a stale
+        // per-schema dispatch plan. Nonempty lookups still use the lock.
+        self.variants
+            .populated
+            .store(!registered.is_empty(), Ordering::Release);
     }
 
     /// Registered derivations for `xsi:type` dispatch (empty when none).
     pub fn variants(&self) -> Vec<Arc<ModelSchema>> {
+        if !self.has_variants() {
+            return Vec::new();
+        }
         self.variants
+            .schemas
             .read()
             .unwrap_or_else(|p| p.into_inner())
             .clone()
@@ -149,16 +171,16 @@ impl ModelSchema {
 
     /// Whether any `xsi:type` derivations are registered for this type.
     pub fn has_variants(&self) -> bool {
-        !self
-            .variants
-            .read()
-            .unwrap_or_else(|p| p.into_inner())
-            .is_empty()
+        self.variants.populated.load(Ordering::Acquire)
     }
 
     /// Look up a derivation by the QName local part of an `xsi:type` value.
     pub fn find_variant(&self, local: &[u8]) -> Option<Arc<ModelSchema>> {
+        if !self.has_variants() {
+            return None;
+        }
         self.variants
+            .schemas
             .read()
             .unwrap_or_else(|p| p.into_inner())
             .iter()
@@ -168,7 +190,11 @@ impl ModelSchema {
 
     /// Look up a derivation by its complete QName.
     pub fn find_variant_qname(&self, namespace: &str, local: &[u8]) -> Option<Arc<ModelSchema>> {
+        if !self.has_variants() {
+            return None;
+        }
         self.variants
+            .schemas
             .read()
             .unwrap_or_else(|p| p.into_inner())
             .iter()
@@ -180,7 +206,11 @@ impl ModelSchema {
 
     /// Whether `candidate` is a registered derivation of `self`.
     pub fn matches_variant(&self, candidate: &ModelSchema) -> bool {
+        if !self.has_variants() {
+            return false;
+        }
         self.variants
+            .schemas
             .read()
             .unwrap_or_else(|p| p.into_inner())
             .iter()
@@ -664,7 +694,7 @@ impl ModelSchemaBuilder {
             is_abstract: self.is_abstract,
             strict_root: self.strict_root,
             content_pattern: self.content_pattern,
-            variants: Arc::new(RwLock::new(Vec::new())),
+            variants: Arc::new(VariantRegistry::default()),
         })
     }
 }

{polyxml-0.34.8 → polyxml-0.35.0}/crates/polyxml-core/src/schema_parser/upa.rs

@@ -15,6 +15,8 @@ pub struct Document {
     groups: BTreeMap<QName, Model>,
     named: BTreeMap<QName, Model>,
     anonymous: Vec<(String, Model)>,
+    #[serde(default)]
+    unsupported_attribute_types: BTreeSet<QName>,
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 enum Model {
@@ -115,14 +117,7 @@ fn node(
                 Event::Start(child)
                     if matches!(
                         strip_prefix(child.name().into_inner()),
-                        "annotation"
-                            | "simpleType"
-                            | "attribute"
-                            | "attributeGroup"
-                            | "anyAttribute"
-                            | "unique"
-                            | "key"
-                            | "keyref"
+                        "annotation" | "simpleType" | "unique" | "key" | "keyref"
                     ) =>
                 {
                     reader.read_to_end(child.name())?;
@@ -130,14 +125,7 @@ fn node(
                 Event::Empty(child)
                     if matches!(
                         strip_prefix(child.name().into_inner()),
-                        "annotation"
-                            | "simpleType"
-                            | "attribute"
-                            | "attributeGroup"
-                            | "anyAttribute"
-                            | "unique"
-                            | "key"
-                            | "keyref"
+                        "annotation" | "simpleType" | "unique" | "key" | "keyref"
                     ) => {}
                 Event::Start(child) => {
                     result
@@ -256,6 +244,28 @@ fn particle(node: &Node, ns: Option<&str>, qualified: bool) -> Option<Model> {
     Some(repeat(node, model))
 }
 impl Document {
+    /// Whether a named type has plain sequence content in one element namespace.
+    /// Source QNames retain local `form` and `elementFormDefault` distinctions.
+    pub(crate) fn uniform_sequence(
+        &self,
+        name: &QName,
+        namespace: &Option<String>,
+    ) -> Option<bool> {
+        fn uniform(model: &Model, namespace: &Option<String>) -> bool {
+            match model {
+                Model::Element(q, _) => &q.namespace == namespace,
+                Model::Sequence(parts) => parts.iter().all(|p| uniform(p, namespace)),
+                Model::Repeat(part, _, _) if matches!(part.as_ref(), Model::Element(..)) => {
+                    uniform(part, namespace)
+                }
+                _ => false,
+            }
+        }
+        self.named.get(name).map(|model| {
+            !self.unsupported_attribute_types.contains(name) && uniform(model, namespace)
+        })
+    }
+
     pub fn parse(xml: &str) -> Result<Self, SchemaError> {
         let mut reader = Reader::from_str(xml);
         let root = loop {
@@ -273,13 +283,38 @@ impl Document {
             groups: BTreeMap::new(),
             named: BTreeMap::new(),
             anonymous: Vec::new(),
+            unsupported_attribute_types: BTreeSet::new(),
         };
-        fn collect(node: &Node, document: &mut Document, qualified: bool) {
+        fn qualified_attributes(node: &Node, default_qualified: bool) -> bool {
+            matches!(node.tag.as_str(), "attributeGroup" | "anyAttribute")
+                || (node.tag == "attribute"
+                    && (node.attr("ref").is_some()
+                        || match node.attr("form") {
+                            Some("qualified") => true,
+                            Some("unqualified") => false,
+                            _ => default_qualified,
+                        }))
+                || node
+                    .children
+                    .iter()
+                    .any(|child| qualified_attributes(child, default_qualified))
+        }
+        fn collect(
+            node: &Node,
+            document: &mut Document,
+            qualified: bool,
+            attributes_qualified: bool,
+        ) {
             let ns = document.namespace.as_deref();
             if node.tag == "complexType" {
                 let model = content(node, ns, qualified);
                 if let Some(name) = node.attr("name") {
                     document.named.insert(QName::new(ns, name), model);
+                    if qualified_attributes(node, attributes_qualified) {
+                        document
+                            .unsupported_attribute_types
+                            .insert(QName::new(ns, name));
+                    }
                 } else {
                     document.anonymous.push((
                         format!("anonymous complexType at byte {}", node.position),
@@ -288,7 +323,7 @@ impl Document {
                 }
             }
             for child in &node.children {
-                collect(child, document, qualified);
+                collect(child, document, qualified, attributes_qualified);
             }
         }
         for child in &root.children {
@@ -301,7 +336,12 @@ impl Document {
                 }
             }
         }
-        collect(&root, &mut document, qualified);
+        collect(
+            &root,
+            &mut document,
+            qualified,
+            root.attr("attributeFormDefault") == Some("qualified"),
+        );
         Ok(document)
     }
     pub fn adopt_namespace(&mut self, namespace: &str) {
@@ -344,6 +384,13 @@ impl Document {
                 _ => {}
             }
         }
+        self.unsupported_attribute_types = std::mem::take(&mut self.unsupported_attribute_types)
+            .into_iter()
+            .map(|mut q| {
+                name(&mut q, namespace);
+                q
+            })
+            .collect();
         for collection in [&mut self.groups, &mut self.named] {
             *collection = std::mem::take(collection)
                 .into_iter()

{polyxml-0.34.8 → polyxml-0.35.0}/crates/polyxml-core/tests/test_rust_codegen.rs

@@ -1505,3 +1505,52 @@ assert_eq!(parsed,value);let object:serde_json::Value=serde_json::from_str(&json
         );
     }
 }
+
+#[test]
+fn incremental_root_writer_is_schema_scoped() {
+    let xsd = include_str!("../../../tests/fixtures/incremental/items.xsd");
+    for zero_copy in [true, false] {
+        let ir = XsdParser::new().parse_str(xsd).unwrap();
+        let code = RustCodegen::new(RustOptions {
+            zero_copy,
+            ..Default::default()
+        })
+        .generate_module(&ir);
+        assert!(code.contains("pub fn write_batch_items"));
+        assert!(code.contains("for item in items"));
+        assert!(code.contains("start.push_attribute((\"xmlns\", \"urn:items\"))"));
+        assert!(code.contains("if count < 1"));
+        assert!(code.contains("item.encode_xml(writer, Some(\"Item\"))"));
+        let bounded = xsd.replace("maxOccurs=\"unbounded\"", "maxOccurs=\"2\"");
+        let ir = XsdParser::new().parse_str(&bounded).unwrap();
+        let code = RustCodegen::new(RustOptions::default()).generate_module(&ir);
+        assert!(code.contains("if count == 2"));
+        for unsupported in [
+            xsd.replace(
+                "elementFormDefault=\"qualified\"",
+                "elementFormDefault=\"qualified\" attributeFormDefault=\"qualified\"",
+            ),
+            xsd.replace("<xs:sequence>", "<xs:sequence minOccurs=\"0\">"),
+            xsd.replace(
+                "name=\"Item\" type=\"t:ItemType\"",
+                "name=\"Item\" type=\"t:ItemType\" nillable=\"true\"",
+            ),
+            xsd.replace(
+                "elementFormDefault=\"qualified\"",
+                "elementFormDefault=\"unqualified\"",
+            ),
+            xsd.replace(
+                "name=\"Batch\" type=\"t:BatchType\"",
+                "name=\"Batch\" type=\"t:BatchType\" nillable=\"true\"",
+            ),
+        ] {
+            let ir = XsdParser::new().parse_str(&unsupported).unwrap();
+            let code = RustCodegen::new(RustOptions::default()).generate_module(&ir);
+            assert!(
+                !code.contains("pub fn write_batch_items"),
+                "{unsupported}\n{:?}",
+                ir.upa_documents
+            );
+        }
+    }
+}

polyxml-0.35.0/crates/polyxml-core/tests/test_variant_registry.rs

@@ -0,0 +1,75 @@
+use std::sync::Arc;
+
+use polyxml::schema::ModelSchema;
+
+#[test]
+fn registration_and_clearing_are_visible_to_schema_clones() {
+    let base = ModelSchema::builder("Base").build();
+    let clone = (*base).clone();
+    let derived = ModelSchema::builder("Derived")
+        .namespace("urn:derived")
+        .build();
+    assert!(!clone.has_variants());
+    assert!(clone.variants().is_empty());
+    base.set_variants(vec![Arc::clone(&derived)]);
+    assert!(clone.has_variants());
+    assert!(Arc::ptr_eq(&clone.variants()[0], &derived));
+    assert!(Arc::ptr_eq(
+        &clone.find_variant(b"Derived").unwrap(),
+        &derived
+    ));
+    assert!(clone.find_variant_qname("urn:other", b"Derived").is_none());
+    assert!(Arc::ptr_eq(
+        &clone.find_variant_qname("urn:derived", b"Derived").unwrap(),
+        &derived
+    ));
+    assert!(clone.matches_variant(&derived));
+    clone.set_variants(Vec::new());
+    assert!(!base.has_variants());
+    assert!(base.variants().is_empty());
+    assert!(base.find_variant(b"Derived").is_none());
+    assert!(!base.matches_variant(&derived));
+    clone.set_variants(vec![Arc::clone(&derived)]);
+    assert!(base.has_variants());
+    assert!(base.matches_variant(&derived));
+}
+
+#[test]
+fn concurrent_registry_updates_keep_complete_variant_snapshots() {
+    let base = ModelSchema::builder("Base").build();
+    let derived = ModelSchema::builder("Derived").build();
+    std::thread::scope(|scope| {
+        scope.spawn(|| {
+            for index in 0..4096 {
+                base.set_variants(if index % 2 == 0 {
+                    Vec::new()
+                } else {
+                    vec![Arc::clone(&derived)]
+                });
+            }
+            base.set_variants(vec![Arc::clone(&derived)]);
+        });
+        for _ in 0..4 {
+            scope.spawn(|| {
+                for _ in 0..4096 {
+                    // These calls can observe different registry revisions.
+                    // Each populated snapshot must contain the original Arc.
+                    let _ = base.has_variants();
+                    let variants = base.variants();
+                    assert!(variants.len() <= 1);
+                    for variant in variants {
+                        assert!(Arc::ptr_eq(&variant, &derived));
+                    }
+                    if let Some(variant) = base.find_variant(b"Derived") {
+                        assert!(Arc::ptr_eq(&variant, &derived));
+                    }
+                }
+            });
+        }
+    });
+    assert!(base.has_variants());
+    assert!(Arc::ptr_eq(&base.variants()[0], &derived));
+    base.set_variants(Vec::new());
+    assert!(!base.has_variants());
+    assert!(base.variants().is_empty());
+}

{polyxml-0.34.8 → polyxml-0.35.0}/pyproject.toml

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