edq-utils 0.0.2__tar.gz → 0.0.3__tar.gz

{edq_utils-0.0.2/edq_utils.egg-info → edq_utils-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edq-utils
-Version: 0.0.2
+Version: 0.0.3
 Summary: Common utilities used by EduLinq Python projects.
 Author-email: Eriq Augustine <eriq@edulinq.org>
 License: MIT License
@@ -37,6 +37,7 @@ License-File: LICENSE
 Requires-Dist: json5>=0.9.14
 Provides-Extra: dev
 Requires-Dist: mypy>=1.14.1; extra == "dev"
+Requires-Dist: pdoc>=14.7.0; extra == "dev"
 Requires-Dist: pylint; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: vermin; extra == "dev"

edq_utils-0.0.3/edq/__init__.py

@@ -0,0 +1,5 @@
+"""
+General Python tools used by several EduLinq projects.
+"""
+
+__version__ = '0.0.3'

edq_utils-0.0.3/edq/testing/__init__.py

@@ -0,0 +1,3 @@
+"""
+Testing infrastructure.
+"""

{edq_utils-0.0.2 → edq_utils-0.0.3}/edq/testing/run.py

@@ -11,10 +11,6 @@ import sys
 import typing
 import unittest
 
-THIS_DIR: str = os.path.join(os.path.dirname(os.path.realpath(__file__)))
-BASE_PACKAGE_DIR: str = os.path.join(THIS_DIR, '..')
-PROJECT_ROOT_DIR: str = os.path.join(BASE_PACKAGE_DIR, '..')
-
 DEFAULT_TEST_FILENAME_PATTERN: str = '*_test.py'
 
 def _collect_tests(suite: typing.Union[unittest.TestCase, unittest.suite.TestSuite]) -> typing.List[unittest.TestCase]:
@@ -41,13 +37,22 @@ def run(args: argparse.Namespace) -> int:
     Will raise if tests fail to load (e.g. syntax errors) and a suggested exit code otherwise.
     """
 
-    # Start in the project's root and add it in the path.
-    os.chdir(PROJECT_ROOT_DIR)
-    sys.path.append(PROJECT_ROOT_DIR)
+    if (args.work_dir is not None):
+        os.chdir(args.work_dir)
+
+    if (args.path_additions is not None):
+        for path in args.path_additions:
+            sys.path.append(path)
+
+    if (args.test_dirs is None):
+        args.test_dirs = ['.']
 
     runner = unittest.TextTestRunner(verbosity = 3)
-    discovered_suite = unittest.TestLoader().discover(BASE_PACKAGE_DIR, pattern = args.filename_pattern)
-    test_cases = _collect_tests(discovered_suite)
+    test_cases = []
+
+    for test_dir in args.test_dirs:
+        discovered_suite = unittest.TestLoader().discover(test_dir, pattern = args.filename_pattern)
+        test_cases += _collect_tests(discovered_suite)
 
     tests = unittest.suite.TestSuite()
 
@@ -64,27 +69,43 @@ def run(args: argparse.Namespace) -> int:
     faults = len(result.errors) + len(result.failures)
 
     if (not result.wasSuccessful()):
-        # This value will be used as an exit status, so don't larger than a byte.
+        # This value will be used as an exit status, so it should not be larger than a byte.
         # (Some higher values are used specially, so just keep it at a round number.)
         return max(1, min(faults, 100))
 
     return 0
 
 def main() -> int:
+    """ Parse the CLI arguments and run tests. """
+
     args = _get_parser().parse_args()
     return run(args)
 
 def _get_parser() -> argparse.ArgumentParser:
+    """ Build a parser for CLI arguments. """
+
     parser = argparse.ArgumentParser(description = 'Run unit tests discovered in this project.')
 
-    parser.add_argument('pattern',
-        action = 'store', type = str, default = None, nargs = '?',
-        help = 'If supplied, only tests with names matching this pattern will be run. This pattern is used directly in re.search().')
+    parser.add_argument('--work-dir', dest = 'work_dir',
+        action = 'store', type = str, default = os.getcwd(),
+        help = 'Set the working directory when running tests, defaults to the current working directory (%(default)s).')
+
+    parser.add_argument('--tests-dir', dest = 'test_dirs',
+        action = 'append',
+        help = 'Discover tests from these directories. Defaults to the current directory.')
+
+    parser.add_argument('--add-path', dest = 'path_additions',
+        action = 'append',
+        help = 'If supplied, add this path the sys.path before running tests.')
 
     parser.add_argument('--filename-pattern', dest = 'filename_pattern',
         action = 'store', type = str, default = DEFAULT_TEST_FILENAME_PATTERN,
         help = 'The pattern to use to find test files (default: %(default)s).')
 
+    parser.add_argument('pattern',
+        action = 'store', type = str, default = None, nargs = '?',
+        help = 'If supplied, only tests with names matching this pattern will be run. This pattern is used directly in re.search().')
+
     return parser
 
 if __name__ == '__main__':

{edq_utils-0.0.2 → edq_utils-0.0.3}/edq/testing/unittest.py

@@ -1,4 +1,3 @@
-import json
 import typing
 import unittest
 
@@ -15,13 +14,21 @@ class BaseTest(unittest.TestCase):
     maxDiff = None
     """ Don't limit the size of diffs. """
 
-    def assertJSONDictEqual(self, a: dict, b: dict) -> None:
+    def assertJSONDictEqual(self, a: dict, b: dict) -> None:  # pylint: disable=invalid-name
+        """
+        Call assertDictEqual(), but supply a message containing the full JSON representation of the arguments.
+        """
+
         a_json = edq.util.json.dumps(a, indent = 4)
         b_json = edq.util.json.dumps(b, indent = 4)
 
         super().assertDictEqual(a, b, FORMAT_STR % (a_json, b_json))
 
-    def assertJSONListEqual(self, a: list, b: list) -> None:
+    def assertJSONListEqual(self, a: list, b: list) -> None:  # pylint: disable=invalid-name
+        """
+        Call assertListEqual(), but supply a message containing the full JSON representation of the arguments.
+        """
+
         a_json = edq.util.json.dumps(a, indent = 4)
         b_json = edq.util.json.dumps(b, indent = 4)
 

edq_utils-0.0.3/edq/util/__init__.py

@@ -0,0 +1,3 @@
+"""
+Low-level utilities.
+"""

{edq_utils-0.0.2 → edq_utils-0.0.3}/edq/util/dirent.py

@@ -13,6 +13,7 @@ import atexit
 import os
 import shutil
 import tempfile
+import typing
 import uuid
 
 DEFAULT_ENCODING: str = 'utf-8'
@@ -247,7 +248,7 @@ def read_file(raw_path: str, strip: bool = True, encoding: str = DEFAULT_ENCODIN
     return contents
 
 def write_file(
-        raw_path: str, contents: str,
+        raw_path: str, contents: typing.Union[str, None],
         strip: bool = True, newline: bool = True,
         encoding: str = DEFAULT_ENCODING,
         no_clobber = False) -> None:
@@ -276,6 +277,39 @@ def write_file(
     with open(path, 'w', encoding = encoding) as file:
         file.write(contents)
 
+def read_file_bytes(raw_path: str) -> bytes:
+    """ Read the contents of a file as bytes. """
+
+    path = os.path.abspath(raw_path)
+
+    if (not exists(path)):
+        raise ValueError(f"Source of read bytes does not exist: '{raw_path}'.")
+
+    with open(path, 'rb') as file:
+        return file.read()
+
+def write_file_bytes(
+        raw_path: str, contents: typing.Union[bytes, None],
+        no_clobber = False) -> None:
+    """
+    Write the contents of a file as bytes.
+    If clobbering, any existing dirent will be removed before write.
+    """
+
+    path = os.path.abspath(raw_path)
+
+    if (exists(path)):
+        if (no_clobber):
+            raise ValueError(f"Destination of write bytes already exists: '{raw_path}'.")
+
+        remove(path)
+
+    if (contents is None):
+        contents = b''
+
+    with open(path, 'wb') as file:
+        file.write(contents)
+
 def contains_path(parent: str, child: str) -> bool:
     """
     Check if the parent path contains the child path.

{edq_utils-0.0.2 → edq_utils-0.0.3}/edq/util/dirent_test.py

@@ -92,6 +92,124 @@ class TestDirent(edq.testing.unittest.BaseTest):
                 actual = edq.util.dirent.contains_path(parent, child)
                 self.assertEqual(expected, actual)
 
+    def test_read_write_file_bytes_base(self):
+        """ Test reading and writing a file as bytes. """
+
+        # [(path, write kwargs, read kwargs, write contents, expected contents, error substring), ...]
+        # All conent should be strings that will be encoded.
+        test_cases = [
+            # Base
+            (
+                "test.txt",
+                {},
+                {},
+                "test",
+                "test",
+                None,
+            ),
+
+            # Empty Write
+            (
+                "test.txt",
+                {},
+                {},
+                "",
+                "",
+                None,
+            ),
+
+            # None Write
+            (
+                "test.txt",
+                {},
+                {},
+                None,
+                "",
+                None,
+            ),
+
+            # Clobber
+            (
+                "a.txt",
+                {},
+                {},
+                "test",
+                "test",
+                None,
+            ),
+            (
+                "dir_1",
+                {},
+                {},
+                "test",
+                "test",
+                None,
+            ),
+            (
+                "symlink_a.txt",
+                {},
+                {},
+                "test",
+                "test",
+                None,
+            ),
+
+            # No Clobber
+            (
+                "a.txt",
+                {'no_clobber': True},
+                {},
+                "test",
+                "test",
+                'already exists',
+            ),
+            (
+                "dir_1",
+                {'no_clobber': True},
+                {},
+                "test",
+                "test",
+                'already exists',
+            ),
+            (
+                "symlink_a.txt",
+                {'no_clobber': True},
+                {},
+                "test",
+                "test",
+                'already exists',
+            ),
+        ]
+
+        for (i, test_case) in enumerate(test_cases):
+            (path, write_options, read_options, write_contents, expected_contents, error_substring) = test_case
+
+            with self.subTest(msg = f"Case {i} ('{path}'):"):
+                temp_dir = self._prep_temp_dir()
+                path = os.path.join(temp_dir, path)
+
+                if (write_contents is not None):
+                    write_contents = bytes(write_contents, edq.util.dirent.DEFAULT_ENCODING)
+
+                expected_contents = bytes(expected_contents, edq.util.dirent.DEFAULT_ENCODING)
+
+                try:
+                    edq.util.dirent.write_file_bytes(path, write_contents, **write_options)
+                    actual_contents = edq.util.dirent.read_file_bytes(path, **read_options)
+                except Exception as ex:
+                    error_string = self.format_error_string(ex)
+                    if (error_substring is None):
+                        self.fail(f"Unexpected error: '{error_string}'.")
+
+                    self.assertIn(error_substring, error_string, 'Error is not as expected.')
+
+                    continue
+
+                if (error_substring is not None):
+                    self.fail(f"Did not get expected error: '{error_substring}'.")
+
+                self.assertEqual(expected_contents, actual_contents)
+
     def test_read_write_file_base(self):
         """ Test reading and writing a file. """
 
@@ -157,7 +275,7 @@ class TestDirent(edq.testing.unittest.BaseTest):
                 None,
             ),
 
-            # None
+            # None Write
             (
                 "test.txt",
                 {'newline': False},
@@ -225,7 +343,6 @@ class TestDirent(edq.testing.unittest.BaseTest):
 
             with self.subTest(msg = f"Case {i} ('{path}'):"):
                 temp_dir = self._prep_temp_dir()
-
                 path = os.path.join(temp_dir, path)
 
                 try:
@@ -243,7 +360,7 @@ class TestDirent(edq.testing.unittest.BaseTest):
                 if (error_substring is not None):
                     self.fail(f"Did not get expected error: '{error_substring}'.")
 
-            self.assertEqual(expected_contents, actual_contents)
+                self.assertEqual(expected_contents, actual_contents)
 
     def test_copy_contents_base(self):
         """

edq_utils-0.0.3/edq/util/json.py

@@ -0,0 +1,163 @@
+"""
+This file standardizes how we write and read JSON.
+Specifically, we try to be flexible when reading (using JSON5),
+and strict when writing (using vanilla JSON).
+"""
+
+import abc
+import enum
+import json
+import typing
+
+import json5
+
+import edq.util.dirent
+
+class DictConverter(abc.ABC):
+    """
+    A base class for class that can represent (serialize) and reconstruct (deserialize) themselves as/from a dict.
+    The intention is that the dict can then be cleanly converted to/from JSON.
+    """
+
+    @abc.abstractmethod
+    def to_dict(self) -> typing.Dict[str, typing.Any]:
+        """
+        Return a dict that can be used to represent this object.
+        If the dict is passed to from_dict(), an identical object should be reconstructed.
+        """
+
+    @classmethod
+    @abc.abstractmethod
+    # Note that `typing.Self` is returned, but that is introduced in Python 3.12.
+    def from_dict(cls, data: typing.Dict[str, typing.Any]) -> typing.Any:
+        """
+        Return an instance of this subclass created using the given dict.
+        If the dict came from to_dict(), the returned object should be identical to the original.
+        """
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Check for equality.
+
+        This check uses to_dict() and compares the results.
+        This may not be complete or efficient depending on the child class.
+        """
+
+        # Note the hard type check (done so we can keep this method general).
+        if (type(self) != type(other)):  # pylint: disable=unidiomatic-typecheck
+            return False
+
+        return self.to_dict() == other.to_dict()  # type: ignore[attr-defined]
+
+    def __str__(self) -> str:
+        return dumps(self)
+
+    def __repr__(self) -> str:
+        return dumps(self)
+
+def _custom_handle(value: typing.Any) -> typing.Union[typing.Dict[str, typing.Any], str]:
+    """
+    Handle objects that are not JSON serializable by default,
+    e.g., calling vars() on an object.
+    """
+
+    if (isinstance(value, DictConverter)):
+        return value.to_dict()
+
+    if (isinstance(value, enum.Enum)):
+        return str(value)
+
+    if (hasattr(value, '__dict__')):
+        return vars(value)
+
+    raise ValueError(f"Could not JSON serialize object: '{value}'.")
+
+def load(file_obj: typing.TextIO, strict: bool = False, **kwargs) -> typing.Dict[str, typing.Any]:
+    """
+    Load a file object/handler as JSON.
+    If strict is set, then use standard Python JSON,
+    otherwise use JSON5.
+    """
+
+    if (strict):
+        return json.load(file_obj, **kwargs)
+
+    return json5.load(file_obj, **kwargs)
+
+def loads(text: str, strict: bool = False, **kwargs) -> typing.Dict[str, typing.Any]:
+    """
+    Load a string as JSON.
+    If strict is set, then use standard Python JSON,
+    otherwise use JSON5.
+    """
+
+    if (strict):
+        return json.loads(text, **kwargs)
+
+    return json5.loads(text, **kwargs)
+
+def load_path(
+        path: str,
+        strict: bool = False,
+        encoding: str = edq.util.dirent.DEFAULT_ENCODING,
+        **kwargs) -> typing.Dict[str, typing.Any]:
+    """
+    Load a file path as JSON.
+    If strict is set, then use standard Python JSON,
+    otherwise use JSON5.
+    """
+
+    try:
+        with open(path, 'r', encoding = encoding) as file:
+            return load(file, strict = strict, **kwargs)
+    except Exception as ex:
+        raise ValueError(f"Failed to read JSON file '{path}'.") from ex
+
+def loads_object(text: str, cls: typing.Type[DictConverter], **kwargs) -> DictConverter:
+    """ Load a JSON string into an object (which is a subclass of DictConverter). """
+
+    data = loads(text, **kwargs)
+    if (not isinstance(data, dict)):
+        raise ValueError(f"JSON to load into an object is not a dict, found '{type(data)}'.")
+
+    return cls.from_dict(data)
+
+def load_object_path(path: str, cls: typing.Type[DictConverter], **kwargs) -> DictConverter:
+    """ Load a JSON file into an object (which is a subclass of DictConverter). """
+
+    data = load_path(path, **kwargs)
+    if (not isinstance(data, dict)):
+        raise ValueError(f"JSON to load into an object is not a dict, found '{type(data)}'.")
+
+    return cls.from_dict(data)
+
+def dump(
+        data: typing.Any,
+        file_obj: typing.TextIO,
+        default: typing.Union[typing.Callable, None] = _custom_handle,
+        sort_keys: bool = True,
+        **kwargs) -> None:
+    """ Dump an object as a JSON file object. """
+
+    json.dump(data, file_obj, default = default, sort_keys = sort_keys, **kwargs)
+
+def dumps(
+        data: typing.Any,
+        default: typing.Union[typing.Callable, None] = _custom_handle,
+        sort_keys: bool = True,
+        **kwargs) -> str:
+    """ Dump an object as a JSON string. """
+
+    return json.dumps(data, default = default, sort_keys = sort_keys, **kwargs)
+
+def dump_path(
+        data: typing.Any,
+        path: str,
+        default: typing.Union[typing.Callable, None] = _custom_handle,
+        sort_keys: bool = True,
+        encoding: str = edq.util.dirent.DEFAULT_ENCODING,
+        **kwargs) -> None:
+    """ Dump an object as a JSON file. """
+
+    with open(path, 'w', encoding = encoding) as file:
+        dump(data, file, default = default, sort_keys = sort_keys, **kwargs)

{edq_utils-0.0.2 → edq_utils-0.0.3}/edq/util/json_test.py

@@ -1,4 +1,5 @@
 import os
+import typing
 
 import edq.testing.unittest
 import edq.util.dirent
@@ -80,10 +81,10 @@ class TestJSON(edq.testing.unittest.BaseTest):
     def _subtest_loads_dumps(self, text_content, dict_content, strict):
         actual_dict = edq.util.json.loads(text_content, strict = strict)
         actual_text = edq.util.json.dumps(dict_content)
-        double_conversion_dict = edq.util.json.dumps(actual_dict)
+        double_conversion_text = edq.util.json.dumps(actual_dict)
 
         self.assertDictEqual(dict_content, actual_dict)
-        self.assertEqual(actual_text, double_conversion_dict)
+        self.assertEqual(actual_text, double_conversion_text)
 
     def _subtest_load_dump(self, text_content, dict_content, strict):
         temp_dir = edq.util.dirent.get_temp_dir(prefix = 'edq_test_json_')
@@ -119,3 +120,109 @@ class TestJSON(edq.testing.unittest.BaseTest):
 
         self.assertDictEqual(dict_content, text_load)
         self.assertDictEqual(dict_load, text_load)
+
+    def test_object_base(self):
+        """
+        Test loading and dumping JSON objects
+        """
+
+        # [(string, object, error_substring), ...]
+        test_cases = [
+            # Base
+            (
+                '{"a": 1, "b": "b"}',
+                _TestConverter(1, "b"),
+                None,
+            ),
+
+            # Missing Key
+            (
+                '{"a": 1}',
+                _TestConverter(1, None),
+                None,
+            ),
+
+            # Empty
+            (
+                '{}',
+                _TestConverter(None, None),
+                None,
+            ),
+
+            # Extra Key
+            (
+                '{"a": 1, "b": "b", "c": 0}',
+                _TestConverter(1, "b"),
+                None,
+            ),
+
+            # List
+            (
+                '[{"a": 1, "b": "b"}]',
+                _TestConverter(1, "b"),
+                'not a dict',
+            ),
+        ]
+
+        # [(function, name), ...]
+        test_methods = [
+            (self._subtest_loads_object, 'subtest_loads_object'),
+            (self._subtest_load_object_path, 'subtest_load_object_path'),
+        ]
+
+        for (test_method, test_method_name) in test_methods:
+            for (i, test_case) in enumerate(test_cases):
+                (text_content, object_content, error_substring) = test_case
+
+                with self.subTest(msg = f"Subtest {test_method_name}, Case {i} ('{text_content}'):"):
+                    try:
+                        test_method(text_content, object_content)
+                    except AssertionError:
+                        # The subttest failed an assertion.
+                        raise
+                    except Exception as ex:
+                        error_string = self.format_error_string(ex)
+                        if (error_substring is None):
+                            self.fail(f"Unexpected error: '{error_string}'.")
+
+                        self.assertIn(error_substring, error_string, 'Error is not as expected.')
+
+                        continue
+
+                    if (error_substring is not None):
+                        self.fail(f"Did not get expected error: '{error_substring}'.")
+
+    def _subtest_loads_object(self, text_content, object_content):
+        actual_object = edq.util.json.loads_object(text_content, _TestConverter)
+        actual_text = edq.util.json.dumps(object_content)
+        double_conversion_text = edq.util.json.dumps(actual_object)
+
+        self.assertEqual(object_content, actual_object)
+        self.assertEqual(actual_text, double_conversion_text)
+
+    def _subtest_load_object_path(self, text_content, object_content):
+        temp_dir = edq.util.dirent.get_temp_dir(prefix = 'edq_test_json_object_path_')
+
+        path_text = os.path.join(temp_dir, 'test-text.json')
+        path_object = os.path.join(temp_dir, 'test-object.json')
+
+        edq.util.dirent.write_file(path_text, text_content)
+        text_load = edq.util.json.load_object_path(path_text, _TestConverter)
+
+        edq.util.json.dump_path(object_content, path_object)
+        object_load = edq.util.json.load_object_path(path_object, _TestConverter)
+
+        self.assertEqual(object_content, text_load)
+        self.assertEqual(object_load, text_load)
+
+class _TestConverter(edq.util.json.DictConverter):
+    def __init__(self, a: typing.Union[int, None] = None, b: typing.Union[str, None] = None, **kwargs) -> None:
+        self.a: typing.Union[int, None] = a
+        self.b: typing.Union[str, None] = b
+
+    def to_dict(self) -> typing.Dict[str, typing.Any]:
+        return vars(self)
+
+    @classmethod
+    def from_dict(cls, data: typing.Dict[str, typing.Any]) -> typing.Any:
+        return _TestConverter(**data)

{edq_utils-0.0.2 → edq_utils-0.0.3/edq_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edq-utils
-Version: 0.0.2
+Version: 0.0.3
 Summary: Common utilities used by EduLinq Python projects.
 Author-email: Eriq Augustine <eriq@edulinq.org>
 License: MIT License
@@ -37,6 +37,7 @@ License-File: LICENSE
 Requires-Dist: json5>=0.9.14
 Provides-Extra: dev
 Requires-Dist: mypy>=1.14.1; extra == "dev"
+Requires-Dist: pdoc>=14.7.0; extra == "dev"
 Requires-Dist: pylint; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: vermin; extra == "dev"

{edq_utils-0.0.2 → edq_utils-0.0.3}/edq_utils.egg-info/SOURCES.txt

@@ -4,6 +4,8 @@ pyproject.toml
 requirements-dev.txt
 requirements.txt
 edq/__init__.py
+edq/py.typed
+edq/testing/__init__.py
 edq/testing/run.py
 edq/testing/unittest.py
 edq/util/__init__.py

{edq_utils-0.0.2 → edq_utils-0.0.3}/edq_utils.egg-info/requires.txt

@@ -2,6 +2,7 @@ json5>=0.9.14
 
 [dev]
 mypy>=1.14.1
+pdoc>=14.7.0
 pylint
 twine
 vermin

{edq_utils-0.0.2 → edq_utils-0.0.3}/requirements-dev.txt

@@ -1,4 +1,5 @@
 mypy>=1.14.1
+pdoc>=14.7.0
 pylint
 twine
 vermin

edq_utils-0.0.2/edq/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.0.2'

edq_utils-0.0.2/edq/util/json.py

@@ -1,80 +0,0 @@
-"""
-This file standardizes how we write and read JSON.
-Specifically, we try to be flexible when reading (using JSON5),
-and strict when writing (using vanilla JSON).
-"""
-
-import json
-import typing
-
-import json5
-
-import edq.util.dirent
-
-def load(file_obj: typing.TextIO, strict: bool = False, **kwargs) -> typing.Dict[str, typing.Any]:
-    """
-    Load a file object/handler as JSON.
-    If strict is set, then use standard Python JSON,
-    otherwise use JSON5.
-    """
-
-    if (strict):
-        return json.load(file_obj, **kwargs)
-
-    return json5.load(file_obj, **kwargs)
-
-def loads(text: str, strict: bool = False, **kwargs) -> typing.Dict[str, typing.Any]:
-    """
-    Load a string as JSON.
-    If strict is set, then use standard Python JSON,
-    otherwise use JSON5.
-    """
-
-    if (strict):
-        return json.loads(text, **kwargs)
-
-    return json5.loads(text, **kwargs)
-
-def load_path(
-        path: str,
-        strict: bool = False,
-        encoding: str = edq.util.dirent.DEFAULT_ENCODING,
-        **kwargs) -> typing.Dict[str, typing.Any]:
-    """
-    Load a file path as JSON.
-    If strict is set, then use standard Python JSON,
-    otherwise use JSON5.
-    """
-
-    try:
-        with open(path, 'r', encoding = encoding) as file:
-            return load(file, strict = strict, **kwargs)
-    except Exception as ex:
-        raise ValueError(f"Failed to read JSON file '{path}'.") from ex
-
-def dump(
-        data: typing.Any,
-        file_obj: typing.TextIO,
-        sort_keys: bool = True,
-        **kwargs) -> None:
-    """ Dump an object as a JSON file object. """
-
-    json.dump(data, file_obj, sort_keys = sort_keys, **kwargs)
-
-def dumps(
-        data: typing.Any,
-        sort_keys: bool = True,
-        **kwargs) -> str:
-    """ Dump an object as a JSON string. """
-
-    return json.dumps(data, sort_keys = sort_keys, **kwargs)
-
-def dump_path(
-        data: typing.Any,
-        path: str,
-        encoding: str = edq.util.dirent.DEFAULT_ENCODING,
-        **kwargs) -> None:
-    """ Dump an object as a JSON file. """
-
-    with open(path, 'w', encoding = encoding) as file:
-        dump(data, file, **kwargs)