json2xml-rs 0.1.0__tar.gz

json2xml_rs-0.1.0/Cargo.lock

@@ -0,0 +1,172 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "json2xml_rs"
+version = "0.1.0"
+dependencies = [
+ "pyo3",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.180"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "syn"
+version = "2.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1dd07eb858a2067e2f3c7155d54e929265c264e6f37efe3ee7a8d1b5a1dd0ba"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

json2xml_rs-0.1.0/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "json2xml_rs"
+version = "0.1.0"
+edition = "2021"
+description = "Fast native JSON to XML conversion for Python"
+license = "Apache-2.0"
+readme = "README.md"
+
+[lib]
+name = "json2xml_rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.27", features = ["extension-module"] }
+
+[profile.release]
+lto = true
+codegen-units = 1
+opt-level = 3

json2xml_rs-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: json2xml_rs
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Summary: Fast native JSON to XML conversion - Rust extension for json2xml
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# json2xml_rs - Rust Extension for json2xml
+
+A high-performance Rust implementation of the dicttoxml module using PyO3.
+
+## Building
+
+### Prerequisites
+
+- Rust (1.70+)
+- Python (3.9+)
+- maturin (`pip install maturin`)
+
+### Development Build
+
+```bash
+cd rust
+maturin develop --release
+```
+
+This builds the extension and installs it in your current Python environment.
+
+### Production Build
+
+```bash
+cd rust
+maturin build --release
+```
+
+The wheel will be in `target/wheels/`.
+
+## Usage
+
+```python
+# Direct usage
+from json2xml_rs import dicttoxml
+
+data = {"name": "John", "age": 30, "active": True}
+xml_bytes = dicttoxml(data)
+print(xml_bytes.decode())
+
+# Or use the hybrid module that auto-selects the fastest backend
+from json2xml import dicttoxml_fast
+xml_bytes = dicttoxml_fast.dicttoxml(data)
+```
+
+## API
+
+### `dicttoxml(obj, root=True, custom_root="root", attr_type=True, item_wrap=True, cdata=False, list_headers=False) -> bytes`
+
+Convert a Python dict or list to XML.
+
+**Parameters:**
+- `obj`: The Python object to convert (dict or list)
+- `root`: Include XML declaration and root element (default: True)
+- `custom_root`: Name of the root element (default: "root")
+- `attr_type`: Include type attributes on elements (default: True)
+- `item_wrap`: Wrap list items in `<item>` tags (default: True)
+- `cdata`: Wrap string values in CDATA sections (default: False)
+- `list_headers`: Repeat parent tag for each list item (default: False)
+
+**Returns:** UTF-8 encoded XML as bytes
+
+### `escape_xml_py(s: str) -> str`
+
+Escape special XML characters (&, ", ', <, >) in a string.
+
+### `wrap_cdata_py(s: str) -> str`
+
+Wrap a string in a CDATA section.
+
+## Performance
+
+The Rust implementation is expected to be 5-15x faster than pure Python for:
+
+- String escaping (single-pass vs. multiple `.replace()` calls)
+- Type dispatch (compiled match statements vs. `isinstance()` chains)
+- String building (pre-allocated buffers vs. f-string concatenation)
+
+## Limitations
+
+The Rust implementation currently does not support:
+
+- `ids` parameter (unique IDs for elements)
+- `item_func` parameter (custom item naming function)
+- `xml_namespaces` parameter
+- `xpath_format` parameter
+- `@attrs`, `@val`, `@flat` special dict keys
+
+For these features, fall back to the pure Python implementation.
+
+## Development
+
+### Running Tests
+
+```bash
+cd rust
+maturin develop
+python -m pytest ../tests/
+```
+
+### Benchmarking
+
+```bash
+cd ..
+python benchmark_rust.py
+```
+

json2xml_rs-0.1.0/README.md

@@ -0,0 +1,106 @@
+# json2xml_rs - Rust Extension for json2xml
+
+A high-performance Rust implementation of the dicttoxml module using PyO3.
+
+## Building
+
+### Prerequisites
+
+- Rust (1.70+)
+- Python (3.9+)
+- maturin (`pip install maturin`)
+
+### Development Build
+
+```bash
+cd rust
+maturin develop --release
+```
+
+This builds the extension and installs it in your current Python environment.
+
+### Production Build
+
+```bash
+cd rust
+maturin build --release
+```
+
+The wheel will be in `target/wheels/`.
+
+## Usage
+
+```python
+# Direct usage
+from json2xml_rs import dicttoxml
+
+data = {"name": "John", "age": 30, "active": True}
+xml_bytes = dicttoxml(data)
+print(xml_bytes.decode())
+
+# Or use the hybrid module that auto-selects the fastest backend
+from json2xml import dicttoxml_fast
+xml_bytes = dicttoxml_fast.dicttoxml(data)
+```
+
+## API
+
+### `dicttoxml(obj, root=True, custom_root="root", attr_type=True, item_wrap=True, cdata=False, list_headers=False) -> bytes`
+
+Convert a Python dict or list to XML.
+
+**Parameters:**
+- `obj`: The Python object to convert (dict or list)
+- `root`: Include XML declaration and root element (default: True)
+- `custom_root`: Name of the root element (default: "root")
+- `attr_type`: Include type attributes on elements (default: True)
+- `item_wrap`: Wrap list items in `<item>` tags (default: True)
+- `cdata`: Wrap string values in CDATA sections (default: False)
+- `list_headers`: Repeat parent tag for each list item (default: False)
+
+**Returns:** UTF-8 encoded XML as bytes
+
+### `escape_xml_py(s: str) -> str`
+
+Escape special XML characters (&, ", ', <, >) in a string.
+
+### `wrap_cdata_py(s: str) -> str`
+
+Wrap a string in a CDATA section.
+
+## Performance
+
+The Rust implementation is expected to be 5-15x faster than pure Python for:
+
+- String escaping (single-pass vs. multiple `.replace()` calls)
+- Type dispatch (compiled match statements vs. `isinstance()` chains)
+- String building (pre-allocated buffers vs. f-string concatenation)
+
+## Limitations
+
+The Rust implementation currently does not support:
+
+- `ids` parameter (unique IDs for elements)
+- `item_func` parameter (custom item naming function)
+- `xml_namespaces` parameter
+- `xpath_format` parameter
+- `@attrs`, `@val`, `@flat` special dict keys
+
+For these features, fall back to the pure Python implementation.
+
+## Development
+
+### Running Tests
+
+```bash
+cd rust
+maturin develop
+python -m pytest ../tests/
+```
+
+### Benchmarking
+
+```bash
+cd ..
+python benchmark_rust.py
+```

json2xml_rs-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["maturin>=1.4,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "json2xml_rs"
+version = "0.1.0"
+description = "Fast native JSON to XML conversion - Rust extension for json2xml"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "Apache-2.0"}
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
+module-name = "json2xml_rs"

json2xml_rs-0.1.0/src/lib.rs

@@ -0,0 +1,668 @@
+//! Fast native JSON to XML conversion for Python
+//!
+//! This module provides a high-performance Rust implementation of dicttoxml
+//! that can be used as a drop-in replacement for the pure Python version.
+
+use pyo3::prelude::*;
+use pyo3::types::{PyBool, PyDict, PyFloat, PyInt, PyList, PyString};
+use std::fmt::Write;
+
+/// Escape special XML characters in a string.
+/// This is one of the hottest paths - optimized for single-pass processing.
+#[inline]
+fn escape_xml(s: &str) -> String {
+    let mut result = String::with_capacity(s.len() + s.len() / 10);
+    for c in s.chars() {
+        match c {
+            '&' => result.push_str("&"),
+            '"' => result.push_str("""),
+            '\'' => result.push_str("'"),
+            '<' => result.push_str("&lt;"),
+            '>' => result.push_str("&gt;"),
+            _ => result.push(c),
+        }
+    }
+    result
+}
+
+/// Wrap content in CDATA section
+#[inline]
+fn wrap_cdata(s: &str) -> String {
+    let escaped = s.replace("]]>", "]]]]><![CDATA[>");
+    format!("<![CDATA[{}]]>", escaped)
+}
+
+/// Check if a key is a valid XML element name (simplified check)
+/// Full validation would require XML parsing, but this catches common issues
+fn is_valid_xml_name(key: &str) -> bool {
+    if key.is_empty() {
+        return false;
+    }
+
+    let mut chars = key.chars();
+
+    // First character must be letter or underscore
+    match chars.next() {
+        Some(c) if c.is_alphabetic() || c == '_' => {}
+        _ => return false,
+    }
+
+    // Remaining characters can be letters, digits, hyphens, underscores, or periods
+    for c in chars {
+        if !(c.is_alphanumeric() || c == '-' || c == '_' || c == '.' || c == ':') {
+            return false;
+        }
+    }
+
+    // Names starting with "xml" (case-insensitive) are reserved
+    !key.to_lowercase().starts_with("xml")
+}
+
+/// Make a valid XML name from a key, returning the key and any attributes
+fn make_valid_xml_name(key: &str) -> (String, Option<(String, String)>) {
+    let escaped = escape_xml(key);
+
+    // Already valid
+    if is_valid_xml_name(&escaped) {
+        return (escaped, None);
+    }
+
+    // Numeric key - prepend 'n'
+    if escaped.chars().all(|c| c.is_ascii_digit()) {
+        return (format!("n{}", escaped), None);
+    }
+
+    // Try replacing spaces with underscores
+    let with_underscores = escaped.replace(' ', "_");
+    if is_valid_xml_name(&with_underscores) {
+        return (with_underscores, None);
+    }
+
+    // Fall back to using "key" with name attribute
+    ("key".to_string(), Some(("name".to_string(), escaped)))
+}
+
+/// Build an attribute string from key-value pairs
+fn make_attr_string(attrs: &[(String, String)]) -> String {
+    if attrs.is_empty() {
+        return String::new();
+    }
+    let mut result = String::new();
+    for (k, v) in attrs {
+        write!(result, " {}=\"{}\"", k, escape_xml(v)).unwrap();
+    }
+    result
+}
+
+/// Configuration for XML conversion
+struct ConvertConfig {
+    attr_type: bool,
+    cdata: bool,
+    item_wrap: bool,
+    list_headers: bool,
+}
+
+/// Convert a Python value to XML string
+fn convert_value(
+    py: Python<'_>,
+    obj: &Bound<'_, PyAny>,
+    parent: &str,
+    config: &ConvertConfig,
+    item_name: &str,
+) -> PyResult<String> {
+    // Handle None
+    if obj.is_none() {
+        return convert_none(item_name, config);
+    }
+
+    // Handle bool (must check before int since bool is subclass of int in Python)
+    if obj.is_instance_of::<PyBool>() {
+        let val: bool = obj.extract()?;
+        return convert_bool(item_name, val, config);
+    }
+
+    // Handle int - try i64 first, fall back to string for large integers
+    if obj.is_instance_of::<PyInt>() {
+        let val_str = match obj.extract::<i64>() {
+            Ok(val) => val.to_string(),
+            Err(_) => obj.str()?.extract::<String>()?, // Fall back for big ints
+        };
+        return convert_number(item_name, &val_str, "int", config);
+    }
+
+    // Handle float
+    if obj.is_instance_of::<PyFloat>() {
+        let val: f64 = obj.extract()?;
+        return convert_number(item_name, &val.to_string(), "float", config);
+    }
+
+    // Handle string
+    if obj.is_instance_of::<PyString>() {
+        let val: String = obj.extract()?;
+        return convert_string(item_name, &val, config);
+    }
+
+    // Handle dict
+    if obj.is_instance_of::<PyDict>() {
+        let dict: &Bound<'_, PyDict> = obj.cast()?;
+        return convert_dict(py, dict, parent, config);
+    }
+
+    // Handle list
+    if obj.is_instance_of::<PyList>() {
+        let list: &Bound<'_, PyList> = obj.cast()?;
+        return convert_list(py, list, parent, config);
+    }
+
+    // Handle other sequences (tuples, etc.) - check if iterable via try_iter
+    if let Ok(iter) = obj.try_iter() {
+        let items: Vec<Bound<'_, PyAny>> = iter.filter_map(|r| r.ok()).collect();
+        let list = PyList::new(py, &items)?;
+        return convert_list(py, &list, parent, config);
+    }
+
+    // Fallback: convert to string
+    let val: String = obj.str()?.extract()?;
+    convert_string(item_name, &val, config)
+}
+
+/// Convert a string value to XML
+fn convert_string(key: &str, val: &str, config: &ConvertConfig) -> PyResult<String> {
+    let (xml_key, name_attr) = make_valid_xml_name(key);
+    let mut attrs = Vec::new();
+
+    if let Some((k, v)) = name_attr {
+        attrs.push((k, v));
+    }
+    if config.attr_type {
+        attrs.push(("type".to_string(), "str".to_string()));
+    }
+
+    let attr_string = make_attr_string(&attrs);
+    let content = if config.cdata {
+        wrap_cdata(val)
+    } else {
+        escape_xml(val)
+    };
+
+    Ok(format!(
+        "<{}{}>{}</{}>",
+        xml_key, attr_string, content, xml_key
+    ))
+}
+
+/// Convert a number value to XML
+fn convert_number(
+    key: &str,
+    val: &str,
+    type_name: &str,
+    config: &ConvertConfig,
+) -> PyResult<String> {
+    let (xml_key, name_attr) = make_valid_xml_name(key);
+    let mut attrs = Vec::new();
+
+    if let Some((k, v)) = name_attr {
+        attrs.push((k, v));
+    }
+    if config.attr_type {
+        attrs.push(("type".to_string(), type_name.to_string()));
+    }
+
+    let attr_string = make_attr_string(&attrs);
+    Ok(format!("<{}{}>{}</{}>", xml_key, attr_string, val, xml_key))
+}
+
+/// Convert a boolean value to XML
+fn convert_bool(key: &str, val: bool, config: &ConvertConfig) -> PyResult<String> {
+    let (xml_key, name_attr) = make_valid_xml_name(key);
+    let mut attrs = Vec::new();
+
+    if let Some((k, v)) = name_attr {
+        attrs.push((k, v));
+    }
+    if config.attr_type {
+        attrs.push(("type".to_string(), "bool".to_string()));
+    }
+
+    let attr_string = make_attr_string(&attrs);
+    let bool_str = if val { "true" } else { "false" };
+    Ok(format!(
+        "<{}{}>{}</{}>",
+        xml_key, attr_string, bool_str, xml_key
+    ))
+}
+
+/// Convert a None value to XML
+fn convert_none(key: &str, config: &ConvertConfig) -> PyResult<String> {
+    let (xml_key, name_attr) = make_valid_xml_name(key);
+    let mut attrs = Vec::new();
+
+    if let Some((k, v)) = name_attr {
+        attrs.push((k, v));
+    }
+    if config.attr_type {
+        attrs.push(("type".to_string(), "null".to_string()));
+    }
+
+    let attr_string = make_attr_string(&attrs);
+    Ok(format!("<{}{}></{}>", xml_key, attr_string, xml_key))
+}
+
+/// Convert a dictionary to XML
+fn convert_dict(
+    py: Python<'_>,
+    dict: &Bound<'_, PyDict>,
+    _parent: &str,
+    config: &ConvertConfig,
+) -> PyResult<String> {
+    let mut output = String::new();
+
+    for (key, val) in dict.iter() {
+        let key_str: String = key.str()?.extract()?;
+        let (xml_key, name_attr) = make_valid_xml_name(&key_str);
+
+        // Handle bool (must check before int)
+        if val.is_instance_of::<PyBool>() {
+            let bool_val: bool = val.extract()?;
+            let mut attrs = Vec::new();
+            if let Some((k, v)) = name_attr {
+                attrs.push((k, v));
+            }
+            if config.attr_type {
+                attrs.push(("type".to_string(), "bool".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            let bool_str = if bool_val { "true" } else { "false" };
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                xml_key, attr_string, bool_str, xml_key
+            )
+            .unwrap();
+        }
+        // Handle int - try i64 first, fall back to string for large integers
+        else if val.is_instance_of::<PyInt>() {
+            let int_str = match val.extract::<i64>() {
+                Ok(v) => v.to_string(),
+                Err(_) => val.str()?.extract::<String>()?,
+            };
+            let mut attrs = Vec::new();
+            if let Some((k, v)) = name_attr {
+                attrs.push((k, v));
+            }
+            if config.attr_type {
+                attrs.push(("type".to_string(), "int".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                xml_key, attr_string, int_str, xml_key
+            )
+            .unwrap();
+        }
+        // Handle float
+        else if val.is_instance_of::<PyFloat>() {
+            let float_val: f64 = val.extract()?;
+            let mut attrs = Vec::new();
+            if let Some((k, v)) = name_attr {
+                attrs.push((k, v));
+            }
+            if config.attr_type {
+                attrs.push(("type".to_string(), "float".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                xml_key, attr_string, float_val, xml_key
+            )
+            .unwrap();
+        }
+        // Handle string
+        else if val.is_instance_of::<PyString>() {
+            let str_val: String = val.extract()?;
+            let mut attrs = Vec::new();
+            if let Some((k, v)) = name_attr {
+                attrs.push((k, v));
+            }
+            if config.attr_type {
+                attrs.push(("type".to_string(), "str".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            let content = if config.cdata {
+                wrap_cdata(&str_val)
+            } else {
+                escape_xml(&str_val)
+            };
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                xml_key, attr_string, content, xml_key
+            )
+            .unwrap();
+        }
+        // Handle None
+        else if val.is_none() {
+            let mut attrs = Vec::new();
+            if let Some((k, v)) = name_attr {
+                attrs.push((k, v));
+            }
+            if config.attr_type {
+                attrs.push(("type".to_string(), "null".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            write!(output, "<{}{}></{}>", xml_key, attr_string, xml_key).unwrap();
+        }
+        // Handle nested dict
+        else if val.is_instance_of::<PyDict>() {
+            let nested_dict: &Bound<'_, PyDict> = val.cast()?;
+            let mut attrs = Vec::new();
+            if let Some((k, v)) = name_attr {
+                attrs.push((k, v));
+            }
+            if config.attr_type {
+                attrs.push(("type".to_string(), "dict".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            let inner = convert_dict(py, nested_dict, &xml_key, config)?;
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                xml_key, attr_string, inner, xml_key
+            )
+            .unwrap();
+        }
+        // Handle list
+        else if val.is_instance_of::<PyList>() {
+            let list: &Bound<'_, PyList> = val.cast()?;
+            let list_output = convert_list(py, list, &xml_key, config)?;
+
+            if config.item_wrap {
+                let mut attrs = Vec::new();
+                if let Some((k, v)) = name_attr {
+                    attrs.push((k, v));
+                }
+                if config.attr_type {
+                    attrs.push(("type".to_string(), "list".to_string()));
+                }
+                let attr_string = make_attr_string(&attrs);
+                write!(
+                    output,
+                    "<{}{}>{}</{}>",
+                    xml_key, attr_string, list_output, xml_key
+                )
+                .unwrap();
+            } else {
+                output.push_str(&list_output);
+            }
+        }
+        // Fallback: convert to string
+        else {
+            let str_val: String = val.str()?.extract()?;
+            let mut attrs = Vec::new();
+            if let Some((k, v)) = name_attr {
+                attrs.push((k, v));
+            }
+            if config.attr_type {
+                attrs.push(("type".to_string(), "str".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            let content = if config.cdata {
+                wrap_cdata(&str_val)
+            } else {
+                escape_xml(&str_val)
+            };
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                xml_key, attr_string, content, xml_key
+            )
+            .unwrap();
+        }
+    }
+
+    Ok(output)
+}
+
+/// Convert a list to XML
+fn convert_list(
+    py: Python<'_>,
+    list: &Bound<'_, PyList>,
+    parent: &str,
+    config: &ConvertConfig,
+) -> PyResult<String> {
+    let mut output = String::new();
+    let item_name = "item";
+
+    for item in list.iter() {
+        let tag_name = if config.item_wrap || config.list_headers {
+            if config.list_headers {
+                parent
+            } else {
+                item_name
+            }
+        } else {
+            parent
+        };
+
+        // Handle bool (must check before int)
+        if item.is_instance_of::<PyBool>() {
+            let bool_val: bool = item.extract()?;
+            let mut attrs = Vec::new();
+            if config.attr_type {
+                attrs.push(("type".to_string(), "bool".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            let bool_str = if bool_val { "true" } else { "false" };
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                tag_name, attr_string, bool_str, tag_name
+            )
+            .unwrap();
+        }
+        // Handle int - try i64 first, fall back to string for large integers
+        else if item.is_instance_of::<PyInt>() {
+            let int_str = match item.extract::<i64>() {
+                Ok(v) => v.to_string(),
+                Err(_) => item.str()?.extract::<String>()?,
+            };
+            let mut attrs = Vec::new();
+            if config.attr_type {
+                attrs.push(("type".to_string(), "int".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                tag_name, attr_string, int_str, tag_name
+            )
+            .unwrap();
+        }
+        // Handle float
+        else if item.is_instance_of::<PyFloat>() {
+            let float_val: f64 = item.extract()?;
+            let mut attrs = Vec::new();
+            if config.attr_type {
+                attrs.push(("type".to_string(), "float".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                tag_name, attr_string, float_val, tag_name
+            )
+            .unwrap();
+        }
+        // Handle string
+        else if item.is_instance_of::<PyString>() {
+            let str_val: String = item.extract()?;
+            let mut attrs = Vec::new();
+            if config.attr_type {
+                attrs.push(("type".to_string(), "str".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            let content = if config.cdata {
+                wrap_cdata(&str_val)
+            } else {
+                escape_xml(&str_val)
+            };
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                tag_name, attr_string, content, tag_name
+            )
+            .unwrap();
+        }
+        // Handle None
+        else if item.is_none() {
+            let mut attrs = Vec::new();
+            if config.attr_type {
+                attrs.push(("type".to_string(), "null".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            write!(output, "<{}{}></{}>", tag_name, attr_string, tag_name).unwrap();
+        }
+        // Handle nested dict
+        else if item.is_instance_of::<PyDict>() {
+            let nested_dict: &Bound<'_, PyDict> = item.cast()?;
+            let inner = convert_dict(py, nested_dict, tag_name, config)?;
+
+            if config.item_wrap || config.list_headers {
+                let mut attrs = Vec::new();
+                if config.attr_type {
+                    attrs.push(("type".to_string(), "dict".to_string()));
+                }
+                let attr_string = make_attr_string(&attrs);
+                write!(
+                    output,
+                    "<{}{}>{}</{}>",
+                    tag_name, attr_string, inner, tag_name
+                )
+                .unwrap();
+            } else {
+                output.push_str(&inner);
+            }
+        }
+        // Handle nested list
+        else if item.is_instance_of::<PyList>() {
+            let nested_list: &Bound<'_, PyList> = item.cast()?;
+            let inner = convert_list(py, nested_list, tag_name, config)?;
+
+            let mut attrs = Vec::new();
+            if config.attr_type {
+                attrs.push(("type".to_string(), "list".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                tag_name, attr_string, inner, tag_name
+            )
+            .unwrap();
+        }
+        // Fallback
+        else {
+            let str_val: String = item.str()?.extract()?;
+            let mut attrs = Vec::new();
+            if config.attr_type {
+                attrs.push(("type".to_string(), "str".to_string()));
+            }
+            let attr_string = make_attr_string(&attrs);
+            let content = if config.cdata {
+                wrap_cdata(&str_val)
+            } else {
+                escape_xml(&str_val)
+            };
+            write!(
+                output,
+                "<{}{}>{}</{}>",
+                tag_name, attr_string, content, tag_name
+            )
+            .unwrap();
+        }
+    }
+
+    Ok(output)
+}
+
+/// Convert a Python dict/list to XML bytes.
+///
+/// This is a high-performance Rust implementation of dicttoxml.
+///
+/// Args:
+///     obj: The Python object to convert (dict or list)
+///     root: Whether to include XML declaration and root element (default: True)
+///     custom_root: The name of the root element (default: "root")
+///     attr_type: Whether to include type attributes (default: True)
+///     item_wrap: Whether to wrap list items in <item> tags (default: True)
+///     cdata: Whether to wrap string values in CDATA sections (default: False)
+///     list_headers: Whether to repeat parent tag for each list item (default: False)
+///
+/// Returns:
+///     bytes: The XML representation of the input object
+#[pyfunction]
+#[pyo3(signature = (obj, root=true, custom_root="root", attr_type=true, item_wrap=true, cdata=false, list_headers=false))]
+#[allow(clippy::too_many_arguments)]
+fn dicttoxml(
+    py: Python<'_>,
+    obj: &Bound<'_, PyAny>,
+    root: bool,
+    custom_root: &str,
+    attr_type: bool,
+    item_wrap: bool,
+    cdata: bool,
+    list_headers: bool,
+) -> PyResult<Vec<u8>> {
+    let config = ConvertConfig {
+        attr_type,
+        cdata,
+        item_wrap,
+        list_headers,
+    };
+
+    let content = if obj.is_instance_of::<PyDict>() {
+        let dict: &Bound<'_, PyDict> = obj.cast()?;
+        convert_dict(py, dict, custom_root, &config)?
+    } else if obj.is_instance_of::<PyList>() {
+        let list: &Bound<'_, PyList> = obj.cast()?;
+        convert_list(py, list, custom_root, &config)?
+    } else {
+        convert_value(py, obj, custom_root, &config, custom_root)?
+    };
+
+    let output = if root {
+        format!(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" ?><{}>{}</{}>",
+            custom_root, content, custom_root
+        )
+    } else {
+        content
+    };
+
+    Ok(output.into_bytes())
+}
+
+/// Fast XML string escaping.
+///
+/// Escapes &, ", ', <, > characters for XML.
+#[pyfunction]
+fn escape_xml_py(s: &str) -> String {
+    escape_xml(s)
+}
+
+/// Wrap a string in CDATA section.
+#[pyfunction]
+fn wrap_cdata_py(s: &str) -> String {
+    wrap_cdata(s)
+}
+
+/// A Python module implemented in Rust.
+#[pymodule]
+fn json2xml_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(dicttoxml, m)?)?;
+    m.add_function(wrap_pyfunction!(escape_xml_py, m)?)?;
+    m.add_function(wrap_pyfunction!(wrap_cdata_py, m)?)?;
+    Ok(())
+}

json2xml_rs-0.1.0/uv.lock

@@ -0,0 +1,7 @@
+version = 1
+requires-python = ">=3.9"
+
+[[package]]
+name = "json2xml-rs"
+version = "0.1.0"
+source = { editable = "." }