jsonxox 0.8.0__tar.gz

jsonxox-0.8.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2023–2026 Daniel Sissman.
+
+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.

jsonxox-0.8.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: jsonxox
+Version: 0.8.0
+Summary: Parsing for extended JSON with optional comments and trailing commas
+Author: Daniel Sissman
+License-Expression: MIT
+Project-URL: documentation, https://github.com/bluebinary/jsonxox/blob/main/README.md
+Project-URL: changelog, https://github.com/bluebinary/jsonxox/blob/main/CHANGELOG.md
+Project-URL: repository, https://github.com/bluebinary/jsonxox
+Project-URL: issues, https://github.com/bluebinary/jsonxox/issues
+Project-URL: homepage, https://github.com/bluebinary/jsonxox
+Keywords: json,extened json,json with comments,json with trailing commas
+Platform: any
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: development
+Requires-Dist: black==26.1.*; extra == "development"
+Requires-Dist: pytest==9.0.*; extra == "development"
+Requires-Dist: pytest-codeblocks==0.17.*; extra == "development"
+Requires-Dist: pyflakes==3.4.*; extra == "development"
+Provides-Extra: distribution
+Requires-Dist: build; extra == "distribution"
+Requires-Dist: twine; extra == "distribution"
+Requires-Dist: wheel; extra == "distribution"
+Dynamic: license-file
+
+# JSONXOX: Extended JSON Parsing
+
+Do you love the JSON serialization format but wish it included support for optional
+comments and trailing commas? Well if so, the JSONXOX library is for you.
+
+The JSONXOX library provides support for parsing extended JSON files and strings – JSON
+files and strings which may contain optional C-style single-line and multi-line comments
+as well as trailing commas.
+
+### Requirements
+
+The JSONXOX library has been tested with Python 3.10, 3.11, 3.12, 3.13 and 3.14. The
+library has not been tested with, nor is it likely compatible with Python 3.9 and earlier.
+
+### Installation
+
+The JSONXOX library is available from PyPI, so may be added to a project's dependencies
+via its `requirements.txt` file or similar by referencing the JSONXOX library's name,
+`jsonxox`, or the library may be installed directly into the local runtime environment
+using `pip install` by running the following command:
+
+	$ pip install jsonxox
+
+### Usage Example
+
+To use the JSONXOX library, simply import the library into your project as a drop-in
+replacement for the standard `json` library, and use it as you would to load a JSON file
+or JSON string. The library can be used to load standard JSON files and strings as well
+as extended JSON files and strings containing single- and multi-line comments as well as
+trailing commas. The library can also be used to save standard JSON files and strings.
+
+See the [**Methods**](#methods) section for more information about the methods provided
+by the library.
+
+```python
+import jsonxox
+
+sample: str = """
+/* this is a multi-line comment block
+that can span multiple lines or just a single line
+*/
+{
+  "a": 123, /* this is also a multi-line comment block (using a single line) */
+  // this is a single-line comment
+  "b": "456", // notice the trailing comma
+}
+"""
+
+data = jsonxox.loads(sample)
+
+assert isinstance(data, dict)
+
+assert "a" in data
+assert data["a"] == 123
+
+assert "b" in data
+assert data["b"] == "456"
+```
+
+<a id="methods"></a>
+### Methods
+
+The `jsonxox` library provides the following methods, mirroring the standard `json`
+library in its available methods and overall functionality:
+
+ * `load(handle, **kwargs)` (`object`) – The `load()` method takes a file handle or file
+ handle like object that is an instance of `io.TextIOWrapper` or one of its subclasses
+ as input and removes any single and multi-line comments as well as any trailing commas
+ from the input string contents read from the file handle, and then passes the cleaned
+ string to the standard library's `json.loads()` method for quick deserialization to its
+ corresponding Python data types. Any additional keyword arguments are passed to the
+ `json.loads()` method, as such any additional keyword arguments must be compatible with
+ the `json.loads()` method.
+
+ * `loads(handle, **kwargs)` (`object`) – The `loads()` method takes a string as input
+ and removes any single and multi-line comments as well as any trailing commas from the
+ input string, and then passes the cleaned string to the standard library's `json.loads()`
+ method for quick deserialization to its corresponding Python data types. Any additional
+ keyword arguments are passed to the `json.loads()` method, as such any additional
+ keyword arguments must be compatible with the `json.loads()` method
+
+ * `dump(*args, **kwargs)` – The `dump()` method is a passthrough to the standard
+ `json` library's `dump()` method and accepts the same arguments and has the same return
+ values. Note that the `dump()` method cannot be used to re-save any comments or trailing
+ commas that may have been present in the original extended JSON file or string.
+ 
+ * `dumps(*args, **kwargs)` (`str`) – The `dumps()` method is a passthrough to the standard
+ `json` library's `dumps()` method and accepts the same arguments and has the same return
+ values. Note that the `dumps()` method cannot be used to re-save any comments or trailing
+ commas that may have been present in the original extended JSON file or string.
+
+### Classes
+
+The `jsonxox` library provides the following classes, mirroring the standard `json`
+library in its available classes:
+
+ * `JSONDecoder` – The `JSONDecoder` class is a direct import of and reference to the
+ standard `json` library's `JSONDecoder` class.
+
+ * `JSONEncoder` – The `JSONEncoder` class is a direct import of and reference to the
+ standard `json` library's `JSONEncoder` class.
+
+### Exceptions
+
+The `jsonxox` library provides the following exception classes, mirroring the standard
+`json` library in its available exception classes:
+
+ * `JSONDecodeError` – The `JSONDecodeError` exception class is a direct import of and
+ reference to the standard `json` library's `JSONDecodeError` exception class.
+
+ * `JSONXOXDecodeError` – The `JSONXOXDecodeError` exception class is a subclass of the
+ standard `json` library's `JSONDecodeError` class and will be raised by the `jsonxox`
+ library if an exception occurs while attempting to clean or load the JSON input.
+
+### Unit Tests
+
+The JSONXOX library includes a suite of comprehensive unit tests which ensure that the
+library functionality operates as expected. The unit tests were developed with and are
+run via `pytest`.
+
+To ensure that the unit tests are run within a predictable runtime environment where all
+of the necessary dependencies are available, a [Docker](https://www.docker.com) image is
+created within which the tests are run. To run the unit tests, ensure Docker and Docker
+Compose is [installed](https://docs.docker.com/engine/install/), and perform the
+following commands, which will build the Docker image via `docker compose build` and
+then run the tests via `docker compose run` – the output the tests will be displayed:
+
+```shell
+$ docker compose build
+$ docker compose run tests
+```
+
+To run the unit tests with optional command line arguments being passed to `pytest`,
+append the relevant arguments to the `docker compose run tests` command, as follows, for
+example passing `-v` to enable verbose output and `-s` to print standard output:
+
+```shell
+$ docker compose run tests -v -s
+```
+
+See the documentation for [PyTest](https://docs.pytest.org/en/latest/) regarding
+available optional command line arguments.
+
+### Copyright & License Information
+
+Copyright © 2023–2026 Daniel Sissman; licensed under the MIT License.

jsonxox-0.8.0/README.md

@@ -0,0 +1,146 @@
+# JSONXOX: Extended JSON Parsing
+
+Do you love the JSON serialization format but wish it included support for optional
+comments and trailing commas? Well if so, the JSONXOX library is for you.
+
+The JSONXOX library provides support for parsing extended JSON files and strings – JSON
+files and strings which may contain optional C-style single-line and multi-line comments
+as well as trailing commas.
+
+### Requirements
+
+The JSONXOX library has been tested with Python 3.10, 3.11, 3.12, 3.13 and 3.14. The
+library has not been tested with, nor is it likely compatible with Python 3.9 and earlier.
+
+### Installation
+
+The JSONXOX library is available from PyPI, so may be added to a project's dependencies
+via its `requirements.txt` file or similar by referencing the JSONXOX library's name,
+`jsonxox`, or the library may be installed directly into the local runtime environment
+using `pip install` by running the following command:
+
+	$ pip install jsonxox
+
+### Usage Example
+
+To use the JSONXOX library, simply import the library into your project as a drop-in
+replacement for the standard `json` library, and use it as you would to load a JSON file
+or JSON string. The library can be used to load standard JSON files and strings as well
+as extended JSON files and strings containing single- and multi-line comments as well as
+trailing commas. The library can also be used to save standard JSON files and strings.
+
+See the [**Methods**](#methods) section for more information about the methods provided
+by the library.
+
+```python
+import jsonxox
+
+sample: str = """
+/* this is a multi-line comment block
+that can span multiple lines or just a single line
+*/
+{
+  "a": 123, /* this is also a multi-line comment block (using a single line) */
+  // this is a single-line comment
+  "b": "456", // notice the trailing comma
+}
+"""
+
+data = jsonxox.loads(sample)
+
+assert isinstance(data, dict)
+
+assert "a" in data
+assert data["a"] == 123
+
+assert "b" in data
+assert data["b"] == "456"
+```
+
+<a id="methods"></a>
+### Methods
+
+The `jsonxox` library provides the following methods, mirroring the standard `json`
+library in its available methods and overall functionality:
+
+ * `load(handle, **kwargs)` (`object`) – The `load()` method takes a file handle or file
+ handle like object that is an instance of `io.TextIOWrapper` or one of its subclasses
+ as input and removes any single and multi-line comments as well as any trailing commas
+ from the input string contents read from the file handle, and then passes the cleaned
+ string to the standard library's `json.loads()` method for quick deserialization to its
+ corresponding Python data types. Any additional keyword arguments are passed to the
+ `json.loads()` method, as such any additional keyword arguments must be compatible with
+ the `json.loads()` method.
+
+ * `loads(handle, **kwargs)` (`object`) – The `loads()` method takes a string as input
+ and removes any single and multi-line comments as well as any trailing commas from the
+ input string, and then passes the cleaned string to the standard library's `json.loads()`
+ method for quick deserialization to its corresponding Python data types. Any additional
+ keyword arguments are passed to the `json.loads()` method, as such any additional
+ keyword arguments must be compatible with the `json.loads()` method
+
+ * `dump(*args, **kwargs)` – The `dump()` method is a passthrough to the standard
+ `json` library's `dump()` method and accepts the same arguments and has the same return
+ values. Note that the `dump()` method cannot be used to re-save any comments or trailing
+ commas that may have been present in the original extended JSON file or string.
+ 
+ * `dumps(*args, **kwargs)` (`str`) – The `dumps()` method is a passthrough to the standard
+ `json` library's `dumps()` method and accepts the same arguments and has the same return
+ values. Note that the `dumps()` method cannot be used to re-save any comments or trailing
+ commas that may have been present in the original extended JSON file or string.
+
+### Classes
+
+The `jsonxox` library provides the following classes, mirroring the standard `json`
+library in its available classes:
+
+ * `JSONDecoder` – The `JSONDecoder` class is a direct import of and reference to the
+ standard `json` library's `JSONDecoder` class.
+
+ * `JSONEncoder` – The `JSONEncoder` class is a direct import of and reference to the
+ standard `json` library's `JSONEncoder` class.
+
+### Exceptions
+
+The `jsonxox` library provides the following exception classes, mirroring the standard
+`json` library in its available exception classes:
+
+ * `JSONDecodeError` – The `JSONDecodeError` exception class is a direct import of and
+ reference to the standard `json` library's `JSONDecodeError` exception class.
+
+ * `JSONXOXDecodeError` – The `JSONXOXDecodeError` exception class is a subclass of the
+ standard `json` library's `JSONDecodeError` class and will be raised by the `jsonxox`
+ library if an exception occurs while attempting to clean or load the JSON input.
+
+### Unit Tests
+
+The JSONXOX library includes a suite of comprehensive unit tests which ensure that the
+library functionality operates as expected. The unit tests were developed with and are
+run via `pytest`.
+
+To ensure that the unit tests are run within a predictable runtime environment where all
+of the necessary dependencies are available, a [Docker](https://www.docker.com) image is
+created within which the tests are run. To run the unit tests, ensure Docker and Docker
+Compose is [installed](https://docs.docker.com/engine/install/), and perform the
+following commands, which will build the Docker image via `docker compose build` and
+then run the tests via `docker compose run` – the output the tests will be displayed:
+
+```shell
+$ docker compose build
+$ docker compose run tests
+```
+
+To run the unit tests with optional command line arguments being passed to `pytest`,
+append the relevant arguments to the `docker compose run tests` command, as follows, for
+example passing `-v` to enable verbose output and `-s` to print standard output:
+
+```shell
+$ docker compose run tests -v -s
+```
+
+See the documentation for [PyTest](https://docs.pytest.org/en/latest/) regarding
+available optional command line arguments.
+
+### Copyright & License Information
+
+Copyright © 2023–2026 Daniel Sissman; licensed under the MIT License.

jsonxox-0.8.0/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "jsonxox"
+description = "Parsing for extended JSON with optional comments and trailing commas"
+readme = {file = "README.md", content-type = "text/markdown"}
+keywords = ["json", "extened json", "json with comments", "json with trailing commas"]
+authors = [{name = "Daniel Sissman"}]
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+requires-python = ">=3.10"
+dynamic = [
+  "version",
+  "dependencies",
+  "optional-dependencies",
+]
+
+[project.urls]
+documentation = "https://github.com/bluebinary/jsonxox/blob/main/README.md"
+changelog = "https://github.com/bluebinary/jsonxox/blob/main/CHANGELOG.md"
+repository = "https://github.com/bluebinary/jsonxox"
+issues = "https://github.com/bluebinary/jsonxox/issues"
+homepage = "https://github.com/bluebinary/jsonxox"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = {file = "source/jsonxox/version.txt"}
+dependencies = {file = "requirements.txt"}
+
+[tool.setuptools.dynamic.optional-dependencies]
+development = {file = "requirements.development.txt"}
+distribution = {file = "requirements.distribution.txt"}
+
+[tool.setuptools]
+platforms = ["any"]
+zip-safe = true
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["source"]
+exclude = ["resources*", "tests*", "*#*"]
+
+[tool.setuptools.package-data]
+"*" = ["*.json", "*.jsonx", "*.jsonc"]
+source = ["*.json", "*.jsonx", "*.jsonc"]
+tests = ["tests/data/*.json", "tests/data/*.jsonx", "tests/data/*.jsonc"]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["*#*", "#*", "@*"]
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = [
+    "tests"
+]
+
+[tool.black]
+line-length = 88
+target-version = ["py310"]
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # The following are specific to Black, you probably don't want those.
+  | blib2to3
+  | tests/data
+  | profiling
+)/
+'''

jsonxox-0.8.0/requirements.development.txt

@@ -0,0 +1,5 @@
+# JSONXOX Library: Development & Test Dependencies
+black==26.1.*
+pytest==9.0.*
+pytest-codeblocks==0.17.*
+pyflakes==3.4.*

jsonxox-0.8.0/requirements.distribution.txt

@@ -0,0 +1,4 @@
+# JSONXOX Library: Build & Deployment Dependencies
+build
+twine
+wheel

jsonxox-0.8.0/requirements.txt

@@ -0,0 +1 @@
+# JSONXOX Library: Runtime Dependencies

jsonxox-0.8.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jsonxox-0.8.0/source/jsonxox/__init__.py

@@ -0,0 +1,103 @@
+import json
+import re
+import io
+
+from json import (
+    JSONDecoder,
+    JSONEncoder,
+    JSONDecodeError,
+)
+
+
+class JSONXOXDecodeError(JSONDecodeError):
+    pass
+
+
+def _jsonx_to_json(content: str) -> str:
+    """With an extended JSON string as input (JSON that can contain C-style single and
+    multi-line comments as well as trailing commas) and return a standard JSON string
+    that has had these non-standard elements removed."""
+
+    if not isinstance(content, str):
+        raise TypeError("The 'content' argument must have a string value!")
+
+    if len(content) > 0:
+        flags = re.MULTILINE | re.DOTALL
+
+        try:
+            # Remove multi-line comments that begin with /* and end with */
+            content = re.sub(r"\/\*.*?\*\/", "", content, flags=flags)
+
+            # Remove single-line comments which begin with // and end at a newline, } or ]
+            content = re.sub(r"\s*(#|\/\/)([^\n\}\]]*)", "", content, flags=flags)
+
+            # Remove any trailing commas that are present before block closures
+            content = re.sub(r"\,(\s*)(\]|\})", r"\1\2", content, flags=flags)
+        except Exception as exception:
+            raise JSONXOXDecodeError(
+                "An exception occurred while cleaning the JSON: %s" % (str(exception))
+            ) from exception
+
+    return content.strip()
+
+
+def load(handle, **kwargs) -> object | None:
+    """An extended json.load() method which supports loading JSON files with single and
+    multi-line comments as well as trailing commas."""
+
+    if not isinstance(handle, io.TextIOWrapper):
+        raise RuntimeError("The input must be compatible with io.TextIOWrapper!")
+
+    content = handle.read().strip()
+
+    if len(content) > 0:
+        if content := _jsonx_to_json(content):
+            try:
+                if isinstance(data := json.loads(content, **kwargs), object):
+                    return data
+            except JSONDecodeError as exception:
+                raise JSONXOXDecodeError(str(exception)) from exception
+
+    return None
+
+
+def loads(content: str, **kwargs) -> object | None:
+    """An extended json.loads() method which supports loading JSON files with single and
+    multi-line comments as well as trailing commas."""
+
+    if not isinstance(content, str):
+        raise TypeError("The 'content' argument must have a string value!")
+
+    if len(content) > 0:
+        if content := _jsonx_to_json(content):
+            try:
+                if isinstance(data := json.loads(content, **kwargs), object):
+                    return data
+            except JSONDecodeError as exception:
+                raise JSONXOXDecodeError(str(exception)) from exception
+
+    return None
+
+
+def dump(*args, **kwargs):
+    """A passthrough method for the json standard library's .dump() method."""
+
+    return json.dump(*args, **kwargs)
+
+
+def dumps(*args, **kwargs):
+    """A passthrough method for the json standard library's .dumps() method."""
+
+    return json.dumps(*args, **kwargs)
+
+
+__all__ = [
+    "load",
+    "loads",
+    "dump",
+    "dumps",
+    "JSONDecoder",
+    "JSONEncoder",
+    "JSONDecodeError",
+    "JSONXOXDecodeError",
+]

jsonxox-0.8.0/source/jsonxox/version.txt

@@ -0,0 +1 @@
+0.8.0

jsonxox-0.8.0/source/jsonxox.egg-info/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: jsonxox
+Version: 0.8.0
+Summary: Parsing for extended JSON with optional comments and trailing commas
+Author: Daniel Sissman
+License-Expression: MIT
+Project-URL: documentation, https://github.com/bluebinary/jsonxox/blob/main/README.md
+Project-URL: changelog, https://github.com/bluebinary/jsonxox/blob/main/CHANGELOG.md
+Project-URL: repository, https://github.com/bluebinary/jsonxox
+Project-URL: issues, https://github.com/bluebinary/jsonxox/issues
+Project-URL: homepage, https://github.com/bluebinary/jsonxox
+Keywords: json,extened json,json with comments,json with trailing commas
+Platform: any
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: development
+Requires-Dist: black==26.1.*; extra == "development"
+Requires-Dist: pytest==9.0.*; extra == "development"
+Requires-Dist: pytest-codeblocks==0.17.*; extra == "development"
+Requires-Dist: pyflakes==3.4.*; extra == "development"
+Provides-Extra: distribution
+Requires-Dist: build; extra == "distribution"
+Requires-Dist: twine; extra == "distribution"
+Requires-Dist: wheel; extra == "distribution"
+Dynamic: license-file
+
+# JSONXOX: Extended JSON Parsing
+
+Do you love the JSON serialization format but wish it included support for optional
+comments and trailing commas? Well if so, the JSONXOX library is for you.
+
+The JSONXOX library provides support for parsing extended JSON files and strings – JSON
+files and strings which may contain optional C-style single-line and multi-line comments
+as well as trailing commas.
+
+### Requirements
+
+The JSONXOX library has been tested with Python 3.10, 3.11, 3.12, 3.13 and 3.14. The
+library has not been tested with, nor is it likely compatible with Python 3.9 and earlier.
+
+### Installation
+
+The JSONXOX library is available from PyPI, so may be added to a project's dependencies
+via its `requirements.txt` file or similar by referencing the JSONXOX library's name,
+`jsonxox`, or the library may be installed directly into the local runtime environment
+using `pip install` by running the following command:
+
+	$ pip install jsonxox
+
+### Usage Example
+
+To use the JSONXOX library, simply import the library into your project as a drop-in
+replacement for the standard `json` library, and use it as you would to load a JSON file
+or JSON string. The library can be used to load standard JSON files and strings as well
+as extended JSON files and strings containing single- and multi-line comments as well as
+trailing commas. The library can also be used to save standard JSON files and strings.
+
+See the [**Methods**](#methods) section for more information about the methods provided
+by the library.
+
+```python
+import jsonxox
+
+sample: str = """
+/* this is a multi-line comment block
+that can span multiple lines or just a single line
+*/
+{
+  "a": 123, /* this is also a multi-line comment block (using a single line) */
+  // this is a single-line comment
+  "b": "456", // notice the trailing comma
+}
+"""
+
+data = jsonxox.loads(sample)
+
+assert isinstance(data, dict)
+
+assert "a" in data
+assert data["a"] == 123
+
+assert "b" in data
+assert data["b"] == "456"
+```
+
+<a id="methods"></a>
+### Methods
+
+The `jsonxox` library provides the following methods, mirroring the standard `json`
+library in its available methods and overall functionality:
+
+ * `load(handle, **kwargs)` (`object`) – The `load()` method takes a file handle or file
+ handle like object that is an instance of `io.TextIOWrapper` or one of its subclasses
+ as input and removes any single and multi-line comments as well as any trailing commas
+ from the input string contents read from the file handle, and then passes the cleaned
+ string to the standard library's `json.loads()` method for quick deserialization to its
+ corresponding Python data types. Any additional keyword arguments are passed to the
+ `json.loads()` method, as such any additional keyword arguments must be compatible with
+ the `json.loads()` method.
+
+ * `loads(handle, **kwargs)` (`object`) – The `loads()` method takes a string as input
+ and removes any single and multi-line comments as well as any trailing commas from the
+ input string, and then passes the cleaned string to the standard library's `json.loads()`
+ method for quick deserialization to its corresponding Python data types. Any additional
+ keyword arguments are passed to the `json.loads()` method, as such any additional
+ keyword arguments must be compatible with the `json.loads()` method
+
+ * `dump(*args, **kwargs)` – The `dump()` method is a passthrough to the standard
+ `json` library's `dump()` method and accepts the same arguments and has the same return
+ values. Note that the `dump()` method cannot be used to re-save any comments or trailing
+ commas that may have been present in the original extended JSON file or string.
+ 
+ * `dumps(*args, **kwargs)` (`str`) – The `dumps()` method is a passthrough to the standard
+ `json` library's `dumps()` method and accepts the same arguments and has the same return
+ values. Note that the `dumps()` method cannot be used to re-save any comments or trailing
+ commas that may have been present in the original extended JSON file or string.
+
+### Classes
+
+The `jsonxox` library provides the following classes, mirroring the standard `json`
+library in its available classes:
+
+ * `JSONDecoder` – The `JSONDecoder` class is a direct import of and reference to the
+ standard `json` library's `JSONDecoder` class.
+
+ * `JSONEncoder` – The `JSONEncoder` class is a direct import of and reference to the
+ standard `json` library's `JSONEncoder` class.
+
+### Exceptions
+
+The `jsonxox` library provides the following exception classes, mirroring the standard
+`json` library in its available exception classes:
+
+ * `JSONDecodeError` – The `JSONDecodeError` exception class is a direct import of and
+ reference to the standard `json` library's `JSONDecodeError` exception class.
+
+ * `JSONXOXDecodeError` – The `JSONXOXDecodeError` exception class is a subclass of the
+ standard `json` library's `JSONDecodeError` class and will be raised by the `jsonxox`
+ library if an exception occurs while attempting to clean or load the JSON input.
+
+### Unit Tests
+
+The JSONXOX library includes a suite of comprehensive unit tests which ensure that the
+library functionality operates as expected. The unit tests were developed with and are
+run via `pytest`.
+
+To ensure that the unit tests are run within a predictable runtime environment where all
+of the necessary dependencies are available, a [Docker](https://www.docker.com) image is
+created within which the tests are run. To run the unit tests, ensure Docker and Docker
+Compose is [installed](https://docs.docker.com/engine/install/), and perform the
+following commands, which will build the Docker image via `docker compose build` and
+then run the tests via `docker compose run` – the output the tests will be displayed:
+
+```shell
+$ docker compose build
+$ docker compose run tests
+```
+
+To run the unit tests with optional command line arguments being passed to `pytest`,
+append the relevant arguments to the `docker compose run tests` command, as follows, for
+example passing `-v` to enable verbose output and `-s` to print standard output:
+
+```shell
+$ docker compose run tests -v -s
+```
+
+See the documentation for [PyTest](https://docs.pytest.org/en/latest/) regarding
+available optional command line arguments.
+
+### Copyright & License Information
+
+Copyright © 2023–2026 Daniel Sissman; licensed under the MIT License.

jsonxox-0.8.0/source/jsonxox.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE.md
+README.md
+pyproject.toml
+requirements.development.txt
+requirements.distribution.txt
+requirements.txt
+source/jsonxox/__init__.py
+source/jsonxox/version.txt
+source/jsonxox.egg-info/PKG-INFO
+source/jsonxox.egg-info/SOURCES.txt
+source/jsonxox.egg-info/dependency_links.txt
+source/jsonxox.egg-info/requires.txt
+source/jsonxox.egg-info/top_level.txt
+source/jsonxox.egg-info/zip-safe
+tests/test_jsonxox.py

jsonxox-0.8.0/source/jsonxox.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jsonxox-0.8.0/source/jsonxox.egg-info/requires.txt

@@ -0,0 +1,11 @@
+
+[development]
+black==26.1.*
+pytest==9.0.*
+pytest-codeblocks==0.17.*
+pyflakes==3.4.*
+
+[distribution]
+build
+twine
+wheel

jsonxox-0.8.0/source/jsonxox.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsonxox

jsonxox-0.8.0/source/jsonxox.egg-info/zip-safe

@@ -0,0 +1 @@
+

jsonxox-0.8.0/tests/test_jsonxox.py

@@ -0,0 +1,281 @@
+import jsonxox
+import io
+
+
+def test_jsonxox_loads_with_trailing_commas_indented(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/trailing-commas-indented.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_loads_with_trailing_commas_compacted(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/trailing-commas-compacted.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_loads_with_single_line_comments_indented(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/single-line-comments-indented.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_loads_with_single_line_comments_compacted(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/single-line-comments-compacted.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_loads_with_multi_line_comments_indented(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/multi-line-comments-indented.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_loads_with_multi_line_comments_compacted(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/multi-line-comments-compacted.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_load_with_all_combined_indented(path: callable):
+    """Text the jsonxox.load() method."""
+
+    filepath: str = path("examples/all-combined-indented.jsonx")
+
+    assert isinstance(filepath, str)
+
+    with open(filepath, "r") as handle:
+        data = jsonxox.load(handle)
+
+        assert isinstance(data, dict)
+
+        assert "a" in data
+        assert data["a"] == 123
+
+        assert "b" in data
+        assert data["b"] == "456"
+
+        assert "c" in data
+        assert data["c"] == 789.10
+
+
+def test_jsonxox_load_with_all_combined_compacted(path: callable):
+    """Text the jsonxox.load() method."""
+
+    filepath: str = path("examples/all-combined-compacted.jsonx")
+
+    assert isinstance(filepath, str)
+
+    with open(filepath, "r") as handle:
+        data = jsonxox.load(handle)
+
+        assert isinstance(data, dict)
+
+        assert "a" in data
+        assert data["a"] == 123
+
+        assert "b" in data
+        assert data["b"] == "456"
+
+        assert "c" in data
+        assert data["c"] == 789.10
+
+
+def test_jsonxox_loads_with_all_combined_indented(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/all-combined-indented.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_loads_with_all_combined_compacted(read: callable):
+    """Text the jsonxox.loads() method."""
+
+    contents: str = read("examples/all-combined-compacted.jsonx")
+
+    assert isinstance(contents, str)
+
+    data = jsonxox.loads(contents)
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+
+def test_jsonxox_dump(path: callable, read: callable):
+    """Text the jsonxox.dump() method."""
+
+    data = {
+        "a": 123,
+        "b": "456",
+        "c": 789.10,
+    }
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+    with io.StringIO() as handle:
+        jsonxox.dump(data, handle, indent=2, ensure_ascii=False)
+
+        handle.seek(0)
+
+        dumped: str = handle.read()
+
+        assert isinstance(dumped, str)
+
+        contents: str = read("examples/dumped.json")
+
+        assert isinstance(contents, str)
+
+        assert dumped == contents
+
+
+def test_jsonxox_dumps(path: callable, read: callable):
+    """Text the jsonxox.dumps() method."""
+
+    data = {
+        "a": 123,
+        "b": "456",
+        "c": 789.10,
+    }
+
+    assert isinstance(data, dict)
+
+    assert "a" in data
+    assert data["a"] == 123
+
+    assert "b" in data
+    assert data["b"] == "456"
+
+    assert "c" in data
+    assert data["c"] == 789.10
+
+    dumped: str = jsonxox.dumps(data, indent=2, ensure_ascii=False)
+
+    assert isinstance(dumped, str)
+
+    contents: str = read("examples/dumped.json")
+
+    assert isinstance(contents, str)
+
+    assert dumped == contents