Make TOML parsing always available

This makes the dependency on `tomli` for older Pythons non-optional,
ensuring that `.toml` files are always supported.

Most of the code removals have to do with testing and supporting the
state with no TOML parser available. There's no longer an `ENABLED`
bool control, and tests no longer try to use that to check the
behavior in the absence of a parser.

Author: sirosen

CHANGELOG.rst

@@ -14,6 +14,10 @@ Unreleased
 - Support the use of `orjson` for faster JSON parsing when it is installed.
   This makes it an optional parser which is preferred over the default
   `json` module when it is available.
+- TOML parsing is now always available (rather than an optional parser).
+  This change adds a dependency on `tomli` on older Python versions, ensuring
+  that TOML formatted data is always supported. Users should no longer need
+  to install `tomli` manually in order to use TOML files.
 
 0.27.4
 ------

docs/optional_parsers.rst

@@ -28,6 +28,12 @@ For example,
 TOML
 ----
 
+.. note::
+
+    In the latest versions of ``check-jsonschema``, the TOML parser is no
+    longer optional. It is always available, using ``tomli`` or ``tomllib``
+    depending on the environment.
+
 - Supported for Instances: yes
 - Supported for Schemas: no
 

setup.cfg

@@ -19,6 +19,7 @@ python_requires = >=3.8
 # reference for dependency spec: https://www.python.org/dev/peps/pep-0508/
 install_requires =
     importlib-resources>=1.4.0;python_version<"3.9"
+    tomli>=2.0;python_version<"3.11"
     ruamel.yaml==0.18.5
     jsonschema>=4.18.0,<5.0
     regress>=0.4.0

src/check_jsonschema/_testing.py

@@ -9,22 +9,22 @@
 from ..identify_filetype import path_to_type
 from . import json5, json_, toml, yaml
 
-_PARSER_ERRORS: set[type[Exception]] = {json_.JSONDecodeError, yaml.ParseError}
+_PARSER_ERRORS: set[type[Exception]] = {
+    json_.JSONDecodeError,
+    yaml.ParseError,
+    toml.ParseError,
+}
 DEFAULT_LOAD_FUNC_BY_TAG: dict[str, t.Callable[[t.IO[bytes]], t.Any]] = {
     "json": json_.load,
+    "toml": toml.load,
 }
-SUPPORTED_FILE_FORMATS = ["json", "yaml"]
+SUPPORTED_FILE_FORMATS = ["json", "toml", "yaml"]
 if json5.ENABLED:
     SUPPORTED_FILE_FORMATS.append("json5")
     DEFAULT_LOAD_FUNC_BY_TAG["json5"] = json5.load
     _PARSER_ERRORS.add(json5.ParseError)
-if toml.ENABLED:
-    SUPPORTED_FILE_FORMATS.append("toml")
-    DEFAULT_LOAD_FUNC_BY_TAG["toml"] = toml.load
-    _PARSER_ERRORS.add(toml.ParseError)
 MISSING_SUPPORT_MESSAGES: dict[str, str] = {
     "json5": json5.MISSING_SUPPORT_MESSAGE,
-    "toml": toml.MISSING_SUPPORT_MESSAGE,
 }
 LOADING_FAILURE_ERROR_TYPES: tuple[type[Exception], ...] = tuple(_PARSER_ERRORS)
 

src/check_jsonschema/parsers/__init__.py

@@ -4,17 +4,9 @@
 import sys
 import typing as t
 
-from check_jsonschema._testing import FORCE_TOML_DISABLED
-
 if sys.version_info < (3, 11):
-    try:
-        import tomli as toml_implementation
-
-        has_toml = True
-    except ImportError:  # pragma: no cover
-        has_toml = False
+    import tomli as toml_implementation
 else:
-    has_toml = True
     import tomllib as toml_implementation
 
 
@@ -55,30 +47,9 @@ def _normalize(data: t.Any) -> t.Any:
         return data
 
 
-# present a bool for detecting that it's enabled
-ENABLED = has_toml and not FORCE_TOML_DISABLED
-
-
-if ENABLED:
-    ParseError: type[Exception] = toml_implementation.TOMLDecodeError
-
-    def load(stream: t.IO[bytes]) -> t.Any:
-        data = toml_implementation.load(stream)
-        return _normalize(data)
-
-else:
-    ParseError = ValueError
-
-    def load(stream: t.IO[bytes]) -> t.Any:
-        raise NotImplementedError
-
-
-MISSING_SUPPORT_MESSAGE = """
-check-jsonschema can only parse TOML files when a TOML parser is installed
+ParseError: type[Exception] = toml_implementation.TOMLDecodeError
 
-If you are running check-jsonschema as an installed python package, add support with
-    pip install tomli
 
-If you are running check-jsonschema as a pre-commit hook, set
-    additional_dependencies: ['tomli']
-"""
+def load(stream: t.IO[bytes]) -> t.Any:
+    data = toml_implementation.load(stream)
+    return _normalize(data)

src/check_jsonschema/parsers/toml.py

@@ -9,7 +9,6 @@
 import ruamel.yaml
 
 from check_jsonschema.parsers.json5 import ENABLED as JSON5_ENABLED
-from check_jsonschema.parsers.toml import ENABLED as TOML_ENABLED
 
 yaml = ruamel.yaml.YAML(typ="safe")
 
@@ -109,8 +108,6 @@ def test_explicit_positive_examples(case_name, run_line):
 def _check_file_format_skip(case_name):
     if case_name.endswith("json5") and not JSON5_ENABLED:
         pytest.skip("cannot check json5 support without json5 enabled")
-    if case_name.endswith("toml") and not TOML_ENABLED:
-        pytest.skip("cannot check toml support without toml enabled")
 
 
 @dataclasses.dataclass

tests/acceptance/test_example_files.py

@@ -3,7 +3,6 @@
 from check_jsonschema.instance_loader import InstanceLoader
 from check_jsonschema.parsers import BadFileTypeError, FailedFileLoadError
 from check_jsonschema.parsers.json5 import ENABLED as JSON5_ENABLED
-from check_jsonschema.parsers.toml import ENABLED as TOML_ENABLED
 
 
 # handy helper for opening multiple files for InstanceLoader
@@ -70,6 +69,23 @@ def test_instanceloader_yaml_data(tmp_path, filename, default_filetype, open_wid
     assert data == [(str(f), {"a": {"b": [1, 2], "c": "d"}})]
 
 
+@pytest.mark.parametrize(
+    "filename, default_filetype",
+    [
+        ("foo.toml", "notarealfiletype"),
+        ("foo.toml", "json"),
+        ("foo.toml", "yaml"),
+        ("foo", "toml"),
+    ],
+)
+def test_instanceloader_toml_data(tmp_path, filename, default_filetype, open_wide):
+    f = tmp_path / "foo.toml"
+    f.write_text('[foo]\nbar = "baz"\n')
+    loader = InstanceLoader(open_wide(f), default_filetype=default_filetype)
+    data = list(loader.iter_files())
+    assert data == [(str(f), {"foo": {"bar": "baz"}})]
+
+
 def test_instanceloader_unknown_type_nonjson_content(tmp_path, open_wide):
     f = tmp_path / "foo"  # no extension here
     f.write_text("a:b")  # non-json data (cannot be detected as JSON)
@@ -93,13 +109,6 @@ def test_instanceloader_unknown_type_nonjson_content(tmp_path, open_wide):
             {},
             "pip install json5",
         ),
-        (
-            TOML_ENABLED,
-            "toml",
-            '[foo]\nbar = "baz"\n',
-            {"foo": {"bar": "baz"}},
-            "pip install tomli",
-        ),
     ],
 )
 def test_instanceloader_optional_format_handling(
@@ -162,8 +171,6 @@ def test_instanceloader_invalid_data(
 ):
     if file_format == "json5" and not JSON5_ENABLED:
         pytest.skip("test requires 'json5' support")
-    if file_format == "toml" and not TOML_ENABLED:
-        pytest.skip("test requires 'toml' support")
 
     f = tmp_path / filename
     f.write_text(content)
@@ -211,8 +218,6 @@ def test_instanceloader_invalid_data_mixed_with_valid_data(tmp_path, open_wide):
 def test_instanceloader_mixed_filetypes(tmp_path, filetypes, open_wide):
     if not JSON5_ENABLED and "json5" in filetypes:
         pytest.skip("test requires json5")
-    if not TOML_ENABLED and "toml" in filetypes:
-        pytest.skip("test requires toml")
     files = {}
     file_order = []
     if "json" in filetypes:

tests/unit/test_instance_loader.py

@@ -2,10 +2,9 @@
 envlist =
     mypy
     cov_clean
-    py38-mindeps
+    py38-mindeps{,-format}
     py{312,311,310,39,38}
-    py310-{notoml,tomli-format}
-    py{38,312}-{json5,pyjson5}
+    py{38,312}-{json5,pyjson5}{,-format}
     py{38,312}-{disable_orjson}
     cov
 skip_missing_interpreters = true
@@ -26,10 +25,7 @@ deps =
     !disable_orjson: orjson
     json5: json5
     pyjson5: pyjson5
-    tomli: tomli
     format: jsonschema[format]
-set_env =
-    notoml: FORCE_TOML_DISABLED=1
 commands =
     coverage run -m pytest {posargs:--junitxml={envdir}/pytest.xml}