xmltodict-rs 0.13.0__cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl

xmltodict_rs/__init__.py

@@ -0,0 +1,9 @@
+"""xmltodict_rs - High-performance XML to dict conversion library using Rust and PyO3.
+
+This module provides parse() and unparse() functions for converting between
+XML and Python dictionaries with better performance than pure Python implementations.
+"""
+
+from .xmltodict_rs import parse, unparse
+
+__all__ = ["parse", "unparse"]

xmltodict_rs/__init__.pyi

@@ -0,0 +1,140 @@
+"""Type stubs for xmltodict_rs - High-performance XML to dict conversion library.
+
+This module provides a Rust-based implementation of xmltodict functionality
+with full type annotations for better IDE support and type checking.
+"""
+
+from collections.abc import Collection
+from typing import Any, Callable
+
+XMLInput = str | bytes
+XMLDict = dict[str, Any]
+PostprocessorFunc = Callable[[list[str], str, Any], tuple[str, Any] | None]
+PreprocessorFunc = Callable[[str, Any], tuple[str, Any] | None]
+
+def parse(
+    xml_input: XMLInput,
+    encoding: str | None = None,
+    process_namespaces: bool = False,
+    namespace_separator: str = ":",
+    disable_entities: bool = True,
+    process_comments: bool = False,
+    xml_attribs: bool = True,
+    attr_prefix: str = "@",
+    cdata_key: str = "#text",
+    force_cdata: bool = False,
+    cdata_separator: str = "",
+    strip_whitespace: bool = True,
+    force_list: bool | Collection[str] | Callable[[list[str], str, Any], bool] | None = None,
+    postprocessor: PostprocessorFunc | None = None,
+    item_depth: int = 0,
+    comment_key: str = "#comment",
+    namespaces: dict[str, str] | None = None,
+) -> XMLDict:
+    """Parse XML string or bytes into a Python dictionary.
+
+    Args:
+        xml_input: XML data as string or bytes to parse
+        encoding: Character encoding (for compatibility, not used in Rust implementation)
+        process_namespaces: If True, namespace prefixes are processed and expanded
+        namespace_separator: Separator character between namespace and tag name (default ':')
+        disable_entities: If True, XML entities are disabled for security (default True)
+        process_comments: If True, XML comments are included in output with comment_key
+        xml_attribs: If True, XML attributes are included in output (default True)
+        attr_prefix: Prefix for attribute keys in output dict (default '@')
+        cdata_key: Key name for text content in output dict (default '#text')
+        force_cdata: If True, text content is always wrapped in dict with cdata_key
+        cdata_separator: Separator for multiple text nodes (default '')
+        strip_whitespace: If True, whitespace-only text is removed (default True)
+        force_list: Control when to create lists for repeated elements:
+            - None/False: automatic list creation for repeated elements
+            - True: always create lists
+            - set/list: create lists for specified tag names
+            - Callable: custom function (path, key, value) -> bool
+        postprocessor: Optional callback to transform parsed data:
+            - Called with (path, key, value)
+            - Should return (new_key, new_value) tuple or None to skip
+        item_depth: Internal parameter for tracking parsing depth
+        comment_key: Key name for XML comments in output (default '#comment')
+        namespaces: Optional dict mapping namespace URIs to prefixes
+
+    Returns:
+        Dictionary representation of the XML structure
+
+    Raises:
+        ValueError: If XML is malformed or has parsing errors
+        TypeError: If xml_input is not str or bytes
+
+    Examples:
+        >>> parse('<root><item>value</item></root>')
+        {'root': {'item': 'value'}}
+
+        >>> parse('<root id="1"><item>A</item><item>B</item></root>')
+        {'root': {'@id': '1', 'item': ['A', 'B']}}
+
+        >>> parse('<root>text</root>', force_cdata=True)
+        {'root': {'#text': 'text'}}
+
+        >>> def postproc(path, key, value):
+        ...     return (key.upper(), value)
+        >>> parse('<root><item>value</item></root>', postprocessor=postproc)
+        {'ROOT': {'ITEM': 'value'}}
+    """
+    ...
+
+def unparse(
+    input_dict: XMLDict,
+    output: str | None = None,
+    encoding: str = "utf-8",
+    full_document: bool = True,
+    short_empty_elements: bool = False,
+    attr_prefix: str = "@",
+    cdata_key: str = "#text",
+    pretty: bool = False,
+    newl: str = "\n",
+    indent: str = "\t",
+    preprocessor: PreprocessorFunc | None = None,
+) -> str:
+    r"""Convert Python dictionary back to XML string.
+
+    Args:
+        input_dict: Dictionary to convert to XML (must have exactly one root key if full_document=True)
+        output: Optional file-like object to write to (for compatibility, returns string anyway)
+        encoding: Character encoding for XML declaration (default 'utf-8')
+        full_document: If True, includes XML declaration (default True)
+        short_empty_elements: If True, empty elements use <tag/> format (default False)
+        attr_prefix: Prefix used to identify attribute keys (default '@')
+        cdata_key: Key name that contains text content (default '#text')
+        pretty: If True, output is formatted with indentation (default False)
+        newl: Newline character for pretty printing (default '\n')
+        indent: Indentation string for pretty printing (default '\t')
+        preprocessor: Optional callback to transform data before unparsing:
+            - Called with (key, value)
+            - Should return (new_key, new_value) tuple or None to skip
+
+    Returns:
+        XML string representation of the dictionary
+
+    Raises:
+        ValueError: If full_document=True and dict doesn't have exactly one root element
+        TypeError: If input_dict is not a dictionary
+
+    Examples:
+        >>> unparse({'root': {'item': 'value'}})
+        '<?xml version="1.0" encoding="utf-8"?>\\n<root><item>value</item></root>'
+
+        >>> unparse({'root': {'@id': '1', 'item': 'value'}})
+        '<?xml version="1.0" encoding="utf-8"?>\\n<root id="1"><item>value</item></root>'
+
+        >>> unparse({'root': None}, short_empty_elements=True)
+        '<?xml version="1.0" encoding="utf-8"?>\\n<root/>'
+
+        >>> unparse({'root': {'item': ['A', 'B']}})
+        '<?xml version="1.0" encoding="utf-8"?>\\n<root><item>A</item><item>B</item></root>'
+
+        >>> unparse({'root': {'child': 'value'}}, pretty=True)
+        '<?xml version="1.0" encoding="utf-8"?>\\n<root>\\n\\t<child>value</child>\\n</root>'
+    """
+    ...
+
+__all__ = ["parse", "unparse"]

xmltodict_rs-0.13.0.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: xmltodict-rs
+Version: 0.13.0
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE
+Summary: High-performance XML to dict conversion library using Rust and PyO3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/tochka-public/xmltodict_rs
+Project-URL: Repository, https://github.com/tochka-public/xmltodict_rs
+Project-URL: Issues, https://github.com/tochka-public/xmltodict_rs/issues
+
+# xmltodict_rs
+
+High-performance XML to dict conversion library using Rust and PyO3
+
+A Rust-based implementation of `xmltodict` that provides significant performance improvements while maintaining API compatibility.
+
+## Features
+
+-  **High Performance** - 5-10x faster than pure Python implementation
+-  **Full Compatibility** - Drop-in replacement for `xmltodict`
+-  **Type Safe** - Includes comprehensive type stubs (`.pyi` files) for better IDE support
+-  **Safe** - Built with Rust for memory safety and security
+-  **Easy to Use** - Simple installation and familiar API
+
+## Versioning
+
+The major and minor version numbers of `xmltodict_rs` match those of the original `xmltodict` library. This ensures that the behavior is consistent with the corresponding version of `xmltodict`, making it a true drop-in replacement. Patch versions may differ for Rust-specific fixes and optimizations.
+
+For example:
+- `xmltodict_rs 0.13.x` matches the behavior of `xmltodict 0.13.x`
+- `xmltodict_rs 0.14.x` matches the behavior of `xmltodict 0.14.x`
+
+## Installation
+
+```bash
+pip install xmltodict-rs
+```
+
+Or with uv:
+
+```bash
+uv add xmltodict-rs
+```
+
+## Quick Start
+
+```python
+import xmltodict_rs
+
+# Parse XML to dictionary
+xml = '<root><item id="1">value</item></root>'
+result = xmltodict_rs.parse(xml)
+print(result)
+# {'root': {'item': {'@id': '1', '#text': 'value'}}}
+
+# Convert dictionary back to XML
+data = {'root': {'item': 'value'}}
+xml = xmltodict_rs.unparse(data)
+print(xml)
+# <?xml version="1.0" encoding="utf-8"?>
+# <root><item>value</item></root>
+```
+
+## Type Hints Support
+
+Full type annotations are included for better IDE support and static type checking:
+
+```python
+from typing import Any
+import xmltodict_rs
+
+# IDE will provide autocomplete and type checking
+result: dict[str, Any] = xmltodict_rs.parse("<root><item>test</item></root>")
+
+# Type checkers like mypy will catch errors
+xmltodict_rs.parse(123)  # Error: Expected str or bytes
+```
+
+
+## API Reference
+
+### parse()
+
+Convert XML to a Python dictionary.
+
+```python
+xmltodict_rs.parse(
+    xml_input,                    # str or bytes: XML data to parse
+    process_namespaces=False,     # bool: Process namespace prefixes
+    namespace_separator=":",      # str: Separator for namespace and tag
+    disable_entities=True,        # bool: Disable XML entities for security
+    process_comments=False,       # bool: Include XML comments in output
+    xml_attribs=True,            # bool: Include attributes in output
+    attr_prefix="@",             # str: Prefix for attribute keys
+    cdata_key="#text",           # str: Key name for text content
+    force_cdata=False,           # bool: Always wrap text in dict
+    cdata_separator="",          # str: Separator for multiple text nodes
+    strip_whitespace=True,       # bool: Remove whitespace-only text
+    force_list=None,             # Control list creation
+    postprocessor=None,          # Callback for transforming data
+    item_depth=0,                # Internal depth tracking
+    comment_key="#comment",      # str: Key name for comments
+    namespaces=None              # dict: Namespace URI mapping
+)
+```
+
+### unparse()
+
+Convert a Python dictionary back to XML.
+
+```python
+xmltodict_rs.unparse(
+    input_dict,                   # dict: Dictionary to convert
+    encoding="utf-8",            # str: Character encoding
+    full_document=True,          # bool: Include XML declaration
+    short_empty_elements=False,  # bool: Use <tag/> for empty elements
+    attr_prefix="@",             # str: Prefix identifying attributes
+    cdata_key="#text",           # str: Key containing text content
+    pretty=False,                # bool: Format with indentation
+    newl="\n",                   # str: Newline character
+    indent="\t",                 # str: Indentation string
+    preprocessor=None            # Callback for transforming data
+)
+```
+
+## Performance
+
+Based on benchmarks with various XML sizes:
+
+| Operation | Small (0.3KB) | Medium (15KB) | Large (150KB) |
+|-----------|---------------|---------------|---------------|
+| Parse     | ~8x faster    | ~6x faster    | ~5x faster    |
+| Unparse   | ~10x faster   | ~8x faster    | ~7x faster    |
+
+
+## Development
+
+### Setup
+
+```bash
+# Install dependencies
+uv venv
+uv sync
+
+# Build the Rust extension
+just dev
+
+# Run tests
+just test
+
+# Run benchmarks
+uv run python benches/accurate_benchmark.py
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Links
+
+- [Original xmltodict](https://github.com/martinblech/xmltodict)
+

xmltodict_rs-0.13.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+xmltodict_rs-0.13.0.dist-info/METADATA,sha256=T0ohHLCcA1oY0oB1LkorJDK6f6EGjdRCtig1qsBV5Tk,5785
+xmltodict_rs-0.13.0.dist-info/WHEEL,sha256=r3Re1LyxSX0vTMvaekQJYIADPZ3YvOvqupg0m4KOsyk,149
+xmltodict_rs-0.13.0.dist-info/licenses/LICENSE,sha256=TejyJYC8dHf16Vx7Okwl2PQhaPEutztvHPh0TKJ1xrA,1075
+xmltodict_rs/__init__.py,sha256=HOypcbSGzLktZ4OZzYE1L9SvJr1Z-W80qBzxkhzhMYo,328
+xmltodict_rs/__init__.pyi,sha256=kZcbEjWwep26f2Isi_g_XLqg_lm1ntkj99NRw0OLQgU,6052
+xmltodict_rs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xmltodict_rs/xmltodict_rs.cpython-312-powerpc64le-linux-gnu.so,sha256=moUKGPQvPfgrdkTPyJHBMWcj6vRRl7sXCa0ww7_Fhbs,529320
+xmltodict_rs-0.13.0.dist-info/RECORD,,

xmltodict_rs-0.13.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_17_ppc64le
+Tag: cp312-cp312-manylinux2014_ppc64le

xmltodict_rs-0.13.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Точка Банк
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.