json2xml 6.0.7__tar.gz → 6.1.0__tar.gz

{json2xml-6.0.7 → json2xml-6.1.0}/CONTRIBUTING.rst

@@ -9,6 +9,17 @@ helps, and credit will always be given.
 
 You can contribute in many ways:
 
+Good First Contributions
+------------------------
+
+If you are new to the project, these are useful places to start:
+
+* Improve examples for real-world API responses, files, and command-line usage.
+* Add small tests around conversion options such as wrappers, list handling, CDATA, and XPath output.
+* Improve benchmark documentation or add a reproducible benchmark case.
+* Polish CLI behavior, error messages, and help text.
+* Review the roadmap in ``ROADMAP.md`` and open a focused issue before starting larger changes.
+
 Types of Contributions
 ----------------------
 
@@ -99,7 +110,7 @@ Ready to contribute? Here's how to set up `json2xml` for local development.
 Rust Extension Development
 --------------------------
 
-The ``json2xml-rs`` Rust extension provides ~29x faster performance. If you want to contribute to the Rust extension:
+The ``json2xml-rs`` Rust extension provides ~57-129x faster performance in the current benchmark. If you want to contribute to the Rust extension:
 
 **Prerequisites**
 

{json2xml-6.0.7 → json2xml-6.1.0}/HISTORY.rst

@@ -1,4 +1,11 @@
 
+6.1.0 / 2026-05-04
+==================
+
+  * fix: address open contribution issues (#292)
+  * docs: improve README and add public roadmap (#287)
+
+
 6.0.7 / 2026-04-26
 ==================
 

{json2xml-6.0.7 → json2xml-6.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json2xml
-Version: 6.0.7
+Version: 6.1.0
 Summary: Simple Python Library to convert JSON to XML
 Author-email: Vinit Kumar <mail@vinitkumar.me>
 License: Apache Software License 2.0
@@ -54,7 +54,7 @@ json2xml
 .. image:: https://codecov.io/gh/vinitkumar/json2xml/branch/master/graph/badge.svg?token=Yt2h55eTL2
       :target: https://codecov.io/gh/vinitkumar/json2xml
 
-json2xml is a Python library that allows you to convert JSON data into XML format. It's simple, efficient, and easy to use.
+json2xml is a Python library and CLI for converting JSON data into XML. It is designed for teams that need predictable XML output, Python-first ergonomics, and a faster native path when conversion speed matters.
 
 Documentation: https://json2xml.readthedocs.io.
 
@@ -62,6 +62,137 @@ The library was initially dependent on the `dict2xml` project, but it has now be
 
 **Looking for a Go version?** Check out `json2xml-go <https://github.com/vinitkumar/json2xml-go>`_, a Go port of this library with identical features and a native CLI tool.
 
+Why json2xml?
+^^^^^^^^^^^^^
+
+Use json2xml when you need:
+
+* A Python library for turning dictionaries, strings, files, or API responses into XML
+* A command-line tool for quick JSON-to-XML conversion from scripts and terminals
+* Optional Rust acceleration with automatic fallback to the pure Python implementation
+* XPath 3.1 compatible output when standards-friendly XML is required
+* A small, focused project with tests, docs, benchmarks, and multiple native implementation experiments
+
+Quick Start
+^^^^^^^^^^^
+
+Install the Python package:
+
+.. code-block:: console
+
+    pip install json2xml
+
+Use it from Python:
+
+.. code-block:: python
+
+    from json2xml import json2xml
+    from json2xml.utils import readfromstring
+
+    data = readfromstring('{"name": "Ada", "language": "Python"}')
+    print(json2xml.Json2xml(data).to_xml())
+
+Use it from the terminal:
+
+.. code-block:: console
+
+    json2xml-py -s '{"name": "Ada", "language": "Python"}'
+
+Install the accelerated path:
+
+.. code-block:: console
+
+    pip install json2xml[fast]
+
+Real-world Examples
+^^^^^^^^^^^^^^^^^^^
+
+Convert a JSON API response in Python when another system expects XML:
+
+.. code-block:: python
+
+    from json2xml import json2xml
+
+    api_response = {"user": {"id": 7, "name": "Ada"}, "active": True}
+    print(json2xml.Json2xml(api_response, pretty=False).to_xml().decode("utf-8"))
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><user type="dict"><id type="int">7</id><name type="str">Ada</name></user><active type="bool">true</active></all>
+
+Convert a local JSON export from the shell:
+
+.. code-block:: console
+
+    cat > orders.json <<'JSON'
+    {"orders":[{"id":"A100","total":19.99},{"id":"A101","total":5.5}]}
+    JSON
+    json2xml-py --no-pretty --no-type orders.json
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><orders><item><id>A100</id><total>19.99</total></item><item><id>A101</id><total>5.5</total></item></orders></all>
+
+Convert stdin in a shell pipeline:
+
+.. code-block:: console
+
+    printf '%s\n' '{"event":"deploy","status":"ok"}' | json2xml-py --no-pretty --no-type -
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><event>deploy</event><status>ok</status></all>
+
+Performance Snapshot
+^^^^^^^^^^^^^^^^^^^^
+
+The optional Rust extension is the fastest path for Python callers because it avoids process startup overhead and falls back to pure Python when a feature is not supported natively.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 20 20 15
+
+   * - Test Case
+     - Pure Python
+     - Rust Extension
+     - Speedup
+   * - **Small JSON** (47 bytes)
+     - 31.49µs
+     - 0.55µs
+     - **56.8x**
+   * - **Medium JSON** (3.2 KB)
+     - 1.69ms
+     - 16.15µs
+     - **105.0x**
+   * - **Large JSON** (32 KB)
+     - 17.97ms
+     - 168.21µs
+     - **106.8x**
+   * - **Very Large JSON** (323 KB)
+     - 183.33ms
+     - 1.42ms
+     - **129.0x**
+
+See `BENCHMARKS.md <https://github.com/vinitkumar/json2xml/blob/master/BENCHMARKS.md>`_ for the full Python, Rust, Go, and Zig comparison.
+
+Project Roadmap
+^^^^^^^^^^^^^^^
+
+The next phase of json2xml is focused on making the project easier to adopt, benchmark, and contribute to:
+
+* Improve examples for common API, file, and CLI workflows
+* Add clearer contribution paths for docs, CLI polish, and benchmark coverage
+* Keep comparing Python, Rust, Go, and Zig implementations with reproducible benchmarks
+* Continue hardening the Rust extension fallback behavior across platforms
+
+See `ROADMAP.md <https://github.com/vinitkumar/json2xml/blob/master/ROADMAP.md>`_ for more detail.
+
 
 
 Architecture Diagram
@@ -574,4 +705,3 @@ Help and Support to maintain this project
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - You can sponsor my work for this plugin here: https://github.com/sponsors/vinitkumar/
-

{json2xml-6.0.7 → json2xml-6.1.0}/README.rst

@@ -18,7 +18,7 @@ json2xml
 .. image:: https://codecov.io/gh/vinitkumar/json2xml/branch/master/graph/badge.svg?token=Yt2h55eTL2
       :target: https://codecov.io/gh/vinitkumar/json2xml
 
-json2xml is a Python library that allows you to convert JSON data into XML format. It's simple, efficient, and easy to use.
+json2xml is a Python library and CLI for converting JSON data into XML. It is designed for teams that need predictable XML output, Python-first ergonomics, and a faster native path when conversion speed matters.
 
 Documentation: https://json2xml.readthedocs.io.
 
@@ -26,6 +26,137 @@ The library was initially dependent on the `dict2xml` project, but it has now be
 
 **Looking for a Go version?** Check out `json2xml-go <https://github.com/vinitkumar/json2xml-go>`_, a Go port of this library with identical features and a native CLI tool.
 
+Why json2xml?
+^^^^^^^^^^^^^
+
+Use json2xml when you need:
+
+* A Python library for turning dictionaries, strings, files, or API responses into XML
+* A command-line tool for quick JSON-to-XML conversion from scripts and terminals
+* Optional Rust acceleration with automatic fallback to the pure Python implementation
+* XPath 3.1 compatible output when standards-friendly XML is required
+* A small, focused project with tests, docs, benchmarks, and multiple native implementation experiments
+
+Quick Start
+^^^^^^^^^^^
+
+Install the Python package:
+
+.. code-block:: console
+
+    pip install json2xml
+
+Use it from Python:
+
+.. code-block:: python
+
+    from json2xml import json2xml
+    from json2xml.utils import readfromstring
+
+    data = readfromstring('{"name": "Ada", "language": "Python"}')
+    print(json2xml.Json2xml(data).to_xml())
+
+Use it from the terminal:
+
+.. code-block:: console
+
+    json2xml-py -s '{"name": "Ada", "language": "Python"}'
+
+Install the accelerated path:
+
+.. code-block:: console
+
+    pip install json2xml[fast]
+
+Real-world Examples
+^^^^^^^^^^^^^^^^^^^
+
+Convert a JSON API response in Python when another system expects XML:
+
+.. code-block:: python
+
+    from json2xml import json2xml
+
+    api_response = {"user": {"id": 7, "name": "Ada"}, "active": True}
+    print(json2xml.Json2xml(api_response, pretty=False).to_xml().decode("utf-8"))
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><user type="dict"><id type="int">7</id><name type="str">Ada</name></user><active type="bool">true</active></all>
+
+Convert a local JSON export from the shell:
+
+.. code-block:: console
+
+    cat > orders.json <<'JSON'
+    {"orders":[{"id":"A100","total":19.99},{"id":"A101","total":5.5}]}
+    JSON
+    json2xml-py --no-pretty --no-type orders.json
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><orders><item><id>A100</id><total>19.99</total></item><item><id>A101</id><total>5.5</total></item></orders></all>
+
+Convert stdin in a shell pipeline:
+
+.. code-block:: console
+
+    printf '%s\n' '{"event":"deploy","status":"ok"}' | json2xml-py --no-pretty --no-type -
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><event>deploy</event><status>ok</status></all>
+
+Performance Snapshot
+^^^^^^^^^^^^^^^^^^^^
+
+The optional Rust extension is the fastest path for Python callers because it avoids process startup overhead and falls back to pure Python when a feature is not supported natively.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 20 20 15
+
+   * - Test Case
+     - Pure Python
+     - Rust Extension
+     - Speedup
+   * - **Small JSON** (47 bytes)
+     - 31.49µs
+     - 0.55µs
+     - **56.8x**
+   * - **Medium JSON** (3.2 KB)
+     - 1.69ms
+     - 16.15µs
+     - **105.0x**
+   * - **Large JSON** (32 KB)
+     - 17.97ms
+     - 168.21µs
+     - **106.8x**
+   * - **Very Large JSON** (323 KB)
+     - 183.33ms
+     - 1.42ms
+     - **129.0x**
+
+See `BENCHMARKS.md <https://github.com/vinitkumar/json2xml/blob/master/BENCHMARKS.md>`_ for the full Python, Rust, Go, and Zig comparison.
+
+Project Roadmap
+^^^^^^^^^^^^^^^
+
+The next phase of json2xml is focused on making the project easier to adopt, benchmark, and contribute to:
+
+* Improve examples for common API, file, and CLI workflows
+* Add clearer contribution paths for docs, CLI polish, and benchmark coverage
+* Keep comparing Python, Rust, Go, and Zig implementations with reproducible benchmarks
+* Continue hardening the Rust extension fallback behavior across platforms
+
+See `ROADMAP.md <https://github.com/vinitkumar/json2xml/blob/master/ROADMAP.md>`_ for more detail.
+
 
 
 Architecture Diagram
@@ -538,4 +669,3 @@ Help and Support to maintain this project
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - You can sponsor my work for this plugin here: https://github.com/sponsors/vinitkumar/
-

{json2xml-6.0.7 → json2xml-6.1.0}/docs/usage.rst

@@ -33,6 +33,52 @@ Here's how to use each method:
     print(json2xml.Json2xml(data).to_xml())
 
 
+Real-world Examples
+-------------------
+
+Convert a JSON API response in Python when another service expects XML:
+
+.. code-block:: python
+
+    from json2xml import json2xml
+
+    api_response = {"user": {"id": 7, "name": "Ada"}, "active": True}
+    print(json2xml.Json2xml(api_response, pretty=False).to_xml().decode("utf-8"))
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><user type="dict"><id type="int">7</id><name type="str">Ada</name></user><active type="bool">true</active></all>
+
+Convert a local JSON export from the shell:
+
+.. code-block:: console
+
+    cat > orders.json <<'JSON'
+    {"orders":[{"id":"A100","total":19.99},{"id":"A101","total":5.5}]}
+    JSON
+    json2xml-py --no-pretty --no-type orders.json
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><orders><item><id>A100</id><total>19.99</total></item><item><id>A101</id><total>5.5</total></item></orders></all>
+
+Convert stdin in a shell pipeline:
+
+.. code-block:: console
+
+    printf '%s\n' '{"event":"deploy","status":"ok"}' | json2xml-py --no-pretty --no-type -
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><event>deploy</event><status>ok</status></all>
+
+
 Constructor Parameters
 ----------------------
 

{json2xml-6.0.7 → json2xml-6.1.0}/json2xml/__init__.py

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

{json2xml-6.0.7 → json2xml-6.1.0}/json2xml/cli.py

@@ -43,6 +43,7 @@ from __future__ import annotations
 
 import argparse
 import sys
+from pathlib import Path
 from typing import NoReturn
 
 from json2xml import __version__
@@ -263,22 +264,36 @@ def read_input(args: argparse.Namespace) -> JSONValue:
         try:
             return readfromstring(args.string)
         except StringReadError as e:
-            exit_with_error(f"Error parsing JSON string: {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 reading JSON file: {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. Use -h for help.")
+    exit_with_error(
+        "Error: No input provided. Pass a JSON file, use - for stdin, "
+        "or provide --string/--url."
+    )
 
 
 def read_from_stdin() -> JSONValue:
@@ -294,10 +309,15 @@ def read_from_stdin() -> JSONValue:
     try:
         json_str = sys.stdin.read().strip()
         if not json_str:
-            exit_with_error("Error: Empty input")
+            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(f"Error parsing JSON from stdin: {e}")
+        exit_with_error(
+            "Error: Invalid JSON from stdin. Pipe valid JSON into stdin "
+            f"or pass a file/--string. ({e})"
+        )
 
 
 def write_output(output: str | bytes, output_file: str | None) -> None:

{json2xml-6.0.7 → json2xml-6.1.0}/json2xml.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: json2xml
-Version: 6.0.7
+Version: 6.1.0
 Summary: Simple Python Library to convert JSON to XML
 Author-email: Vinit Kumar <mail@vinitkumar.me>
 License: Apache Software License 2.0
@@ -54,7 +54,7 @@ json2xml
 .. image:: https://codecov.io/gh/vinitkumar/json2xml/branch/master/graph/badge.svg?token=Yt2h55eTL2
       :target: https://codecov.io/gh/vinitkumar/json2xml
 
-json2xml is a Python library that allows you to convert JSON data into XML format. It's simple, efficient, and easy to use.
+json2xml is a Python library and CLI for converting JSON data into XML. It is designed for teams that need predictable XML output, Python-first ergonomics, and a faster native path when conversion speed matters.
 
 Documentation: https://json2xml.readthedocs.io.
 
@@ -62,6 +62,137 @@ The library was initially dependent on the `dict2xml` project, but it has now be
 
 **Looking for a Go version?** Check out `json2xml-go <https://github.com/vinitkumar/json2xml-go>`_, a Go port of this library with identical features and a native CLI tool.
 
+Why json2xml?
+^^^^^^^^^^^^^
+
+Use json2xml when you need:
+
+* A Python library for turning dictionaries, strings, files, or API responses into XML
+* A command-line tool for quick JSON-to-XML conversion from scripts and terminals
+* Optional Rust acceleration with automatic fallback to the pure Python implementation
+* XPath 3.1 compatible output when standards-friendly XML is required
+* A small, focused project with tests, docs, benchmarks, and multiple native implementation experiments
+
+Quick Start
+^^^^^^^^^^^
+
+Install the Python package:
+
+.. code-block:: console
+
+    pip install json2xml
+
+Use it from Python:
+
+.. code-block:: python
+
+    from json2xml import json2xml
+    from json2xml.utils import readfromstring
+
+    data = readfromstring('{"name": "Ada", "language": "Python"}')
+    print(json2xml.Json2xml(data).to_xml())
+
+Use it from the terminal:
+
+.. code-block:: console
+
+    json2xml-py -s '{"name": "Ada", "language": "Python"}'
+
+Install the accelerated path:
+
+.. code-block:: console
+
+    pip install json2xml[fast]
+
+Real-world Examples
+^^^^^^^^^^^^^^^^^^^
+
+Convert a JSON API response in Python when another system expects XML:
+
+.. code-block:: python
+
+    from json2xml import json2xml
+
+    api_response = {"user": {"id": 7, "name": "Ada"}, "active": True}
+    print(json2xml.Json2xml(api_response, pretty=False).to_xml().decode("utf-8"))
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><user type="dict"><id type="int">7</id><name type="str">Ada</name></user><active type="bool">true</active></all>
+
+Convert a local JSON export from the shell:
+
+.. code-block:: console
+
+    cat > orders.json <<'JSON'
+    {"orders":[{"id":"A100","total":19.99},{"id":"A101","total":5.5}]}
+    JSON
+    json2xml-py --no-pretty --no-type orders.json
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><orders><item><id>A100</id><total>19.99</total></item><item><id>A101</id><total>5.5</total></item></orders></all>
+
+Convert stdin in a shell pipeline:
+
+.. code-block:: console
+
+    printf '%s\n' '{"event":"deploy","status":"ok"}' | json2xml-py --no-pretty --no-type -
+
+Output:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8" ?><all><event>deploy</event><status>ok</status></all>
+
+Performance Snapshot
+^^^^^^^^^^^^^^^^^^^^
+
+The optional Rust extension is the fastest path for Python callers because it avoids process startup overhead and falls back to pure Python when a feature is not supported natively.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 20 20 15
+
+   * - Test Case
+     - Pure Python
+     - Rust Extension
+     - Speedup
+   * - **Small JSON** (47 bytes)
+     - 31.49µs
+     - 0.55µs
+     - **56.8x**
+   * - **Medium JSON** (3.2 KB)
+     - 1.69ms
+     - 16.15µs
+     - **105.0x**
+   * - **Large JSON** (32 KB)
+     - 17.97ms
+     - 168.21µs
+     - **106.8x**
+   * - **Very Large JSON** (323 KB)
+     - 183.33ms
+     - 1.42ms
+     - **129.0x**
+
+See `BENCHMARKS.md <https://github.com/vinitkumar/json2xml/blob/master/BENCHMARKS.md>`_ for the full Python, Rust, Go, and Zig comparison.
+
+Project Roadmap
+^^^^^^^^^^^^^^^
+
+The next phase of json2xml is focused on making the project easier to adopt, benchmark, and contribute to:
+
+* Improve examples for common API, file, and CLI workflows
+* Add clearer contribution paths for docs, CLI polish, and benchmark coverage
+* Keep comparing Python, Rust, Go, and Zig implementations with reproducible benchmarks
+* Continue hardening the Rust extension fallback behavior across platforms
+
+See `ROADMAP.md <https://github.com/vinitkumar/json2xml/blob/master/ROADMAP.md>`_ for more detail.
+
 
 
 Architecture Diagram
@@ -574,4 +705,3 @@ Help and Support to maintain this project
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - You can sponsor my work for this plugin here: https://github.com/sponsors/vinitkumar/
-

{json2xml-6.0.7 → json2xml-6.1.0}/json2xml.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ tests/__init__.py
 tests/conftest.py
 tests/test_cli.py
 tests/test_dict2xml.py
+tests/test_dicttoxml_fast_fallback.py
 tests/test_json2xml.py
 tests/test_missing_coverage.py
 tests/test_rust_dicttoxml.py

{json2xml-6.0.7 → json2xml-6.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "json2xml"
-version = "6.0.7"
+version = "6.1.0"
 description = "Simple Python Library to convert JSON to XML"
 readme = "README.rst"
 requires-python = ">=3.10"

{json2xml-6.0.7 → json2xml-6.1.0}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 6.0.7
+current_version = 6.1.0
 commit = True
 tag = True
 

{json2xml-6.0.7 → json2xml-6.1.0}/tests/test_cli.py

@@ -187,7 +187,7 @@ class TestCLI:
             text=True,
         )
         assert result.returncode == 1
-        assert "Error" in result.stderr
+        assert "Invalid JSON in --string input" in result.stderr
 
     def test_no_input_error(self) -> None:
         """Test error when no input is provided."""
@@ -201,6 +201,7 @@ class TestCLI:
         )
         # Should fail with no input error
         assert result.returncode == 1
+        assert "Empty stdin" in result.stderr
 
     def test_list_input(self) -> None:
         """Test handling of JSON array input."""
@@ -267,7 +268,7 @@ class TestCLI:
             text=True,
         )
         assert result.returncode == 1
-        assert "Empty input" in result.stderr or "Error" in result.stderr
+        assert "Empty stdin" in result.stderr
 
     def test_stdin_whitespace_only(self) -> None:
         """Test error handling when stdin contains only whitespace."""
@@ -303,8 +304,10 @@ class TestCLI:
             text=True,
         )
         assert result.returncode == 1
-        assert "Error" in result.stderr
+        assert "JSON file not found" in result.stderr
+        assert "use - to read JSON from stdin" in result.stderr
 
+    # @lat: [[tests#CLI failure messages#Invalid file JSON names the source]]
     def test_invalid_json_file(self) -> None:
         """Test error handling for file with invalid JSON content."""
         with tempfile.TemporaryDirectory() as tmpdir:
@@ -318,7 +321,8 @@ class TestCLI:
             )
 
         assert result.returncode == 1
-        assert "Error" in result.stderr
+        assert "Could not parse JSON file" in result.stderr
+        assert str(json_file) in result.stderr
 
     def test_output_file_permission_error(self) -> None:
         """Test error handling when output file cannot be written."""
@@ -553,8 +557,34 @@ class TestCLIUnitTests:
             assert exc_info.value.code == 1
 
         captured = capsys.readouterr()
-        assert "Error reading JSON file" in captured.err
+        assert "JSON file not found" in captured.err
+
+    def test_read_input_existing_json_file_parse_error(self, capsys: CaptureFixture[str]) -> None:
+        """Test read_input keeps parse failures distinct from missing file failures."""
+        from json2xml.utils import JSONReadError
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            json_file = Path(tmpdir) / "invalid.json"
+            json_file.write_text("{")
+
+            with patch("json2xml.cli.readfromjson") as mock_read:
+                mock_read.side_effect = JSONReadError("Invalid JSON File")
+
+                args = MagicMock()
+                args.url = None
+                args.string = None
+                args.input_file = str(json_file)
+
+                with pytest.raises(SystemExit) as exc_info:
+                    read_input(args)
+
+                assert exc_info.value.code == 1
+
+        captured = capsys.readouterr()
+        assert "Could not parse JSON file" in captured.err
+        assert str(json_file) in captured.err
 
+    # @lat: [[tests#CLI failure messages#No input is actionable]]
     def test_read_input_no_input_tty(self, capsys: CaptureFixture[str]) -> None:
         """Test read_input exits when no input provided and stdin is a tty."""
         with patch("sys.stdin.isatty", return_value=True):

json2xml-6.1.0/tests/test_dicttoxml_fast_fallback.py

@@ -0,0 +1,98 @@
+"""Tests for optional Rust backend selection in dicttoxml_fast."""
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import Mock
+
+import pytest
+
+import json2xml.dicttoxml_fast as fast_module
+
+
+def _force_rust_backend(monkeypatch: pytest.MonkeyPatch) -> Mock:
+    """Install a fake Rust backend so tests can exercise selection logic without PyO3."""
+    rust_backend = Mock(return_value=b"<rust/>")
+    monkeypatch.setattr(fast_module, "_USE_RUST", True)
+    monkeypatch.setattr(fast_module, "_rust_dicttoxml", rust_backend)
+    return rust_backend
+
+
+# @lat: [[tests#Conversion behavior#Fast wrapper uses Rust for supported options]]
+def test_fast_wrapper_uses_rust_when_available_for_supported_options(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Supported option combinations should go through the Rust callable when present."""
+    rust_backend = _force_rust_backend(monkeypatch)
+
+    result = fast_module.dicttoxml(
+        {"name": "Ada"},
+        root=False,
+        custom_root="person",
+        attr_type=False,
+        item_wrap=False,
+        cdata=True,
+        list_headers=True,
+    )
+
+    assert result == b"<rust/>"
+    rust_backend.assert_called_once_with(
+        {"name": "Ada"},
+        root=False,
+        custom_root="person",
+        attr_type=False,
+        item_wrap=False,
+        cdata=True,
+        list_headers=True,
+    )
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "expected"),
+    [
+        ({"ids": [1]}, b'id="'),
+        ({"item_func": lambda parent: "entry"}, b"<entry"),
+        ({"xml_namespaces": {"demo": "https://example.com/demo"}}, b'xmlns:demo="https://example.com/demo"'),
+        ({"xpath_format": True}, b'xmlns="http://www.w3.org/2005/xpath-functions"'),
+    ],
+)
+def test_fast_wrapper_falls_back_to_python_for_unsupported_options(
+    monkeypatch: pytest.MonkeyPatch,
+    kwargs: dict[str, Any],
+    expected: bytes,
+) -> None:
+    """Unsupported Rust options should preserve Python semantics instead of calling Rust."""
+    rust_backend = _force_rust_backend(monkeypatch)
+
+    result = fast_module.dicttoxml({"items": [1, 2]}, **kwargs)
+
+    assert expected in result
+    rust_backend.assert_not_called()
+
+
+# @lat: [[tests#Conversion behavior#Special keys force Python fallback]]
+def test_fast_wrapper_falls_back_to_python_for_special_keys(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Special @attrs/@val keys require Python processing even when Rust is installed."""
+    rust_backend = _force_rust_backend(monkeypatch)
+
+    result = fast_module.dicttoxml({"record": {"@attrs": {"id": "7"}, "@val": "Ada"}})
+
+    assert b'id="7"' in result
+    assert b">Ada</record>" in result
+    rust_backend.assert_not_called()
+
+
+def test_fast_wrapper_falls_back_to_python_when_rust_is_unavailable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Contributors without json2xml_rs should still exercise the pure Python fallback."""
+    rust_backend = Mock(return_value=b"<rust/>")
+    monkeypatch.setattr(fast_module, "_USE_RUST", False)
+    monkeypatch.setattr(fast_module, "_rust_dicttoxml", rust_backend)
+
+    result = fast_module.dicttoxml({"name": "Ada"})
+
+    assert b"<name" in result
+    assert b">Ada</name>" in result
+    rust_backend.assert_not_called()

{json2xml-6.0.7 → json2xml-6.1.0}/tests/test_utils.py

@@ -31,7 +31,7 @@ if TYPE_CHECKING:
 class JsonTestHandler(BaseHTTPRequestHandler):
     """Tiny HTTP handler for exercising the real URL reader."""
 
-    responses: ClassVar[dict[str, tuple[int, bytes]]] = {
+    json_responses: ClassVar[dict[str, tuple[int, bytes]]] = {
         "/data.json": (200, b'{"key": "value", "number": 42}'),
         "/api": (200, b'{"result": "success"}'),
         "/invalid.json": (200, b"invalid json content"),
@@ -41,7 +41,7 @@ class JsonTestHandler(BaseHTTPRequestHandler):
 
     def do_GET(self) -> None:
         path = self.path.split("?", 1)[0]
-        status, body = self.responses.get(path, (404, b'{"error": "not found"}'))
+        status, body = self.json_responses.get(path, (404, b'{"error": "not found"}'))
         self.send_response(status)
         self.send_header("Content-Type", "application/json")
         self.send_header("Content-Length", str(len(body)))