json2xml 6.3.0__tar.gz → 6.4.0__tar.gz

{json2xml-6.3.0 → json2xml-6.4.0}/CONTRIBUTING.rst

@@ -186,7 +186,7 @@ A reminder for the maintainers on how to deploy.
 Make sure all your changes are committed (including an entry in HISTORY.rst).
 Then run::
 
-$ bumpversion patch # possible: major / minor / patch
+Update the version in pyproject.toml and json2xml/__init__.py
 $ git push
 $ git push --tags
 

{json2xml-6.3.0 → json2xml-6.4.0}/HISTORY.rst

@@ -1,4 +1,12 @@
 
+6.4.0 / 2026-07-13
+==================
+
+  * perf: buffer Rust serializer writes in bounded 16 KiB chunks, reducing large-payload conversion time while keeping serializer memory near 80 MiB
+  * chore: release ``json2xml-rs`` 0.4.1 and require it from ``json2xml[fast]`` for accelerated installs
+  * docs: record before-and-after Rust buffering benchmarks and the unchanged XML output size
+
+
 6.3.0 / 2026-06-10
 ==================
 

{json2xml-6.3.0 → json2xml-6.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json2xml
-Version: 6.3.0
+Version: 6.4.0
 Summary: Simple Python Library to convert JSON to XML
 Author-email: Vinit Kumar <mail@vinitkumar.me>
 License: Apache Software License 2.0
@@ -32,7 +32,7 @@ Requires-Dist: setuptools; extra == "dev"
 Requires-Dist: pygments>=2.20.0; extra == "dev"
 Requires-Dist: xmltodict>=0.12.0; extra == "dev"
 Provides-Extra: fast
-Requires-Dist: json2xml-rs>=0.4.0; extra == "fast"
+Requires-Dist: json2xml-rs>=0.4.1; extra == "fast"
 Dynamic: license-file
 
 .. image:: ./json2xml-hero.png

{json2xml-6.3.0 → json2xml-6.4.0}/json2xml/__init__.py

@@ -2,4 +2,4 @@
 
 __author__ = """Vinit Kumar"""
 __email__ = "mail@vinitkumar.me"
-__version__ = "6.3.0"
+__version__ = "6.4.0"

json2xml-6.4.0/json2xml/backend_selector.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+
+@dataclass(frozen=True, slots=True)
+class ConversionRequest:
+    """Normalized conversion request shared across backend adapters."""
+
+    obj: Any
+    root: bool
+    custom_root: str
+    ids: list[int] | None
+    attr_type: bool
+    item_wrap: bool
+    item_func: Any
+    cdata: bool
+    xml_namespaces: dict[str, Any] | None
+    list_headers: bool
+    xpath_format: bool
+
+
+class BackendAdapter(Protocol):
+    """Small adapter seam for conversion backends."""
+
+    @property
+    def name(self) -> str:
+        raise NotImplementedError  # pragma: no cover
+
+    def can_handle(self, request: ConversionRequest) -> bool:
+        raise NotImplementedError  # pragma: no cover
+
+    def render(self, request: ConversionRequest) -> bytes:
+        raise NotImplementedError  # pragma: no cover
+
+
+class BackendSelector:
+    """Pick the first backend that can preserve request semantics."""
+
+    def __init__(self, *backends: BackendAdapter) -> None:
+        self._backends = backends
+
+    def render(self, request: ConversionRequest) -> bytes:
+        for backend in self._backends:
+            if backend.can_handle(request):
+                return backend.render(request)
+        raise RuntimeError("No XML backend can handle the requested conversion")
+
+
+def has_special_keys(obj: Any) -> bool:
+    """Return True when the payload uses Python-only special key semantics."""
+    if isinstance(obj, dict):
+        return any(
+            (isinstance(key, str) and (key.startswith("@") or key.endswith("@flat")))
+            or has_special_keys(value)
+            for key, value in obj.items()
+        )
+
+    if isinstance(obj, list):
+        return any(has_special_keys(item) for item in obj)
+
+    return False

{json2xml-6.3.0 → json2xml-6.4.0}/json2xml/cli.py

@@ -43,6 +43,7 @@ from __future__ import annotations
 
 import argparse
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 from typing import NoReturn
 
@@ -62,12 +63,142 @@ AUTHOR = "Vinit Kumar"
 EMAIL = "mail@vinitkumar.me"
 
 
+@dataclass(frozen=True, slots=True)
+class CLIConversionOptions:
+    """Parsed CLI options normalized for the conversion workflow."""
+
+    input_file: str | None
+    url: str | None
+    string: str | None
+    output: str | None
+    wrapper: str
+    root: bool
+    pretty: bool
+    attr_type: bool
+    item_wrap: bool
+    xpath_format: bool
+    cdata: bool
+    list_headers: bool
+
+    @classmethod
+    def from_namespace(cls, args: argparse.Namespace) -> "CLIConversionOptions":
+        return cls(
+            input_file=args.input_file,
+            url=args.url,
+            string=args.string,
+            output=args.output,
+            wrapper=args.wrapper,
+            root=args.root,
+            pretty=args.pretty,
+            attr_type=args.attr_type,
+            item_wrap=args.item_wrap,
+            xpath_format=args.xpath_format,
+            cdata=args.cdata,
+            list_headers=args.list_headers,
+        )
+
+
 def exit_with_error(message: str) -> NoReturn:
     """Print an error message and terminate CLI processing."""
     print(message, file=sys.stderr)
     raise SystemExit(1)
 
 
+class CLIApplication:
+    """Thin command adapter around input resolution, conversion, and output."""
+
+    def read_input(self, options: CLIConversionOptions) -> JSONValue:
+        if options.url:
+            try:
+                return readfromurl(options.url)
+            except URLReadError as error:
+                exit_with_error(f"Error reading from URL: {error}")
+
+        if options.string:
+            try:
+                return readfromstring(options.string)
+            except StringReadError as error:
+                exit_with_error(
+                    "Error: Invalid JSON in --string input. "
+                    "Pass a valid JSON object, array, string, number, boolean, or null. "
+                    f"({error})"
+                )
+
+        if options.input_file:
+            if options.input_file == "-":
+                return read_from_stdin()
+            if not Path(options.input_file).is_file():
+                exit_with_error(
+                    f"Error: JSON file not found: {options.input_file}. "
+                    "Check the path or use - to read JSON from stdin."
+                )
+            try:
+                return readfromjson(options.input_file)
+            except JSONReadError as error:
+                exit_with_error(
+                    f"Error: Could not parse JSON file: {options.input_file}. "
+                    f"Check that the file contains valid JSON. ({error})"
+                )
+
+        if not sys.stdin.isatty():
+            return read_from_stdin()
+
+        exit_with_error(
+            "Error: No input provided. Pass a JSON file, use - for stdin, "
+            "or provide --string/--url."
+        )
+        raise AssertionError("unreachable")
+
+    def read_from_stdin(self) -> JSONValue:
+        try:
+            json_str = sys.stdin.read().strip()
+            if not json_str:
+                exit_with_error(
+                    "Error: Empty stdin. Pipe JSON into stdin or pass a file/--string."
+                )
+            return readfromstring(json_str)
+        except StringReadError as error:
+            exit_with_error(
+                "Error: Invalid JSON from stdin. Pipe valid JSON into stdin "
+                f"or pass a file/--string. ({error})"
+            )
+
+    def convert(self, data: JSONValue, options: CLIConversionOptions) -> str | bytes:
+        converter = Json2xml(
+            data=data,
+            wrapper=options.wrapper,
+            root=options.root,
+            pretty=options.pretty,
+            attr_type=options.attr_type,
+            item_wrap=options.item_wrap,
+            xpath_format=options.xpath_format,
+            cdata=options.cdata,
+            list_headers=options.list_headers,
+        )
+        xml_output = converter.to_xml()
+        if xml_output is None:
+            raise ValueError("Empty data, no XML generated")
+        return xml_output
+
+    def write_output(self, output: str | bytes, output_file: str | None) -> None:
+        if isinstance(output, bytes):
+            output = output.decode("utf-8")
+
+        if output_file:
+            try:
+                with open(output_file, "w", encoding="utf-8") as file_obj:
+                    file_obj.write(output)
+            except OSError as error:
+                print(f"Error writing to file: {error}", file=sys.stderr)
+                sys.exit(1)
+            return
+
+        print(output)
+
+
+_APP = CLIApplication()
+
+
 # @lat: [[architecture#CLI entrypoint]]
 def create_parser() -> argparse.ArgumentParser:
     """Create and configure the argument parser."""
@@ -238,153 +369,39 @@ Examples:
 
 
 # @lat: [[behavior#Input readers]]
-def read_input(args: argparse.Namespace) -> JSONValue:
-    """
-    Read JSON input from the specified source.
-
-    Priority: URL > String > File > Stdin
-
-    Args:
-        args: Parsed command line arguments.
-
-    Returns:
-        Parsed JSON data as dict or list.
-
-    Raises:
-        SystemExit: When no input is provided or reading fails.
-    """
-    # Priority: URL > String > File > Stdin
-    if args.url:
-        try:
-            return readfromurl(args.url)
-        except URLReadError as e:
-            exit_with_error(f"Error reading from URL: {e}")
-
-    if args.string:
-        try:
-            return readfromstring(args.string)
-        except StringReadError as e:
-            exit_with_error(
-                "Error: Invalid JSON in --string input. "
-                f"Pass a valid JSON object, array, string, number, boolean, or null. ({e})"
-            )
-
-    if args.input_file:
-        if args.input_file == "-":
-            # Read from stdin
-            return read_from_stdin()
-        if not Path(args.input_file).is_file():
-            exit_with_error(
-                f"Error: JSON file not found: {args.input_file}. "
-                "Check the path or use - to read JSON from stdin."
-            )
-        try:
-            return readfromjson(args.input_file)
-        except JSONReadError as e:
-            exit_with_error(
-                f"Error: Could not parse JSON file: {args.input_file}. "
-                f"Check that the file contains valid JSON. ({e})"
-            )
-
-    # Check if there's data on stdin
-    if not sys.stdin.isatty():
-        return read_from_stdin()
-
-    exit_with_error(
-        "Error: No input provided. Pass a JSON file, use - for stdin, "
-        "or provide --string/--url."
-    )
+def read_input(args: argparse.Namespace | CLIConversionOptions) -> JSONValue:
+    """Read JSON input from the specified source."""
+    options = args if isinstance(args, CLIConversionOptions) else CLIConversionOptions.from_namespace(args)
+    return _APP.read_input(options)
 
 
 def read_from_stdin() -> JSONValue:
-    """
-    Read JSON from standard input.
-
-    Returns:
-        Parsed JSON data.
-
-    Raises:
-        SystemExit: When stdin is empty or contains invalid JSON.
-    """
-    try:
-        json_str = sys.stdin.read().strip()
-        if not json_str:
-            exit_with_error(
-                "Error: Empty stdin. Pipe JSON into stdin or pass a file/--string."
-            )
-        return readfromstring(json_str)
-    except StringReadError as e:
-        exit_with_error(
-            "Error: Invalid JSON from stdin. Pipe valid JSON into stdin "
-            f"or pass a file/--string. ({e})"
-        )
+    """Read JSON from standard input."""
+    return _APP.read_from_stdin()
 
 
 def write_output(output: str | bytes, output_file: str | None) -> None:
-    """
-    Write XML output to the specified destination.
-
-    Args:
-        output: XML content to write.
-        output_file: Path to output file, or None for stdout.
-    """
-    if isinstance(output, bytes):
-        output = output.decode("utf-8")
-
-    if output_file:
-        try:
-            with open(output_file, "w", encoding="utf-8") as f:
-                f.write(output)
-        except OSError as e:
-            print(f"Error writing to file: {e}", file=sys.stderr)
-            sys.exit(1)
-    else:
-        print(output)
+    """Write XML output to the specified destination."""
+    _APP.write_output(output, output_file)
 
 
 def main(argv: list[str] | None = None) -> int:
-    """
-    Main entry point for the CLI.
-
-    Args:
-        argv: Command line arguments (defaults to sys.argv[1:]).
-
-    Returns:
-        Exit code (0 for success, 1 for error).
-    """
+    """Main entry point for the CLI."""
     parser = create_parser()
     args = parser.parse_args(argv)
+    options = CLIConversionOptions.from_namespace(args)
 
-    # Read input data
     try:
-        data = read_input(args)
-    except Exception as e:
-        print(f"Error reading input: {e}", file=sys.stderr)
+        data = read_input(options)
+    except Exception as error:
+        print(f"Error reading input: {error}", file=sys.stderr)
         return 1
 
-    # Convert to XML
     try:
-        converter = Json2xml(
-            data=data,
-            wrapper=args.wrapper,
-            root=args.root,
-            pretty=args.pretty,
-            attr_type=args.attr_type,
-            item_wrap=args.item_wrap,
-            xpath_format=args.xpath_format,
-            cdata=args.cdata,
-            list_headers=args.list_headers,
-        )
-        xml_output = converter.to_xml()
-
-        if xml_output is None:
-            print("Error: Empty data, no XML generated", file=sys.stderr)
-            return 1
-
-        write_output(xml_output, args.output)
-
-    except Exception as e:
-        print(f"Error converting to XML: {e}", file=sys.stderr)
+        xml_output = _APP.convert(data, options)
+        write_output(xml_output, options.output)
+    except Exception as error:
+        print(f"Error converting to XML: {error}", file=sys.stderr)
         return 1
 
     return 0

{json2xml-6.3.0 → json2xml-6.4.0}/json2xml/dicttoxml.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import datetime
-import logging
 import numbers
 from collections.abc import Callable, Sequence
+from dataclasses import dataclass
 from decimal import Decimal
 from fractions import Fraction
 from functools import lru_cache
@@ -16,8 +16,6 @@ __lazy_modules__ = ["defusedxml.minidom"]
 # Create a safe random number generator
 _SAFE_RANDOM = SystemRandom()
 
-# Set up logging
-LOG = logging.getLogger("dicttoxml")
 _XML_ESCAPE_CHARS = frozenset("&\"'<>")
 
 
@@ -53,24 +51,15 @@ def make_id(element: str, start: int = 100000, end: int = 999999) -> str:
 
 def get_unique_id(element: str) -> str:
     """
-    Generate a unique ID for a given element.
+    Generate an ID for a given element.
 
     Args:
         element (str): The element to generate an ID for.
 
     Returns:
-        str: The unique ID.
+        str: The generated ID.
     """
-    ids: list[str] = []  # initialize list of unique ids
-    this_id = make_id(element)
-    dup = True
-    while dup:
-        if this_id not in ids:
-            dup = False
-            ids.append(this_id)
-        else:  # pragma: no cover
-            this_id = make_id(element)
-    return ids[-1]
+    return make_id(element)
 
 
 ELEMENT = Union[
@@ -951,6 +940,127 @@ def convert_none_valid_name(
     return f"<{key}{attr_string}></{key}>"
 
 
+@dataclass(frozen=True, slots=True)
+class SerializerConfig:
+    """Normalized options for the pure Python serializer engine."""
+
+    obj: ELEMENT
+    root: bool
+    custom_root: str
+    ids: list[int] | None
+    attr_type: bool
+    item_wrap: bool
+    item_func: Callable[[str], str]
+    cdata: bool
+    xml_namespaces: dict[str, Any] | None
+    list_headers: bool
+    xpath_format: bool
+
+
+class _XPathDocumentRenderer:
+    """Render the W3C XPath 3.1 JSON-to-XML document shape."""
+
+    def __init__(self, config: SerializerConfig) -> None:
+        self._config = config
+
+    def render(self) -> bytes:
+        output = _XMLWriter()
+        output.write('<?xml version="1.0" encoding="UTF-8" ?>')
+        tag_name = get_xpath31_tag_name(self._config.obj)
+        if tag_name in {"map", "array"}:
+            _append_xpath31(output, self._config.obj, namespace=True)
+        else:
+            output.write(f'<map xmlns="{XPATH_FUNCTIONS_NS}">')
+            _append_xpath31(output, self._config.obj)
+            output.write("</map>")
+        return output.to_bytes()
+
+
+class _NamespaceFormatter:
+    """Keep namespace emission and schema-attribute quirks in one place."""
+
+    @staticmethod
+    def format(xml_namespaces: dict[str, Any] | None) -> str:
+        if xml_namespaces is None:
+            return ""
+
+        namespace_parts: list[str] = []
+        for prefix in xml_namespaces:
+            if prefix == "xsi":
+                for schema_att in xml_namespaces[prefix]:
+                    if schema_att == "schemaInstance":
+                        namespace_parts.append(
+                            f' xmlns:{prefix}="{xml_namespaces[prefix]["schemaInstance"]}"'
+                        )
+                    elif schema_att == "schemaLocation":
+                        namespace_parts.append(
+                            f' xsi:{schema_att}="{xml_namespaces[prefix][schema_att]}"'
+                        )
+            elif prefix == "xmlns":
+                namespace_parts.append(f' xmlns="{xml_namespaces[prefix]}"')
+            else:
+                namespace_parts.append(f' xmlns:{prefix}="{xml_namespaces[prefix]}"')
+        return "".join(namespace_parts)
+
+
+class _StandardDocumentRenderer:
+    """Render the project-specific XML document shape."""
+
+    def __init__(self, config: SerializerConfig) -> None:
+        self._config = config
+
+    def render(self) -> bytes:
+        output = _XMLWriter()
+        if self._config.root:
+            self._render_with_root(output)
+        else:
+            self._render_fragment(output)
+        return output.to_bytes()
+
+    def _render_with_root(self, output: _XMLWriter) -> None:
+        custom_root, root_attr = make_valid_xml_name(self._config.custom_root, {})
+        namespace_str = _NamespaceFormatter.format(self._config.xml_namespaces)
+        output.write('<?xml version="1.0" encoding="UTF-8" ?>')
+        output.write(f"<{custom_root}{make_attrstring(root_attr)}{namespace_str}>")
+        _append_convert(
+            output,
+            self._config.obj,
+            self._config.ids,
+            self._config.attr_type,
+            self._config.item_func,
+            self._config.cdata,
+            self._config.item_wrap,
+            parent=custom_root,
+            list_headers=self._config.list_headers,
+        )
+        output.write(f"</{custom_root}>")
+
+    def _render_fragment(self, output: _XMLWriter) -> None:
+        _append_convert(
+            output,
+            self._config.obj,
+            self._config.ids,
+            self._config.attr_type,
+            self._config.item_func,
+            self._config.cdata,
+            self._config.item_wrap,
+            parent="",
+            list_headers=self._config.list_headers,
+        )
+
+
+class _SerializerEngine:
+    """Choose the document renderer while keeping helper semantics local."""
+
+    def __init__(self, config: SerializerConfig) -> None:
+        self._config = config
+
+    def render(self) -> bytes:
+        if self._config.xpath_format:
+            return _XPathDocumentRenderer(self._config).render()
+        return _StandardDocumentRenderer(self._config).render()
+
+
 # @lat: [[architecture#Conversion engine]]
 def dicttoxml(
     obj: ELEMENT,
@@ -1103,62 +1213,17 @@ def dicttoxml(
         <list a="b" c="d"><item>4</item><item>5</item><item>6</item></list>
 
     """
-    if xpath_format:
-        output = _XMLWriter()
-        output.write('<?xml version="1.0" encoding="UTF-8" ?>')
-        tag_name = get_xpath31_tag_name(obj)
-        if tag_name in {"map", "array"}:
-            _append_xpath31(output, obj, namespace=True)
-        else:
-            output.write(f'<map xmlns="{XPATH_FUNCTIONS_NS}">')
-            _append_xpath31(output, obj)
-            output.write("</map>")
-        return output.to_bytes()
-
-    namespace_parts: list[str] = []
-    if xml_namespaces is None:
-        xml_namespaces = {}
-    for prefix in xml_namespaces:
-        if prefix == 'xsi':
-            for schema_att in xml_namespaces[prefix]:
-                if schema_att == 'schemaInstance':
-                    ns = xml_namespaces[prefix]['schemaInstance']
-                    namespace_parts.append(f' xmlns:{prefix}="{ns}"')
-                elif schema_att == 'schemaLocation':
-                    ns = xml_namespaces[prefix][schema_att]
-                    namespace_parts.append(f' xsi:{schema_att}="{ns}"')
-
-        elif prefix == 'xmlns':
-            # xmns needs no prefix
-            ns = xml_namespaces[prefix]
-            namespace_parts.append(f' xmlns="{ns}"')
-
-        else:
-            ns = xml_namespaces[prefix]
-            namespace_parts.append(f' xmlns:{prefix}="{ns}"')
-    namespace_str = "".join(namespace_parts)
-    if root:
-        custom_root, root_attr = make_valid_xml_name(custom_root, {})
-        output = _XMLWriter()
-        output.write('<?xml version="1.0" encoding="UTF-8" ?>')
-        output.write(f"<{custom_root}{make_attrstring(root_attr)}{namespace_str}>")
-        _append_convert(
-            output,
-            obj,
-            ids,
-            attr_type,
-            item_func,
-            cdata,
-            item_wrap,
-            parent=custom_root,
-            list_headers=list_headers,
-        )
-        output.write(f"</{custom_root}>")
-        return output.to_bytes()
-
-    output = _XMLWriter()
-    _append_convert(
-        output,
-            obj, ids, attr_type, item_func, cdata, item_wrap, parent="", list_headers=list_headers
+    config = SerializerConfig(
+        obj=obj,
+        root=root,
+        custom_root=custom_root,
+        ids=ids,
+        attr_type=attr_type,
+        item_wrap=item_wrap,
+        item_func=item_func,
+        cdata=cdata,
+        xml_namespaces=xml_namespaces,
+        list_headers=list_headers,
+        xpath_format=xpath_format,
     )
-    return output.to_bytes()
+    return _SerializerEngine(config).render()

{json2xml-6.3.0 → json2xml-6.4.0}/json2xml/dicttoxml_fast.py

@@ -15,8 +15,11 @@ from __future__ import annotations
 
 import logging
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import Any
 
+from .backend_selector import BackendSelector, ConversionRequest, has_special_keys
+
 RustStringTransform = Callable[[str], str]
 
 LOG = logging.getLogger("dicttoxml_fast")
@@ -49,6 +52,71 @@ def get_backend() -> str:
     """Return the name of the current backend ('rust' or 'python')."""
     return "rust" if _use_rust else "python"
 
+@dataclass(frozen=True, slots=True)
+class _RustBackendAdapter:
+    """Adapter for the optional Rust backend."""
+
+    name: str = "rust"
+
+    def can_handle(self, request: ConversionRequest) -> bool:
+        if not _use_rust or _rust_dicttoxml is None:
+            return False
+
+        return not (
+            request.ids is not None
+            or request.item_func is not None
+            or request.xml_namespaces
+            or request.xpath_format
+            or not isinstance(request.obj, (dict, list))
+            or has_special_keys(request.obj)
+        )
+
+    def render(self, request: ConversionRequest) -> bytes:
+        assert _rust_dicttoxml is not None
+        return _rust_dicttoxml(
+            request.obj,
+            root=request.root,
+            custom_root=request.custom_root,
+            attr_type=request.attr_type,
+            item_wrap=request.item_wrap,
+            cdata=request.cdata,
+            list_headers=request.list_headers,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _PythonBackendAdapter:
+    """Adapter for the compatibility-preserving Python backend."""
+
+    python_dicttoxml: Callable[..., bytes]
+    default_item_func: Callable[[str], str]
+
+    name: str = "python"
+
+    def can_handle(self, request: ConversionRequest) -> bool:
+        return True
+
+    def render(self, request: ConversionRequest) -> bytes:
+        return self.python_dicttoxml(
+            request.obj,
+            root=request.root,
+            custom_root=request.custom_root,
+            ids=request.ids,
+            attr_type=request.attr_type,
+            item_wrap=request.item_wrap,
+            item_func=request.item_func or self.default_item_func,
+            cdata=request.cdata,
+            xml_namespaces=request.xml_namespaces,
+            list_headers=request.list_headers,
+            xpath_format=request.xpath_format,
+        )
+
+
+_BACKEND_SELECTOR = BackendSelector(
+    _RustBackendAdapter(),
+    _PythonBackendAdapter(_py_dicttoxml.dicttoxml, _py_dicttoxml.default_item_func),
+)
+
 
 # @lat: [[architecture#Backend selection]]
 def dicttoxml(
@@ -86,62 +154,20 @@ def dicttoxml(
     Returns:
         UTF-8 encoded XML as bytes
     """
-    # Features that require Python fallback
-    needs_python = (
-        ids is not None
-        or item_func is not None
-        or xml_namespaces
-        or xpath_format
-        or not isinstance(obj, (dict, list))
+    request = ConversionRequest(
+        obj=obj,
+        root=root,
+        custom_root=custom_root,
+        ids=ids,
+        attr_type=attr_type,
+        item_wrap=item_wrap,
+        item_func=item_func,
+        cdata=cdata,
+        xml_namespaces=xml_namespaces,
+        list_headers=list_headers,
+        xpath_format=xpath_format,
     )
-
-    # Check for special dict keys that require Python
-    if not needs_python and isinstance(obj, dict):
-        needs_python = _has_special_keys(obj)
-
-    if _use_rust and not needs_python and _rust_dicttoxml is not None:  # pragma: no cover
-        # Use fast Rust implementation
-        return _rust_dicttoxml(
-            obj,
-            root=root,
-            custom_root=custom_root,
-            attr_type=attr_type,
-            item_wrap=item_wrap,
-            cdata=cdata,
-            list_headers=list_headers,
-        )
-    else:
-        # Fall back to pure Python
-        return _py_dicttoxml.dicttoxml(
-            obj,
-            root=root,
-            custom_root=custom_root,
-            ids=ids,
-            attr_type=attr_type,
-            item_wrap=item_wrap,
-            item_func=item_func or _py_dicttoxml.default_item_func,
-            cdata=cdata,
-            xml_namespaces=xml_namespaces,
-            list_headers=list_headers,
-            xpath_format=xpath_format,
-        )
-
-
-def _has_special_keys(obj: Any) -> bool:
-    """Check if a dict contains special keys that require Python processing."""
-    if isinstance(obj, dict):
-        for key, val in obj.items():
-            if isinstance(key, str) and (
-                key.startswith("@") or key.endswith("@flat")
-            ):
-                return True
-            if _has_special_keys(val):
-                return True
-    elif isinstance(obj, list):
-        for item in obj:
-            if _has_special_keys(item):
-                return True
-    return False
+    return _BACKEND_SELECTOR.render(request)
 
 
 # Re-export commonly used functions

{json2xml-6.3.0 → json2xml-6.4.0}/json2xml.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json2xml
-Version: 6.3.0
+Version: 6.4.0
 Summary: Simple Python Library to convert JSON to XML
 Author-email: Vinit Kumar <mail@vinitkumar.me>
 License: Apache Software License 2.0
@@ -32,7 +32,7 @@ Requires-Dist: setuptools; extra == "dev"
 Requires-Dist: pygments>=2.20.0; extra == "dev"
 Requires-Dist: xmltodict>=0.12.0; extra == "dev"
 Provides-Extra: fast
-Requires-Dist: json2xml-rs>=0.4.0; extra == "fast"
+Requires-Dist: json2xml-rs>=0.4.1; extra == "fast"
 Dynamic: license-file
 
 .. image:: ./json2xml-hero.png

{json2xml-6.3.0 → json2xml-6.4.0}/json2xml.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ docs/readme.rst
 docs/rust_memory_benchmark.rst
 docs/usage.rst
 json2xml/__init__.py
+json2xml/backend_selector.py
 json2xml/cli.py
 json2xml/dicttoxml.py
 json2xml/dicttoxml_fast.py
@@ -37,6 +38,8 @@ json2xml.egg-info/requires.txt
 json2xml.egg-info/top_level.txt
 tests/__init__.py
 tests/conftest.py
+tests/test_backend_selector.py
+tests/test_benchmark_multi_python.py
 tests/test_cli.py
 tests/test_dict2xml.py
 tests/test_dicttoxml_fast_fallback.py

{json2xml-6.3.0 → json2xml-6.4.0}/json2xml.egg-info/requires.txt

@@ -10,4 +10,4 @@ pygments>=2.20.0
 xmltodict>=0.12.0
 
 [fast]
-json2xml-rs>=0.4.0
+json2xml-rs>=0.4.1

{json2xml-6.3.0 → json2xml-6.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "json2xml"
-version = "6.3.0"
+version = "6.4.0"
 description = "Simple Python Library to convert JSON to XML"
 readme = "README.rst"
 requires-python = ">=3.10"
@@ -50,7 +50,7 @@ dev = [
     "pygments>=2.20.0",
     "xmltodict>=0.12.0",
 ]
-fast = ["json2xml-rs>=0.4.0"]
+fast = ["json2xml-rs>=0.4.1"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

json2xml-6.4.0/setup.cfg

@@ -0,0 +1,11 @@
+[flake8]
+exclude = docs
+max-line-length = 120
+
+[coverage:run]
+relative_files = True
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

json2xml-6.4.0/tests/test_backend_selector.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import pytest
+
+from json2xml.backend_selector import BackendSelector, ConversionRequest, has_special_keys
+
+
+class _NeverBackend:
+    name = "never"
+
+    def can_handle(self, request: ConversionRequest) -> bool:
+        return False
+
+    def render(self, request: ConversionRequest) -> bytes:
+        raise AssertionError("render should not be called")
+
+
+# @lat: [[tests#Conversion behavior#Backend selector detects Python-only payload markers]]
+def test_has_special_keys_detects_nested_python_only_markers() -> None:
+    assert has_special_keys({"items": [{"record": {"@attrs": {"id": "7"}}}]}) is True
+    assert has_special_keys({"items": [{"record@flat": [1, 2, 3]}]}) is True
+    assert has_special_keys({"items": [{"record": {"name": "Ada"}}]}) is False
+
+
+# @lat: [[tests#Conversion behavior#Backend selector fails loudly with no compatible backend]]
+def test_backend_selector_raises_when_no_backend_can_handle_request() -> None:
+    request = ConversionRequest(
+        obj={"name": "Ada"},
+        root=True,
+        custom_root="root",
+        ids=None,
+        attr_type=True,
+        item_wrap=True,
+        item_func=None,
+        cdata=False,
+        xml_namespaces=None,
+        list_headers=False,
+        xpath_format=False,
+    )
+
+    selector = BackendSelector(_NeverBackend())
+
+    with pytest.raises(RuntimeError, match="No XML backend can handle"):
+        selector.render(request)

json2xml-6.4.0/tests/test_benchmark_multi_python.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+
+
+# @lat: [[tests#Performance benchmarks#Benchmark script derives interpreter paths from configurable uv base dir]]
+def test_benchmark_multi_python_uses_configurable_uv_base_dir(monkeypatch) -> None:
+    monkeypatch.setenv("JSON2XML_UV_PYTHON_DIR", "/tmp/uv-python")
+    monkeypatch.delenv("JSON2XML_PYTHON_CPYTHON_314_6", raising=False)
+    monkeypatch.delenv("JSON2XML_PYTHON_CPYTHON_315_0B3", raising=False)
+    monkeypatch.delenv("JSON2XML_PYTHON_PYPY_311_15", raising=False)
+
+    module = importlib.import_module("benchmark_multi_python")
+    module = importlib.reload(module)
+
+    assert module.UV_PYTHON_DIR.as_posix() == "/tmp/uv-python"
+    assert Path(module.PYTHON_VERSIONS[0]["python"]).as_posix() == "/tmp/uv-python/cpython-3.14.6-macos-aarch64-none/bin/python3.14"
+    assert Path(module.PYTHON_VERSIONS[1]["python"]).as_posix() == "/tmp/uv-python/cpython-3.15.0b3-macos-aarch64-none/bin/python3.15"
+    assert Path(module.PYTHON_VERSIONS[2]["python"]).as_posix() == "/tmp/uv-python/pypy-3.11.15-macos-aarch64-none/bin/pypy3.11"
+
+
+# @lat: [[tests#Performance benchmarks#Benchmark script lets explicit interpreter env vars override uv defaults]]
+def test_benchmark_multi_python_env_overrides_interpreter_paths(monkeypatch) -> None:
+    monkeypatch.setenv("JSON2XML_UV_PYTHON_DIR", "/tmp/uv-python")
+    monkeypatch.setenv("JSON2XML_PYTHON_CPYTHON_314_6", "/custom/python314")
+    monkeypatch.setenv("JSON2XML_PYTHON_CPYTHON_315_0B3", "/custom/python315")
+    monkeypatch.setenv("JSON2XML_PYTHON_PYPY_311_15", "/custom/pypy311")
+
+    module = importlib.import_module("benchmark_multi_python")
+    module = importlib.reload(module)
+
+    assert Path(module.PYTHON_VERSIONS[0]["python"]).as_posix() == "/custom/python314"
+    assert Path(module.PYTHON_VERSIONS[1]["python"]).as_posix() == "/custom/python315"
+    assert Path(module.PYTHON_VERSIONS[2]["python"]).as_posix() == "/custom/pypy311"

{json2xml-6.3.0 → json2xml-6.4.0}/tests/test_cli.py

@@ -11,7 +11,15 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from json2xml.cli import create_parser, main, read_from_stdin, read_input, write_output
+from json2xml.cli import (
+    CLIApplication,
+    CLIConversionOptions,
+    create_parser,
+    main,
+    read_from_stdin,
+    read_input,
+    write_output,
+)
 
 if TYPE_CHECKING:
     from pytest import CaptureFixture
@@ -601,6 +609,32 @@ class TestCLIUnitTests:
         captured = capsys.readouterr()
         assert "No input provided" in captured.err
 
+    # @lat: [[tests#CLI failure messages#No-input guard stays total if exit helper is bypassed]]
+    def test_read_input_no_input_guard_raises_assertion_if_exit_helper_returns(self) -> None:
+        """Test the no-input branch keeps a hard failure if the exit helper is bypassed."""
+        app = CLIApplication()
+        options = CLIConversionOptions(
+            input_file=None,
+            url=None,
+            string=None,
+            output=None,
+            wrapper="all",
+            root=True,
+            pretty=True,
+            attr_type=True,
+            item_wrap=True,
+            xpath_format=False,
+            cdata=False,
+            list_headers=True,
+        )
+
+        with (
+            patch("sys.stdin.isatty", return_value=True),
+            patch("json2xml.cli.exit_with_error", return_value=None),
+        ):
+            with pytest.raises(AssertionError, match="unreachable"):
+                app.read_input(options)
+
     def test_read_input_stdin_when_not_tty(self) -> None:
         """Test read_input reads from stdin when not a tty."""
         with (

{json2xml-6.3.0 → json2xml-6.4.0}/tests/test_dict2xml.py

@@ -1,18 +1,12 @@
 import copy
 import datetime
-import numbers
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import pytest
 from _pytest.monkeypatch import MonkeyPatch
 
 from json2xml import dicttoxml
 
-if TYPE_CHECKING:
-    from _pytest.capture import CaptureFixture
-    from _pytest.fixtures import FixtureRequest
-    from _pytest.logging import LogCaptureFixture
-
 
 class TestDict2xml:
     """Test class for dicttoxml functionality."""

{json2xml-6.3.0 → json2xml-6.4.0}/tests/test_json2xml.py

@@ -2,7 +2,6 @@
 
 """Tests for `json2xml` package."""
 
-import json
 from pyexpat import ExpatError
 from typing import Any
 

{json2xml-6.3.0 → json2xml-6.4.0}/tests/test_missing_coverage.py

@@ -3,65 +3,15 @@
 from __future__ import annotations
 
 import numbers
-from typing import TYPE_CHECKING
-from unittest.mock import MagicMock, patch
-
-import pytest
+from unittest.mock import patch
 
 from json2xml.dicttoxml import (
     convert_to_xpath31,
     dicttoxml,
-    get_unique_id,
     get_xml_type,
     get_xpath31_tag_name,
-    make_id,
 )
 
-if TYPE_CHECKING:
-    pass
-
-
-class TestGetUniqueIdDuplicateGeneration:
-    """Test line 52: duplicate ID generation in get_unique_id loop"""
-
-    def test_get_unique_id_generates_id_when_duplicates_occur(self) -> None:
-        """Test that get_unique_id handles the while loop by regenerating IDs on duplicates.
-
-        Line 52 (this_id = make_id(element)) is executed when a duplicate is found.
-        Since make_id uses SystemRandom, we can't guarantee duplicates, but we can
-        ensure the function returns a valid ID in the correct format.
-        """
-        result = get_unique_id("test_element")
-
-        # Verify it returns a string in the expected format
-        assert isinstance(result, str)
-        assert result.startswith("test_element_")
-        assert len(result) > len("test_element_")
-
-        # Verify the numeric part is valid
-        numeric_part = result.replace("test_element_", "")
-        assert numeric_part.isdigit()
-        assert 100000 <= int(numeric_part) <= 999999
-
-    def test_get_unique_id_duplicate_id_regeneration(self) -> None:
-        """Test line 52: trigger duplicate ID regeneration.
-
-        Line 52 (this_id = make_id(element)) only executes if this_id is in the ids list.
-        We can't easily trigger this with the current implementation since ids starts empty,
-        but we test the function's robustness when make_id returns duplicates.
-        """
-        # Call get_unique_id multiple times - while theoretically one could duplicate
-        # due to SystemRandom, the function handles this correctly
-        ids_generated = [get_unique_id("test") for _ in range(10)]
-
-        # All generated IDs should be properly formatted
-        for id_val in ids_generated:
-            assert isinstance(id_val, str)
-            assert id_val.startswith("test_")
-            numeric_part = id_val.split("_")[-1]
-            assert numeric_part.isdigit()
-            assert 100000 <= int(numeric_part) <= 999999
-
 
 class TestGetXmlTypeWithNumbers:
     """Test line 90: get_xml_type handling of numbers.Number instances"""

{json2xml-6.3.0 → json2xml-6.4.0}/tests/test_utils.py

@@ -22,11 +22,6 @@ from json2xml.utils import (
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    from _pytest.capture import CaptureFixture
-    from _pytest.fixtures import FixtureRequest
-    from _pytest.logging import LogCaptureFixture
-    from _pytest.monkeypatch import MonkeyPatch
-
 
 class JsonTestHandler(BaseHTTPRequestHandler):
     """Tiny HTTP handler for exercising the real URL reader."""

json2xml-6.3.0/setup.cfg

@@ -1,31 +0,0 @@
-[bumpversion]
-current_version = 6.1.0
-commit = True
-tag = True
-
-[bumpversion:file:setup.py]
-search = version='{current_version}'
-replace = version='{new_version}'
-
-[bumpversion:file:json2xml/__init__.py]
-search = __version__ = '{current_version}'
-replace = __version__ = '{new_version}'
-
-[bdist_wheel]
-universal = false
-
-[flake8]
-exclude = docs
-max-line-length = 120
-
-[aliases]
-
-[tool.ty]
-
-[coverage:run]
-relative_files = True
-
-[egg_info]
-tag_build = 
-tag_date = 0
-