json2xml 7.0.0__tar.gz → 7.1.0__tar.gz

{json2xml-7.0.0 → json2xml-7.1.0}/HISTORY.rst

@@ -1,4 +1,25 @@
 
+7.1.0 / 2026-09-03
+==================
+
+  * perf: enforce conversion depth and item limits inside the native payload walk, cutting a 2,000-record accelerated conversion from 7.1 ms to 1.4 ms
+  * fix: keep tuples on the Python serializer; the native backend rendered nested tuples differently under ``item_wrap=False`` and ``list_headers=True``
+  * fix: write identical CLI output to stdout and ``--output`` files, as UTF-8 bytes ending in exactly one newline
+  * fix: accept numbers and other scalars in ``dicttoxml_fast.escape_xml`` and ``wrap_cdata`` on both backends
+  * fix: raise ``InvalidDataError`` from ``Json2xml.to_xml`` for values the serializer rejects, such as a Mapping that is not a dict
+  * fix: classify ``datetime.time`` in the direct ``convert_kv`` helpers the same way the serializer does
+  * fix: report unreadable files distinctly from invalid JSON in ``readfromjson``
+  * refactor: load the optional Rust backend through one function that keeps working with ``json2xml-rs`` 0.5.0, and log under ``json2xml.dicttoxml_fast``
+  * refactor: share ``SerializerConfig`` between the serializer and the backend selector, add ``dicttoxml.serialize()``, and remove ``ConversionRequest`` and ``has_special_keys``
+  * refactor: declare CLI toggles with ``BooleanOptionalAction`` and derive type attributes from one exact-type table
+  * chore: release ``json2xml-rs`` 0.6.0 first and require it from ``json2xml[fast]``
+
+7.0.1 / 2026-08-28
+==================
+
+  * fix: validate explicitly provided empty ``--string``, ``--url``, and file-path inputs instead of silently falling back to stdin
+
+
 7.0.0 / 2026-08-23
 ==================
 

{json2xml-7.0.0 → json2xml-7.1.0}/PKG-INFO

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

{json2xml-7.0.0 → json2xml-7.1.0}/json2xml/__init__.py

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

{json2xml-7.0.0 → json2xml-7.1.0}/json2xml/backend_selector.py

@@ -1,30 +1,10 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import Any, Protocol
 
 # Shared with the Python serializer deliberately: the root-name gate below is only
 # correct while it uses the exact predicate Python's name resolver starts from.
-from .dicttoxml import _is_fast_valid_xml_name
-
-
-@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
-    max_output_bytes: int | None = None
-    indent: str | None = None
+from .dicttoxml import SerializerConfig, _is_fast_valid_xml_name
 
 
 class BackendAdapter(Protocol):
@@ -34,10 +14,10 @@ class BackendAdapter(Protocol):
     def name(self) -> str:
         raise NotImplementedError  # pragma: no cover
 
-    def can_handle(self, request: ConversionRequest) -> bool:
+    def can_handle(self, request: SerializerConfig) -> bool:
         raise NotImplementedError  # pragma: no cover
 
-    def render(self, request: ConversionRequest) -> bytes:
+    def render(self, request: SerializerConfig) -> bytes:
         raise NotImplementedError  # pragma: no cover
 
 
@@ -47,7 +27,7 @@ class BackendSelector:
     def __init__(self, *backends: BackendAdapter) -> None:
         self._backends = backends
 
-    def render(self, request: ConversionRequest) -> bytes:
+    def render(self, request: SerializerConfig) -> bytes:
         for backend in self._backends:
             if backend.can_handle(request):
                 return backend.render(request)
@@ -56,9 +36,9 @@ class BackendSelector:
 
 # Types the Rust backend renders byte-identically to the Python serializer. Subclasses are
 # excluded on purpose: Python classifies them through its isinstance fallbacks, which the
-# native writer does not reproduce.
+# native writer does not reproduce. Tuples are excluded because Python applies its
+# list-shape rules to them while the native writer only recognizes lists.
 _RUST_SCALAR_TYPES = frozenset({str, bool, int, float, type(None)})
-_RUST_CONTAINER_TYPES = frozenset({dict, list, tuple})
 
 
 def _rust_renders_key_identically(key: Any) -> bool:
@@ -105,23 +85,8 @@ def rust_renders_identically(obj: Any) -> bool:
                     return False
                 stack.append(child)
             continue
-        if value_type in _RUST_CONTAINER_TYPES:
+        if value_type is list:
             stack.extend(value)
             continue
         return False
     return True
-
-
-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-7.0.0 → json2xml-7.1.0}/json2xml/cli.py

@@ -7,10 +7,11 @@ Usage:
 
 Flags:
     -w, --wrapper string    Wrapper element name (default "all")
-    -r, --root              Include root element (default true)
-    -p, --pretty            Pretty print output (default false)
-    -t, --type              Include type attributes (default true)
-    -i, --item-wrap         Wrap list items in <item> elements (default true)
+    -r, --root              Include root element (default true, --no-root disables)
+    -p, --pretty            Pretty print output (default false, --no-pretty disables)
+    -t, --type              Include type attributes (default true, --no-type disables)
+    -i, --item-wrap         Wrap list items in <item> elements (default true,
+                            --no-item-wrap disables)
     -x, --xpath             Use XPath 3.1 json-to-xml format
     -o, --output string     Output file (default: stdout)
     -u, --url string        Read JSON from URL
@@ -109,13 +110,14 @@ class CLIApplication:
     """Thin command adapter around input resolution, conversion, and output."""
 
     def read_input(self, options: CLIConversionOptions) -> JSONValue:
-        if options.url:
+        # None means omitted; explicit empty values still require source validation.
+        if options.url is not None:
             try:
                 return readfromurl(options.url)
             except URLReadError as error:
                 exit_with_error(f"Error reading from URL: {error}")
 
-        if options.string:
+        if options.string is not None:
             try:
                 return readfromstring(options.string)
             except StringReadError as error:
@@ -125,9 +127,14 @@ class CLIApplication:
                     f"({error})"
                 )
 
-        if options.input_file:
+        if options.input_file is not None:
             if options.input_file == "-":
                 return read_from_stdin()
+            if not options.input_file:
+                exit_with_error(
+                    "Error: Empty JSON file path. "
+                    "Pass a JSON file, use - for stdin, or provide --string/--url."
+                )
             if not Path(options.input_file).is_file():
                 exit_with_error(
                     f"Error: JSON file not found: {options.input_file}. "
@@ -180,19 +187,32 @@ class CLIApplication:
         return xml_output
 
     def write_output(self, output: str | bytes, output_file: str | None) -> None:
-        if isinstance(output, bytes):
-            output = output.decode("utf-8")
+        text = output.decode("utf-8") if isinstance(output, bytes) else output
+        # Both destinations get the same text: the document plus exactly one final
+        # newline, whether the serializer emitted none, one, or several.
+        text = text.rstrip("\n") + "\n"
 
-        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)
+        if not output_file:
+            self._write_stdout(text)
+            return
+
+        try:
+            Path(output_file).write_text(text, encoding="utf-8")
+        except OSError as error:
+            exit_with_error(f"Error writing to file: {error}")
+
+    @staticmethod
+    def _write_stdout(text: str) -> None:
+        """Write UTF-8 bytes so stdout matches the file output byte for byte."""
+        buffer = getattr(sys.stdout, "buffer", None)
+        if buffer is None:
+            # A text-only replacement such as io.StringIO has no byte layer.
+            sys.stdout.write(text)
             return
 
-        print(output)
+        sys.stdout.flush()
+        buffer.write(text.encode("utf-8"))
+        buffer.flush()
 
 
 _APP = CLIApplication()
@@ -275,61 +295,38 @@ Examples:
         default="all",
         help='Wrapper element name (default: "all")',
     )
+    # Each toggle also accepts its --no-* form; the last occurrence wins.
     conv_group.add_argument(
         "-r",
         "--root",
         dest="root",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
         default=True,
-        help="Include root element (default: true)",
-    )
-    conv_group.add_argument(
-        "--no-root",
-        dest="root",
-        action="store_false",
-        help="Exclude root element",
+        help="Include root element",
     )
     conv_group.add_argument(
         "-p",
         "--pretty",
         dest="pretty",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
         default=False,
-        help="Pretty print output (default: false)",
-    )
-    conv_group.add_argument(
-        "--no-pretty",
-        dest="pretty",
-        action="store_false",
-        help="Disable pretty printing",
+        help="Pretty print output",
     )
     conv_group.add_argument(
         "-t",
         "--type",
         dest="attr_type",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
         default=True,
-        help="Include type attributes (default: true)",
-    )
-    conv_group.add_argument(
-        "--no-type",
-        dest="attr_type",
-        action="store_false",
-        help="Exclude type attributes",
+        help="Include type attributes",
     )
     conv_group.add_argument(
         "-i",
         "--item-wrap",
         dest="item_wrap",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
         default=True,
-        help="Wrap list items in <item> elements (default: true)",
-    )
-    conv_group.add_argument(
-        "--no-item-wrap",
-        dest="item_wrap",
-        action="store_false",
-        help="Don't wrap list items",
+        help="Wrap list items in <item> elements",
     )
     conv_group.add_argument(
         "-x",

{json2xml-7.0.0 → json2xml-7.1.0}/json2xml/dicttoxml.py

@@ -9,7 +9,7 @@ from fractions import Fraction
 from functools import lru_cache
 from io import BytesIO
 from random import SystemRandom
-from typing import Any, Union, cast
+from typing import Any, TypeAlias, Union, cast
 
 __lazy_modules__ = ["defusedxml.minidom"]
 
@@ -141,6 +141,10 @@ def get_unique_id(element: str) -> str:
     return make_id(element)
 
 
+# Only the truthiness of ``ids`` is ever consulted, so any value is a valid argument:
+# the historical list form, a bool, or an int all enable generated id attributes.
+IdsOption: TypeAlias = object
+
 ELEMENT = Union[
     str,
     int,
@@ -214,6 +218,19 @@ def _classify(value: Any) -> int:
     return _KIND_UNSUPPORTED
 
 
+# Type attribute values for native JSON types, keyed by exact type like _EXACT_KINDS.
+_EXACT_TYPE_NAMES: dict[type, str] = {
+    type(None): "null",
+    str: "str",
+    int: "int",
+    float: "float",
+    bool: "bool",
+    dict: "dict",
+    list: "list",
+    tuple: "list",
+}
+
+
 def get_xml_type(val: Any) -> str:
     """
     Get the XML type of a given value.
@@ -224,21 +241,10 @@ def get_xml_type(val: Any) -> str:
     Returns:
         str: The XML type.
     """
-    if val is None:
-        return "null"
-    val_type = type(val)
-    if val_type is str:
-        return "str"
-    if val_type is int:
-        return "int"
-    if val_type is float:
-        return "float"
-    if val_type is bool:
-        return "bool"
-    if val_type is dict:
-        return "dict"
-    if val_type is list or val_type is tuple:
-        return "list"
+    name = _EXACT_TYPE_NAMES.get(type(val))
+    if name is not None:
+        return name
+    # Subclasses and other Number implementations take the historical fallback names.
     if isinstance(val, str):
         return "str"
     if _is_number(val):
@@ -514,7 +520,7 @@ def _append_xpath31(
 
 def convert(
     obj: Any,
-    ids: Any,
+    ids: IdsOption,
     attr_type: bool,
     item_func: Callable[[str], str],
     cdata: bool,
@@ -616,7 +622,7 @@ def list2xml_str(
 
 def convert_dict(
     obj: dict[str, Any],
-    ids: list[str],
+    ids: IdsOption,
     parent: str,
     attr_type: bool,
     item_func: Callable[[str], str],
@@ -647,7 +653,7 @@ def convert_dict(
 
 def convert_list(
     items: Sequence[Any],
-    ids: list[str] | None,
+    ids: IdsOption,
     parent: str,
     attr_type: bool,
     item_func: Callable[[str], str],
@@ -679,7 +685,7 @@ def convert_list(
 def _append_convert(
     output: _XMLWriter,
     obj: Any,
-    ids: Any,
+    ids: IdsOption,
     attr_type: bool,
     item_func: Callable[[str], str],
     cdata: bool,
@@ -755,7 +761,7 @@ def _append_dict2xml_str(
     list_headers: bool = False,
 ) -> None:
     """Append a dict element using the same shape as dict2xml_str."""
-    ids: list[str] = []
+    ids: IdsOption = None
     attr = dict(attr)
 
     if attr_type:
@@ -821,7 +827,7 @@ def _append_dict2xml_str(
 def _append_rawitem(
     output: _XMLWriter,
     rawitem: Any,
-    ids: list[str],
+    ids: IdsOption,
     attr_type: bool,
     item_func: Callable[[str], str],
     cdata: bool,
@@ -863,7 +869,7 @@ def _append_list2xml_str(
     item_wrap: bool,
     list_headers: bool = False,
 ) -> None:
-    ids: list[str] = []
+    ids: IdsOption = None
     attr = dict(attr)
     if attr_type:
         attr["type"] = get_xml_type(item)
@@ -908,7 +914,7 @@ def _append_list2xml_str(
 def _append_convert_dict(
     output: _XMLWriter,
     obj: dict[str, Any],
-    ids: list[str],
+    ids: IdsOption,
     parent: str,
     attr_type: bool,
     item_func: Callable[[str], str],
@@ -977,7 +983,7 @@ def _append_convert_dict(
 def _append_convert_list(
     output: _XMLWriter,
     items: Sequence[Any],
-    ids: list[str] | None,
+    ids: IdsOption,
     parent: str,
     attr_type: bool,
     item_func: Callable[[str], str],
@@ -1067,9 +1073,18 @@ def _append_convert_list(
             raise TypeError(f"Unsupported data type: {item} ({type(item).__name__})")
 
 
+_DATE_LIKE_TYPES = (datetime.datetime, datetime.date, datetime.time)
+
+
 def convert_kv(
     key: str,
-    val: str | int | float | numbers.Number | datetime.datetime | datetime.date,
+    val: str
+    | int
+    | float
+    | numbers.Number
+    | datetime.datetime
+    | datetime.date
+    | datetime.time,
     attr_type: bool,
     attr: dict[str, Any] | None = None,
     cdata: bool = False,
@@ -1078,10 +1093,8 @@ def convert_kv(
     attr = dict(attr) if attr else {}
     key, attr = make_valid_xml_name(key, attr)
 
-    # Convert datetime to isoformat string
-    if hasattr(val, "isoformat") and isinstance(
-        val, (datetime.datetime, datetime.date)
-    ):
+    # Date-like values serialize as ISO text, matching the main serializer path.
+    if isinstance(val, _DATE_LIKE_TYPES):
         val = val.isoformat()
 
     if attr_type:
@@ -1094,15 +1107,19 @@ def convert_kv(
 
 def convert_kv_valid_name(
     key: str,
-    val: str | int | float | numbers.Number | datetime.datetime | datetime.date,
+    val: str
+    | int
+    | float
+    | numbers.Number
+    | datetime.datetime
+    | datetime.date
+    | datetime.time,
     attr_type: bool,
     attr: dict[str, Any],
     cdata: bool = False,
 ) -> str:
     """Converts a scalar into an XML element when the caller already validated the key."""
-    if hasattr(val, "isoformat") and isinstance(
-        val, (datetime.datetime, datetime.date)
-    ):
+    if isinstance(val, _DATE_LIKE_TYPES):
         val = val.isoformat()
 
     attr_string = (
@@ -1168,12 +1185,12 @@ def convert_none_valid_name(key: str, attr_type: bool, attr: dict[str, Any]) ->
 
 @dataclass(frozen=True, slots=True)
 class SerializerConfig:
-    """Normalized options for the pure Python serializer engine."""
+    """Normalized conversion options shared by the backend selector and this engine."""
 
-    obj: ELEMENT
+    obj: Any
     root: bool
     custom_root: str
-    ids: list[int] | None
+    ids: IdsOption
     attr_type: bool
     item_wrap: bool
     item_func: Callable[[str], str]
@@ -1312,7 +1329,7 @@ def dicttoxml(
     obj: ELEMENT,
     root: bool = True,
     custom_root: str = "root",
-    ids: list[int] | None = None,
+    ids: IdsOption = None,
     attr_type: bool = True,
     item_wrap: bool = True,
     item_func: Callable[[str], str] = default_item_func,
@@ -1337,9 +1354,9 @@ def dicttoxml(
         Default is 'root'
         allows you to specify a custom root element.
 
-    :param bool ids:
-        Default is False
-        specifies whether elements get unique ids.
+    :param ids:
+        Default is None
+        any truthy value gives elements unique ids.
 
     :param bool attr_type:
         Default is True
@@ -1484,4 +1501,9 @@ def dicttoxml(
         max_output_bytes=max_output_bytes,
         indent=indent,
     )
+    return serialize(config)
+
+
+def serialize(config: SerializerConfig) -> bytes:
+    """Render an already normalized configuration; see :func:`dicttoxml`."""
     return _SerializerEngine(config).render()