polyxml 0.8.1__tar.gz → 0.10.0__tar.gz

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

@@ -320,9 +320,9 @@ dependencies = [
 
 [[package]]
 name = "napi-build"
-version = "2.4.1"
+version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60fdf9b392c50e7c4170fa633bd909490ed7835cea4c046776d1a4dd8d2ae0ab"
+checksum = "860e7c40864f95cfb83cde99f9ebadd88ef3d9bdccd7dd2cee0cc96a2dd4ffa7"
 
 [[package]]
 name = "napi-derive"
@@ -395,7 +395,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.8.1"
+version = "0.10.0"
 dependencies = [
  "criterion",
  "lexical-core",
@@ -408,14 +408,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.8.1"
+version = "0.10.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-js"
-version = "0.8.1"
+version = "0.10.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.8.1"
+version = "0.10.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -629,9 +629,9 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "smallvec"
-version = "1.16.0"
+version = "1.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9be42f50aa861c555654aa3a37f52f4b1074bacf4e48fe0ef7fa584e80f1f0f"
+checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
 
 [[package]]
 name = "syn"

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

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

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

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

{polyxml-0.8.1 → polyxml-0.10.0}/crates/polyxml-core/src/lib.rs

@@ -37,6 +37,25 @@ pub fn serialize(
     XmlSerializer::serialize(root_name, value, schema, indent)
 }
 
+/// High-level function to serialize a PolyValue with optional namespace support and custom prefix mapping.
+pub fn serialize_with_options(
+    root_name: &str,
+    value: &PolyValue,
+    schema: &ModelSchema,
+    indent: Option<usize>,
+    enable_namespaces: Option<bool>,
+    ns_map: Option<&std::collections::HashMap<String, String>>,
+) -> Result<Vec<u8>> {
+    XmlSerializer::serialize_with_options(
+        root_name,
+        value,
+        schema,
+        indent,
+        enable_namespaces,
+        ns_map,
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -212,4 +231,129 @@ mod tests {
         let item4 = stream.next_item().unwrap();
         assert!(item4.is_none());
     }
+
+    #[test]
+    fn test_namespaced_serialization() {
+        use std::collections::HashMap;
+
+        let schema = ModelSchema::builder("Item")
+            .xml_name(b"item")
+            .namespace("http://example.com/ns1")
+            .field(
+                FieldSchema::new(
+                    "title",
+                    b"title",
+                    FieldKind::Element,
+                    ValueType::Scalar(ScalarType::String),
+                )
+                .namespace("http://example.com/ns1"),
+            )
+            .field(
+                FieldSchema::new(
+                    "sku",
+                    b"sku",
+                    FieldKind::Attribute,
+                    ValueType::Scalar(ScalarType::String),
+                )
+                .namespace("http://example.com/ns2"),
+            )
+            .field(FieldSchema::new(
+                "unprefixed_attr",
+                b"unprefixed_attr",
+                FieldKind::Attribute,
+                ValueType::Scalar(ScalarType::Int),
+            ))
+            .build();
+
+        let mut obj = HashMap::new();
+        obj.insert("title".into(), PolyValue::String("Laptop".into()));
+        obj.insert("sku".into(), PolyValue::String("SKU123".into()));
+        obj.insert("unprefixed_attr".into(), PolyValue::Int(42));
+        let poly_val = PolyValue::Object(obj);
+
+        // 1. Auto-detected namespaces
+        let xml_bytes = serialize("item", &poly_val, &schema, None).unwrap();
+        let xml_str = std::str::from_utf8(&xml_bytes).unwrap();
+
+        assert!(xml_str.contains("xmlns:ns0=\"http://example.com/ns1\""));
+        assert!(xml_str.contains("xmlns:ns1=\"http://example.com/ns2\""));
+        assert!(xml_str.starts_with("<ns0:item"));
+        assert!(xml_str.contains("ns1:sku=\"SKU123\""));
+        assert!(xml_str.contains("unprefixed_attr=\"42\""));
+        assert!(xml_str.contains("<ns0:title>Laptop</ns0:title>"));
+        assert!(xml_str.ends_with("</ns0:item>"));
+
+        // 2. Custom ns_map with default namespace for ns1
+        let mut custom_map = HashMap::new();
+        custom_map.insert("".into(), "http://example.com/ns1".into());
+        custom_map.insert("inv".into(), "http://example.com/ns2".into());
+
+        let custom_xml_bytes = serialize_with_options(
+            "item",
+            &poly_val,
+            &schema,
+            None,
+            Some(true),
+            Some(&custom_map),
+        )
+        .unwrap();
+        let custom_str = std::str::from_utf8(&custom_xml_bytes).unwrap();
+
+        assert!(custom_str.contains("xmlns=\"http://example.com/ns1\""));
+        assert!(custom_str.contains("xmlns:inv=\"http://example.com/ns2\""));
+        assert!(custom_str.starts_with("<item"));
+        assert!(custom_str.contains("inv:sku=\"SKU123\""));
+        assert!(custom_str.contains("<title>Laptop</title>"));
+        assert!(custom_str.ends_with("</item>"));
+
+        // 3. Explicitly disabled namespaces (fast-path)
+        let raw_xml_bytes =
+            serialize_with_options("item", &poly_val, &schema, None, Some(false), None).unwrap();
+        let raw_str = std::str::from_utf8(&raw_xml_bytes).unwrap();
+        assert!(!raw_str.contains("xmlns"));
+        assert!(raw_str.starts_with("<item"));
+        assert!(raw_str.contains("sku=\"SKU123\""));
+        assert!(raw_str.contains("<title>Laptop</title>"));
+
+        // 4. Verify deserialization roundtrip ignores xmlns attributes and handles prefixed elements
+        let roundtrip_val = deserialize(&xml_bytes, Arc::clone(&schema)).unwrap();
+        assert_eq!(
+            roundtrip_val.get("title"),
+            Some(&PolyValue::String("Laptop".into()))
+        );
+        assert_eq!(
+            roundtrip_val.get("sku"),
+            Some(&PolyValue::String("SKU123".into()))
+        );
+        assert_eq!(
+            roundtrip_val.get("unprefixed_attr"),
+            Some(&PolyValue::Int(42))
+        );
+    }
+
+    #[test]
+    fn test_deserialization_does_not_confuse_xmlns_with_attributes() {
+        // Schema has an attribute named "prefix"
+        let schema = ModelSchema::builder("Item")
+            .field(FieldSchema::new(
+                "prefix",
+                b"prefix",
+                FieldKind::Attribute,
+                ValueType::Scalar(ScalarType::String),
+            ))
+            .build();
+
+        // XML defines xmlns:prefix="http://example.com" and an actual attribute prefix="actual_val"
+        let xml = br#"<Item xmlns:prefix="http://example.com" prefix="actual_val" />"#;
+        let val = deserialize(xml, Arc::clone(&schema)).unwrap();
+        assert_eq!(
+            val.get("prefix"),
+            Some(&PolyValue::String("actual_val".into()))
+        );
+
+        // XML defines xmlns:prefix="http://example.com" but NO actual attribute prefix
+        let xml2 = br#"<Item xmlns:prefix="http://example.com" />"#;
+        let val2 = deserialize(xml2, Arc::clone(&schema)).unwrap();
+        assert_eq!(val2.get("prefix"), None);
+    }
 }

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

@@ -94,6 +94,10 @@ pub struct XmlDeserializer;
 
 fn is_nil_element(e: &BytesStart) -> bool {
     for attr in e.attributes().flatten() {
+        let raw_key = attr.key.as_ref();
+        if raw_key == "xmlns" || raw_key.starts_with("xmlns:") {
+            continue;
+        }
         let key = attr.key.local_name();
         if (key.as_ref() == "nil" || key.as_ref() == "xsi:nil")
             && (attr.value.as_ref() == "true" || attr.value.as_ref() == "1")
@@ -368,6 +372,10 @@ impl XmlDeserializer {
 
     pub(crate) fn parse_attributes(e: &BytesStart, frame: &mut StackFrame) -> Result<()> {
         for attr in e.attributes().flatten() {
+            let raw_key = attr.key.as_ref();
+            if raw_key == "xmlns" || raw_key.starts_with("xmlns:") {
+                continue;
+            }
             let key = attr.key.local_name();
             if let Some(&field_idx) = frame.schema.attribute_map.get(key.as_ref().as_bytes()) {
                 let field = &frame.schema.fields[field_idx];
@@ -407,12 +415,20 @@ impl<R: std::io::BufRead> XmlItemStream<R> {
     }
 
     pub fn next_item(&mut self) -> Result<Option<PolyValue>> {
+        let target_local = if let Some(pos) = self.target_tag.iter().position(|&b| b == b':') {
+            &self.target_tag[pos + 1..]
+        } else {
+            self.target_tag.as_slice()
+        };
+
         loop {
             self.buf.clear();
             match self.reader.read_event_into(&mut self.buf) {
                 Ok(Event::Start(ref e)) => {
                     let local = e.local_name();
-                    if local.as_ref().as_bytes() == self.target_tag.as_slice() {
+                    if local.as_ref().as_bytes() == target_local
+                        || e.name().as_ref().as_bytes() == self.target_tag.as_slice()
+                    {
                         let item = XmlDeserializer::parse_sub_tree(
                             &mut self.reader,
                             Arc::clone(&self.schema),
@@ -424,7 +440,9 @@ impl<R: std::io::BufRead> XmlItemStream<R> {
                 }
                 Ok(Event::Empty(ref e)) => {
                     let local = e.local_name();
-                    if local.as_ref().as_bytes() == self.target_tag.as_slice() {
+                    if local.as_ref().as_bytes() == target_local
+                        || e.name().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.8.1 → polyxml-0.10.0}/crates/polyxml-core/src/schema.rs

@@ -33,6 +33,7 @@ pub enum ValueType {
 pub struct FieldSchema {
     pub name: String,
     pub xml_name: Vec<u8>,
+    pub namespace: Option<String>,
     pub kind: FieldKind,
     pub val_type: ValueType,
     pub required: bool,
@@ -48,12 +49,18 @@ impl FieldSchema {
         Self {
             name: name.into(),
             xml_name: xml_name.to_vec(),
+            namespace: None,
             kind,
             val_type,
             required: false,
         }
     }
 
+    pub fn namespace(mut self, ns: impl Into<String>) -> Self {
+        self.namespace = Some(ns.into());
+        self
+    }
+
     pub fn required(mut self) -> Self {
         self.required = true;
         self
@@ -63,6 +70,8 @@ impl FieldSchema {
 #[derive(Debug, Clone)]
 pub struct ModelSchema {
     pub name: String,
+    pub xml_name: Vec<u8>,
+    pub namespace: Option<String>,
     pub fields: Vec<FieldSchema>,
     pub element_map: HashMap<Vec<u8>, usize>,
     pub attribute_map: HashMap<Vec<u8>, usize>,
@@ -77,6 +86,8 @@ impl ModelSchema {
 
 pub struct ModelSchemaBuilder {
     name: String,
+    xml_name: Option<Vec<u8>>,
+    namespace: Option<String>,
     fields: Vec<FieldSchema>,
 }
 
@@ -84,10 +95,22 @@ impl ModelSchemaBuilder {
     pub fn new(name: impl Into<String>) -> Self {
         Self {
             name: name.into(),
+            xml_name: None,
+            namespace: None,
             fields: Vec::new(),
         }
     }
 
+    pub fn xml_name(mut self, xml_name: &[u8]) -> Self {
+        self.xml_name = Some(xml_name.to_vec());
+        self
+    }
+
+    pub fn namespace(mut self, ns: impl Into<String>) -> Self {
+        self.namespace = Some(ns.into());
+        self
+    }
+
     pub fn field(mut self, field: FieldSchema) -> Self {
         self.fields.push(field);
         self
@@ -119,8 +142,14 @@ impl ModelSchemaBuilder {
             }
         }
 
+        let xml_name = self
+            .xml_name
+            .unwrap_or_else(|| self.name.as_bytes().to_vec());
+
         Arc::new(ModelSchema {
             name: self.name,
+            xml_name,
+            namespace: self.namespace,
             fields: self.fields,
             element_map,
             attribute_map,

polyxml-0.10.0/crates/polyxml-core/src/serializer.rs

@@ -0,0 +1,411 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::io::Cursor;
+
+use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
+use quick_xml::Writer;
+
+use crate::error::{PolyXmlError, Result};
+use crate::schema::{FieldKind, ModelSchema, ValueType};
+use crate::value::PolyValue;
+
+#[derive(Debug, Clone)]
+pub struct NamespaceContext {
+    pub uri_to_prefix: HashMap<String, String>,
+    pub prefix_to_uri: Vec<(String, String)>,
+}
+
+impl NamespaceContext {
+    pub fn build(
+        root_schema: &ModelSchema,
+        user_ns_map: Option<&HashMap<String, String>>,
+    ) -> Option<Self> {
+        let mut uris = Vec::new();
+        Self::collect_namespaces(root_schema, &mut uris);
+
+        if uris.is_empty() && user_ns_map.is_none_or(|m| m.is_empty()) {
+            return None;
+        }
+
+        let mut uri_to_prefix = HashMap::new();
+        let mut prefix_to_uri = Vec::new();
+
+        // 1. Process user ns_map
+        if let Some(map) = user_ns_map {
+            for (k, v) in map {
+                let (prefix, uri) = if v.contains("://") || v.starts_with("urn:") {
+                    (k.clone(), v.clone())
+                } else if k.contains("://") || k.starts_with("urn:") {
+                    (v.clone(), k.clone())
+                } else {
+                    (k.clone(), v.clone())
+                };
+
+                let clean_prefix = if prefix == "None" {
+                    String::new()
+                } else {
+                    prefix
+                };
+                if !uri.is_empty() && !uri_to_prefix.contains_key(&uri) {
+                    uri_to_prefix.insert(uri.clone(), clean_prefix.clone());
+                    prefix_to_uri.push((clean_prefix, uri));
+                }
+            }
+        }
+
+        // 2. Assign prefixes for remaining schema URIs
+        let mut ns_counter = 0;
+        for uri in uris {
+            if !uri_to_prefix.contains_key(&uri) {
+                let prefix = match uri.as_str() {
+                    "http://www.w3.org/2001/XMLSchema-instance" => "xsi".to_string(),
+                    "http://www.w3.org/2001/XMLSchema" => "xs".to_string(),
+                    "http://www.w3.org/XML/1998/namespace" => "xml".to_string(),
+                    _ => loop {
+                        let candidate = format!("ns{}", ns_counter);
+                        ns_counter += 1;
+                        if !prefix_to_uri.iter().any(|(p, _)| p == &candidate) {
+                            break candidate;
+                        }
+                    },
+                };
+
+                uri_to_prefix.insert(uri.clone(), prefix.clone());
+                prefix_to_uri.push((prefix, uri));
+            }
+        }
+
+        Some(Self {
+            uri_to_prefix,
+            prefix_to_uri,
+        })
+    }
+
+    fn collect_namespaces(schema: &ModelSchema, uris: &mut Vec<String>) {
+        if let Some(ref ns) = schema.namespace {
+            if !ns.is_empty() && !uris.contains(ns) {
+                uris.push(ns.clone());
+            }
+        }
+        for field in &schema.fields {
+            if let Some(ref ns) = field.namespace {
+                if !ns.is_empty() && !uris.contains(ns) {
+                    uris.push(ns.clone());
+                }
+            }
+            match &field.val_type {
+                ValueType::Nested(nested) => Self::collect_namespaces(nested, uris),
+                ValueType::List(inner) => {
+                    if let ValueType::Nested(nested) = inner.as_ref() {
+                        Self::collect_namespaces(nested, uris);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    pub fn qualify_element<'a>(&'a self, local_name: &'a str, ns: Option<&str>) -> Cow<'a, str> {
+        if let Some(ns_uri) = ns {
+            if let Some(prefix) = self.uri_to_prefix.get(ns_uri) {
+                if !prefix.is_empty() {
+                    return Cow::Owned(format!("{}:{}", prefix, local_name));
+                }
+            }
+        }
+        Cow::Borrowed(local_name)
+    }
+
+    pub fn qualify_attribute<'a>(&'a self, local_name: &'a str, ns: Option<&str>) -> Cow<'a, str> {
+        if let Some(ns_uri) = ns {
+            if let Some(prefix) = self.uri_to_prefix.get(ns_uri) {
+                if !prefix.is_empty() {
+                    return Cow::Owned(format!("{}:{}", prefix, local_name));
+                }
+            }
+        }
+        Cow::Borrowed(local_name)
+    }
+}
+
+pub struct XmlSerializer;
+
+impl XmlSerializer {
+    pub fn serialize(
+        root_name: &str,
+        value: &PolyValue,
+        schema: &ModelSchema,
+        indent: Option<usize>,
+    ) -> Result<Vec<u8>> {
+        Self::serialize_with_options(root_name, value, schema, indent, None, None)
+    }
+
+    pub fn serialize_with_options(
+        root_name: &str,
+        value: &PolyValue,
+        schema: &ModelSchema,
+        indent: Option<usize>,
+        enable_namespaces: Option<bool>,
+        ns_map: Option<&HashMap<String, String>>,
+    ) -> Result<Vec<u8>> {
+        let mut buffer = Cursor::new(Vec::with_capacity(512));
+        let mut writer = match indent {
+            Some(spaces) => Writer::new_with_indent(&mut buffer, b' ', spaces),
+            None => Writer::new(&mut buffer),
+        };
+
+        let ns_ctx = match enable_namespaces {
+            Some(false) => None,
+            _ => NamespaceContext::build(schema, ns_map),
+        };
+
+        Self::write_model(
+            &mut writer,
+            root_name.as_bytes(),
+            value,
+            schema,
+            ns_ctx.as_ref(),
+            true,
+            schema.namespace.as_deref(),
+        )?;
+
+        Ok(buffer.into_inner())
+    }
+
+    fn format_scalar_to<'a>(
+        val: &'a PolyValue,
+        buf: &'a mut [u8; lexical_core::BUFFER_SIZE],
+    ) -> Option<&'a str> {
+        match val {
+            PolyValue::String(s) => Some(s.as_str()),
+            PolyValue::Int(i) => {
+                let bytes = lexical_core::write(*i, buf);
+                std::str::from_utf8(bytes).ok()
+            }
+            PolyValue::Float(f) => {
+                let bytes = lexical_core::write(*f, buf);
+                std::str::from_utf8(bytes).ok()
+            }
+            PolyValue::Bool(b) => Some(if *b { "true" } else { "false" }),
+            _ => None,
+        }
+    }
+
+    fn write_model<W: std::io::Write>(
+        writer: &mut Writer<W>,
+        tag_name: &[u8],
+        value: &PolyValue,
+        schema: &ModelSchema,
+        ns_ctx: Option<&NamespaceContext>,
+        is_root: bool,
+        element_ns: Option<&str>,
+    ) -> Result<()> {
+        let obj = match value {
+            PolyValue::Object(o) => o,
+            _ => {
+                return Err(PolyXmlError::SerializationError(
+                    "Expected Object value for model".into(),
+                ))
+            }
+        };
+
+        let local_tag = std::str::from_utf8(tag_name)?;
+        let qualified_tag = if let Some(ctx) = ns_ctx {
+            ctx.qualify_element(local_tag, element_ns)
+        } else {
+            Cow::Borrowed(local_tag)
+        };
+
+        let mut elem = BytesStart::new(qualified_tag.as_ref());
+
+        // Emit xmlns declarations on root element
+        if is_root {
+            if let Some(ctx) = ns_ctx {
+                for (prefix, uri) in &ctx.prefix_to_uri {
+                    if prefix.is_empty() {
+                        elem.push_attribute(("xmlns", uri.as_str()));
+                    } else {
+                        let attr_name = format!("xmlns:{}", prefix);
+                        elem.push_attribute((attr_name.as_str(), uri.as_str()));
+                    }
+                }
+            }
+        }
+
+        // 1. Collect and write attributes
+        for field in &schema.fields {
+            if field.kind == FieldKind::Attribute {
+                if let Some(val) = obj.get(&field.name) {
+                    if !val.is_null() {
+                        let local_attr = std::str::from_utf8(&field.xml_name)?;
+                        let attr_name = if let Some(ctx) = ns_ctx {
+                            ctx.qualify_attribute(local_attr, field.namespace.as_deref())
+                        } else {
+                            Cow::Borrowed(local_attr)
+                        };
+                        let mut buf = [0u8; lexical_core::BUFFER_SIZE];
+                        if let Some(attr_str) = Self::format_scalar_to(val, &mut buf) {
+                            elem.push_attribute((attr_name.as_ref(), attr_str));
+                        }
+                    }
+                }
+            }
+        }
+
+        writer
+            .write_event(Event::Start(elem))
+            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+
+        // 2. Write text content if present
+        if let Some(text_idx) = schema.text_field {
+            let field = &schema.fields[text_idx];
+            if let Some(val) = obj.get(&field.name) {
+                let mut buf = [0u8; lexical_core::BUFFER_SIZE];
+                if let Some(text_content) = Self::format_scalar_to(val, &mut buf) {
+                    if !text_content.is_empty() {
+                        writer
+                            .write_event(Event::Text(BytesText::new(text_content)))
+                            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+                    }
+                } else if let PolyValue::List(items) = val {
+                    for item in items {
+                        let mut item_buf = [0u8; lexical_core::BUFFER_SIZE];
+                        if let Some(text_content) = Self::format_scalar_to(item, &mut item_buf) {
+                            if !text_content.is_empty() {
+                                writer
+                                    .write_event(Event::Text(BytesText::new(text_content)))
+                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // 3. Write child elements
+        for field in &schema.fields {
+            if field.kind == FieldKind::Element {
+                if let Some(val) = obj.get(&field.name) {
+                    if val.is_null() {
+                        continue;
+                    }
+                    let child_element_ns =
+                        field.namespace.as_deref().or(schema.namespace.as_deref());
+
+                    match &field.val_type {
+                        ValueType::Scalar(_) => {
+                            let mut buf = [0u8; lexical_core::BUFFER_SIZE];
+                            if let Some(text) = Self::format_scalar_to(val, &mut buf) {
+                                let local_child = std::str::from_utf8(&field.xml_name)?;
+                                let child_tag = if let Some(ctx) = ns_ctx {
+                                    ctx.qualify_element(local_child, child_element_ns)
+                                } else {
+                                    Cow::Borrowed(local_child)
+                                };
+
+                                writer
+                                    .write_event(Event::Start(BytesStart::new(child_tag.as_ref())))
+                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+                                writer
+                                    .write_event(Event::Text(BytesText::new(text)))
+                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+                                writer
+                                    .write_event(Event::End(BytesEnd::new(child_tag.as_ref())))
+                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+                            }
+                        }
+                        ValueType::List(inner) => {
+                            if let PolyValue::List(items) = val {
+                                for item in items {
+                                    match inner.as_ref() {
+                                        ValueType::Scalar(_) => {
+                                            let mut buf = [0u8; lexical_core::BUFFER_SIZE];
+                                            if let Some(text) =
+                                                Self::format_scalar_to(item, &mut buf)
+                                            {
+                                                let local_child =
+                                                    std::str::from_utf8(&field.xml_name)?;
+                                                let child_tag = if let Some(ctx) = ns_ctx {
+                                                    ctx.qualify_element(
+                                                        local_child,
+                                                        child_element_ns,
+                                                    )
+                                                } else {
+                                                    Cow::Borrowed(local_child)
+                                                };
+
+                                                writer
+                                                    .write_event(Event::Start(BytesStart::new(
+                                                        child_tag.as_ref(),
+                                                    )))
+                                                    .map_err(|e| {
+                                                        PolyXmlError::SerializationError(
+                                                            e.to_string(),
+                                                        )
+                                                    })?;
+                                                writer
+                                                    .write_event(Event::Text(BytesText::new(text)))
+                                                    .map_err(|e| {
+                                                        PolyXmlError::SerializationError(
+                                                            e.to_string(),
+                                                        )
+                                                    })?;
+                                                writer
+                                                    .write_event(Event::End(BytesEnd::new(
+                                                        child_tag.as_ref(),
+                                                    )))
+                                                    .map_err(|e| {
+                                                        PolyXmlError::SerializationError(
+                                                            e.to_string(),
+                                                        )
+                                                    })?;
+                                            }
+                                        }
+                                        ValueType::Nested(nested_schema) => {
+                                            let nested_ns = field
+                                                .namespace
+                                                .as_deref()
+                                                .or(nested_schema.namespace.as_deref());
+                                            Self::write_model(
+                                                writer,
+                                                &field.xml_name,
+                                                item,
+                                                nested_schema,
+                                                ns_ctx,
+                                                false,
+                                                nested_ns,
+                                            )?;
+                                        }
+                                        ValueType::List(_) => {}
+                                    }
+                                }
+                            }
+                        }
+                        ValueType::Nested(nested_schema) => {
+                            let nested_ns = field
+                                .namespace
+                                .as_deref()
+                                .or(nested_schema.namespace.as_deref());
+                            Self::write_model(
+                                writer,
+                                &field.xml_name,
+                                val,
+                                nested_schema,
+                                ns_ctx,
+                                false,
+                                nested_ns,
+                            )?;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Close element
+        writer
+            .write_event(Event::End(BytesEnd::new(qualified_tag.as_ref())))
+            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+
+        Ok(())
+    }
+}

{polyxml-0.8.1 → polyxml-0.10.0}/crates/polyxml-python/src/lib.rs

@@ -188,6 +188,24 @@ fn extract_schema_from_class<'py>(
     let py = cls.py();
     let class_name: String = cls.getattr("__name__")?.extract()?;
     let mut builder = ModelSchema::builder(class_name);
+
+    if let Ok(meta_cls) = cls.getattr("Meta") {
+        if let Ok(name_val) = meta_cls.getattr("name") {
+            if let Ok(name_str) = name_val.extract::<String>() {
+                if !name_str.is_empty() {
+                    builder = builder.xml_name(name_str.as_bytes());
+                }
+            }
+        }
+        if let Ok(ns_val) = meta_cls.getattr("namespace") {
+            if let Ok(ns_str) = ns_val.extract::<String>() {
+                if !ns_str.is_empty() {
+                    builder = builder.namespace(ns_str);
+                }
+            }
+        }
+    }
+
     let mut cached_fields = Vec::new();
 
     let type_hints: Option<Bound<'py, PyDict>> = py
@@ -204,6 +222,7 @@ fn extract_schema_from_class<'py>(
             let py_string = PyString::new(py, &py_name).unbind();
             let mut xml_name = py_name.clone();
             let mut kind = FieldKind::Element;
+            let mut field_ns: Option<String> = None;
 
             let meta = field_obj
                 .getattr("xsdata_metadata")
@@ -229,6 +248,13 @@ fn extract_schema_from_class<'py>(
                 if let Ok(n) = m.get_item("name") {
                     xml_name = n.extract().unwrap_or(py_name.clone());
                 }
+                if let Ok(ns) = m.get_item("namespace") {
+                    if let Ok(ns_str) = ns.extract::<String>() {
+                        if !ns_str.is_empty() {
+                            field_ns = Some(ns_str);
+                        }
+                    }
+                }
             }
 
             let field_type = if let Some(ref hints) = type_hints {
@@ -250,12 +276,11 @@ fn extract_schema_from_class<'py>(
                 py_type: Some(unwrapped_type.into_any().unbind()),
             });
 
-            builder = builder.field(FieldSchema::new(
-                py_name,
-                xml_name.as_bytes(),
-                kind,
-                val_type,
-            ));
+            let mut field_schema = FieldSchema::new(py_name, xml_name.as_bytes(), kind, val_type);
+            if let Some(ns) = field_ns {
+                field_schema = field_schema.namespace(ns);
+            }
+            builder = builder.field(field_schema);
         }
     } else if cls.hasattr("__dataclass_fields__")? {
         let fields: Bound<'py, PyDict> = cls.getattr("__dataclass_fields__")?.cast_into()?;
@@ -264,6 +289,7 @@ fn extract_schema_from_class<'py>(
             let py_string = PyString::new(py, &py_name).unbind();
             let mut xml_name = py_name.clone();
             let mut kind = FieldKind::Element;
+            let mut field_ns: Option<String> = None;
 
             if let Ok(meta) = field_obj.getattr("metadata") {
                 if let Ok(t) = meta.get_item("type") {
@@ -284,6 +310,13 @@ fn extract_schema_from_class<'py>(
                 if let Ok(n) = meta.get_item("name") {
                     xml_name = n.extract().unwrap_or(py_name.clone());
                 }
+                if let Ok(ns) = meta.get_item("namespace") {
+                    if let Ok(ns_str) = ns.extract::<String>() {
+                        if !ns_str.is_empty() {
+                            field_ns = Some(ns_str);
+                        }
+                    }
+                }
             }
 
             let is_init = field_obj
@@ -315,12 +348,11 @@ fn extract_schema_from_class<'py>(
                 py_type: Some(unwrapped_type.into_any().unbind()),
             });
 
-            builder = builder.field(FieldSchema::new(
-                py_name,
-                xml_name.as_bytes(),
-                kind,
-                val_type,
-            ));
+            let mut field_schema = FieldSchema::new(py_name, xml_name.as_bytes(), kind, val_type);
+            if let Some(ns) = field_ns {
+                field_schema = field_schema.namespace(ns);
+            }
+            builder = builder.field(field_schema);
         }
     }
 
@@ -793,20 +825,49 @@ impl XmlIterator {
 }
 
 #[pyfunction]
-#[pyo3(signature = (obj, indent=None))]
+#[pyo3(signature = (obj, indent=None, namespaces=None, ns_map=None))]
 fn serialize<'py>(
     py: Python<'py>,
     obj: Bound<'py, PyAny>,
     indent: Option<usize>,
+    namespaces: Option<bool>,
+    ns_map: Option<Bound<'py, PyDict>>,
 ) -> PyResult<Bound<'py, PyBytes>> {
     let cls = obj.get_type();
     let meta = get_or_create_schema_meta(&cls)?;
 
     let poly_val = py_to_poly_value(py, &obj, &meta.schema, Some(&meta))?;
-    let root_name = meta.schema.name.as_str();
+    let root_name = std::str::from_utf8(&meta.schema.xml_name).unwrap_or(meta.schema.name.as_str());
 
-    let bytes = polyxml::serialize(root_name, &poly_val, &meta.schema, indent)
-        .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
+    let rust_ns_map = if let Some(dict) = ns_map {
+        let mut map = std::collections::HashMap::new();
+        for (k, v) in dict.iter() {
+            let k_str = if k.is_none() {
+                String::new()
+            } else {
+                k.extract::<String>().unwrap_or_default()
+            };
+            let v_str = if v.is_none() {
+                String::new()
+            } else {
+                v.extract::<String>().unwrap_or_default()
+            };
+            map.insert(k_str, v_str);
+        }
+        Some(map)
+    } else {
+        None
+    };
+
+    let bytes = polyxml::serialize_with_options(
+        root_name,
+        &poly_val,
+        &meta.schema,
+        indent,
+        namespaces,
+        rust_ns_map.as_ref(),
+    )
+    .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
 
     Ok(PyBytes::new(py, &bytes))
 }

{polyxml-0.8.1 → polyxml-0.10.0}/crates/polyxml-python/tests/test_polyxml.py

@@ -561,3 +561,69 @@ def test_mixed_content_wildcard_dataclass():
     serialized = polyxml.serialize(decoded)
     assert b"Sample Text Content" in serialized
     assert b'lang="en"' in serialized
+
+
+def test_namespaced_dataclass_serialization():
+    @dataclass
+    class Item:
+        class Meta:
+            name = "item"
+            namespace = "http://example.com/ns1"
+
+        title: str = field(metadata={"type": "Element", "namespace": "http://example.com/ns1"})
+        sku: str = field(metadata={"type": "Attribute", "namespace": "http://example.com/ns2"})
+        local_attr: int = field(default=99, metadata={"type": "Attribute"})
+
+    item = Item(title="Smartphone", sku="SKU-888", local_attr=99)
+
+    # 1. Auto-detected namespaces
+    xml_bytes = polyxml.serialize(item)
+    xml_str = xml_bytes.decode("utf-8")
+    assert 'xmlns:ns0="http://example.com/ns1"' in xml_str
+    assert 'xmlns:ns1="http://example.com/ns2"' in xml_str
+    assert xml_str.startswith("<ns0:item")
+    assert 'ns1:sku="SKU-888"' in xml_str
+    assert 'local_attr="99"' in xml_str
+    assert "<ns0:title>Smartphone</ns0:title>" in xml_str
+    assert xml_str.endswith("</ns0:item>")
+
+    # 2. Custom ns_map with default namespace
+    ns_map = {None: "http://example.com/ns1", "inv": "http://example.com/ns2"}
+    xml_custom = polyxml.serialize(item, ns_map=ns_map).decode("utf-8")
+    assert 'xmlns="http://example.com/ns1"' in xml_custom
+    assert 'xmlns:inv="http://example.com/ns2"' in xml_custom
+    assert xml_custom.startswith("<item")
+    assert 'inv:sku="SKU-888"' in xml_custom
+    assert "<title>Smartphone</title>" in xml_custom
+    assert xml_custom.endswith("</item>")
+
+    # 3. Explicitly disabled namespaces (toggle=False)
+    xml_raw = polyxml.serialize(item, namespaces=False).decode("utf-8")
+    assert "xmlns" not in xml_raw
+    assert xml_raw.startswith("<item")
+    assert 'sku="SKU-888"' in xml_raw
+    assert "<title>Smartphone</title>" in xml_raw
+
+
+def test_namespaced_pydantic_serialization():
+    class PydanticItem(BaseModel):
+        class Meta:
+            name = "product"
+            namespace = "http://example.com/prod"
+
+        name: str = Field(
+            json_schema_extra={"type": "Element", "namespace": "http://example.com/prod"}
+        )
+        code: str = Field(
+            json_schema_extra={"type": "Attribute", "namespace": "http://example.com/meta"}
+        )
+
+    prod = PydanticItem(name="Tablet", code="TAB-1")
+    xml_bytes = polyxml.serialize(prod, namespaces=True)
+    xml_str = xml_bytes.decode("utf-8")
+
+    assert 'xmlns:ns0="http://example.com/prod"' in xml_str
+    assert 'xmlns:ns1="http://example.com/meta"' in xml_str
+    assert xml_str.startswith("<ns0:product")
+    assert 'ns1:code="TAB-1"' in xml_str
+    assert "<ns0:name>Tablet</ns0:name>" in xml_str

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

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

{polyxml-0.8.1 → polyxml-0.10.0}/python/polyxml/__init__.py

@@ -104,17 +104,28 @@ def iterparse[T](
     return _iterparse(_to_bytes(source), target_type, tag)
 
 
-def serialize(obj: object, *, indent: int | None = None) -> bytes:
+def serialize(
+    obj: object,
+    *,
+    indent: int | None = None,
+    namespaces: bool | None = None,
+    ns_map: dict[str, str] | 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.
+        namespaces: Optional boolean toggle to enable or disable XML namespace prefix
+            resolution and root xmlns attribute generation. When None (default),
+            namespaces are automatically enabled if the model or fields define
+            namespaces or if ns_map is provided.
+        ns_map: Optional prefix-to-URI or URI-to-prefix mapping dictionary for XML namespaces.
 
     Returns:
         UTF-8 encoded XML bytes representing the model instance.
     """
-    return _serialize(obj, indent=indent)
+    return _serialize(obj, indent=indent, namespaces=namespaces, ns_map=ns_map)
 
 
 try:

polyxml-0.8.1/crates/polyxml-core/src/serializer.rs

@@ -1,200 +0,0 @@
-use std::io::Cursor;
-
-use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
-use quick_xml::Writer;
-
-use crate::error::{PolyXmlError, Result};
-use crate::schema::{FieldKind, ModelSchema, ValueType};
-use crate::value::PolyValue;
-
-pub struct XmlSerializer;
-
-impl XmlSerializer {
-    pub fn serialize(
-        root_name: &str,
-        value: &PolyValue,
-        schema: &ModelSchema,
-        indent: Option<usize>,
-    ) -> Result<Vec<u8>> {
-        let mut buffer = Cursor::new(Vec::with_capacity(512));
-        let mut writer = match indent {
-            Some(spaces) => Writer::new_with_indent(&mut buffer, b' ', spaces),
-            None => Writer::new(&mut buffer),
-        };
-
-        Self::write_model(&mut writer, root_name.as_bytes(), value, schema)?;
-
-        Ok(buffer.into_inner())
-    }
-
-    fn format_scalar_to<'a>(
-        val: &'a PolyValue,
-        buf: &'a mut [u8; lexical_core::BUFFER_SIZE],
-    ) -> Option<&'a str> {
-        match val {
-            PolyValue::String(s) => Some(s.as_str()),
-            PolyValue::Int(i) => {
-                let bytes = lexical_core::write(*i, buf);
-                std::str::from_utf8(bytes).ok()
-            }
-            PolyValue::Float(f) => {
-                let bytes = lexical_core::write(*f, buf);
-                std::str::from_utf8(bytes).ok()
-            }
-            PolyValue::Bool(b) => Some(if *b { "true" } else { "false" }),
-            _ => None,
-        }
-    }
-
-    fn write_model<W: std::io::Write>(
-        writer: &mut Writer<W>,
-        tag_name: &[u8],
-        value: &PolyValue,
-        schema: &ModelSchema,
-    ) -> Result<()> {
-        let obj = match value {
-            PolyValue::Object(o) => o,
-            _ => {
-                return Err(PolyXmlError::SerializationError(
-                    "Expected Object value for model".into(),
-                ))
-            }
-        };
-
-        let mut elem = BytesStart::new(std::str::from_utf8(tag_name)?);
-
-        // 1. Collect and write attributes
-        for field in &schema.fields {
-            if field.kind == FieldKind::Attribute {
-                if let Some(val) = obj.get(&field.name) {
-                    if !val.is_null() {
-                        let attr_name = std::str::from_utf8(&field.xml_name)?;
-                        let mut buf = [0u8; lexical_core::BUFFER_SIZE];
-                        if let Some(attr_str) = Self::format_scalar_to(val, &mut buf) {
-                            elem.push_attribute((attr_name, attr_str));
-                        }
-                    }
-                }
-            }
-        }
-
-        writer
-            .write_event(Event::Start(elem))
-            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
-
-        // 2. Write text content if present
-        if let Some(text_idx) = schema.text_field {
-            let field = &schema.fields[text_idx];
-            if let Some(val) = obj.get(&field.name) {
-                let mut buf = [0u8; lexical_core::BUFFER_SIZE];
-                if let Some(text_content) = Self::format_scalar_to(val, &mut buf) {
-                    if !text_content.is_empty() {
-                        writer
-                            .write_event(Event::Text(BytesText::new(text_content)))
-                            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
-                    }
-                } else if let PolyValue::List(items) = val {
-                    for item in items {
-                        let mut item_buf = [0u8; lexical_core::BUFFER_SIZE];
-                        if let Some(text_content) = Self::format_scalar_to(item, &mut item_buf) {
-                            if !text_content.is_empty() {
-                                writer
-                                    .write_event(Event::Text(BytesText::new(text_content)))
-                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // 3. Write child elements
-        for field in &schema.fields {
-            if field.kind == FieldKind::Element {
-                if let Some(val) = obj.get(&field.name) {
-                    if val.is_null() {
-                        continue;
-                    }
-                    match &field.val_type {
-                        ValueType::Scalar(_) => {
-                            let mut buf = [0u8; lexical_core::BUFFER_SIZE];
-                            if let Some(text) = Self::format_scalar_to(val, &mut buf) {
-                                let child_tag = std::str::from_utf8(&field.xml_name)?;
-                                writer
-                                    .write_event(Event::Start(BytesStart::new(child_tag)))
-                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
-                                writer
-                                    .write_event(Event::Text(BytesText::new(text)))
-                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
-                                writer
-                                    .write_event(Event::End(BytesEnd::new(child_tag)))
-                                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
-                            }
-                        }
-                        ValueType::List(inner) => {
-                            if let PolyValue::List(items) = val {
-                                for item in items {
-                                    match inner.as_ref() {
-                                        ValueType::Scalar(_) => {
-                                            let mut buf = [0u8; lexical_core::BUFFER_SIZE];
-                                            if let Some(text) =
-                                                Self::format_scalar_to(item, &mut buf)
-                                            {
-                                                let child_tag =
-                                                    std::str::from_utf8(&field.xml_name)?;
-                                                writer
-                                                    .write_event(Event::Start(BytesStart::new(
-                                                        child_tag,
-                                                    )))
-                                                    .map_err(|e| {
-                                                        PolyXmlError::SerializationError(
-                                                            e.to_string(),
-                                                        )
-                                                    })?;
-                                                writer
-                                                    .write_event(Event::Text(BytesText::new(text)))
-                                                    .map_err(|e| {
-                                                        PolyXmlError::SerializationError(
-                                                            e.to_string(),
-                                                        )
-                                                    })?;
-                                                writer
-                                                    .write_event(Event::End(BytesEnd::new(
-                                                        child_tag,
-                                                    )))
-                                                    .map_err(|e| {
-                                                        PolyXmlError::SerializationError(
-                                                            e.to_string(),
-                                                        )
-                                                    })?;
-                                            }
-                                        }
-                                        ValueType::Nested(nested_schema) => {
-                                            Self::write_model(
-                                                writer,
-                                                &field.xml_name,
-                                                item,
-                                                nested_schema,
-                                            )?;
-                                        }
-                                        ValueType::List(_) => {}
-                                    }
-                                }
-                            }
-                        }
-                        ValueType::Nested(nested_schema) => {
-                            Self::write_model(writer, &field.xml_name, val, nested_schema)?;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Close element
-        writer
-            .write_event(Event::End(BytesEnd::new(std::str::from_utf8(tag_name)?)))
-            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
-
-        Ok(())
-    }
-}