rf: Use acres data loader uniformly

Author: effigies

.pre-commit-config.yaml

@@ -72,6 +72,7 @@ repos:
       - id: mypy
         # Sync with project.optional-dependencies.typing
         additional_dependencies:
+          - acres
           - click
           - markdown-it-py
           - importlib_resources

tools/schemacode/pyproject.toml

@@ -11,6 +11,7 @@ license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [
+    "acres",
     "click",
     "pyyaml",
     "jsonschema",

tools/schemacode/src/bidsschematools/__init__.py

@@ -13,15 +13,15 @@
 
 
 def __getattr__(attr):
-    from .data import load_resource
+    from .data import load
 
     if attr == "__version__":
         global __version__
-        __version__ = load_resource("schema/SCHEMA_VERSION").read_text().strip()
+        __version__ = load.readable("schema/SCHEMA_VERSION").read_text().strip()
         return __version__
     elif attr == "__bids_version__":
         global __bids_version__
-        __bids_version__ = load_resource("schema/BIDS_VERSION").read_text().strip()
+        __bids_version__ = load.readable("schema/BIDS_VERSION").read_text().strip()
         return __bids_version__
 
     raise AttributeError(f"module {__spec__.name!r} has no attribute {attr!r}")

tools/schemacode/src/bidsschematools/__main__.py

@@ -7,7 +7,6 @@
 
 import click
 
-from .data import load_resource
 from .rules import regexify_filename_rules
 from .schema import export_schema, load_schema
 from .utils import configure_logger, get_logger
@@ -48,7 +47,9 @@ def export(ctx, schema, output):
 @click.pass_context
 def export_metaschema(ctx, output):
     """Export BIDS schema to JSON document"""
-    metaschema = load_resource("metaschema.json").read_text()
+    from .data import load
+
+    metaschema = load.readable("metaschema.json").read_text()
     if output == "-":
         print(metaschema, end="")
     else:

tools/schemacode/src/bidsschematools/conftest.py

@@ -2,9 +2,12 @@
 import tempfile
 from pathlib import Path
 from subprocess import run
+from typing import Generator
 
 import pytest
 
+from . import data
+
 lgr = logging.getLogger()
 
 # This selects a subset of the bids-examples collection to run the test suite on.
@@ -90,12 +93,10 @@ def fixture(tests_data_dir):
 
 
 @pytest.fixture(scope="session")
-def schema_dir():
+def schema_dir() -> Generator[str, None, None]:
     """Path to the schema housed in the bids-specification repo."""
-    from bidsschematools import utils
-
-    bids_schema = utils.get_bundled_schema_path()
-    return bids_schema
+    with data.load.as_path("schema") as schema_path:
+        yield str(schema_path)
 
 
 @pytest.fixture(scope="session")

tools/schemacode/src/bidsschematools/data/__init__.py

@@ -1,91 +1,14 @@
 """Module containing data files, including the schema source files
 
-.. autofunction:: load_resource
-"""
-
-import atexit
-import os
-from contextlib import ExitStack
-from functools import cache, cached_property
-from importlib.resources import as_file, files
-from pathlib import Path
-from types import ModuleType
-from typing import Union
-
-__all__ = ["load_resource"]
-
-
-class Loader:
-    """A loader for package files relative to a module
-
-    This class wraps :mod:`importlib.resources` to provide a getter
-    function with an interpreter-lifetime scope. For typical packages
-    it simply passes through filesystem paths as :class:`~pathlib.Path`
-    objects. For zipped distributions, it will unpack the files into
-    a temporary directory that is cleaned up on interpreter exit.
-
-    This loader accepts a fully-qualified module name or a module
-    object.
-
-    Expected usage::
-
-        '''Data package
+.. autofunction:: load
 
-        .. autofunction:: load_data
-        '''
+.. automethod:: load.readable
 
-        from bidsschematools.data import Loader
+.. automethod:: load.as_path
 
-        load_data = Loader(__package__)
-
-    :class:`~Loader` objects implement the :func:`callable` interface
-    and generate a docstring, and are intended to be treated and documented
-    as functions.
-    """
-
-    def __init__(self, anchor: Union[str, ModuleType]):
-        self._anchor = anchor
-        self.files = files(anchor)
-        self.exit_stack = ExitStack()
-        atexit.register(self.exit_stack.close)
-        # Allow class to have a different docstring from instances
-        self.__doc__ = self._doc
-
-    @cached_property
-    def _doc(self):
-        """Construct docstring for instances
-
-        Lists the public top-level paths inside the location, where
-        non-public means has a `.` or `_` prefix or is a 'tests'
-        directory.
-        """
-        top_level = sorted(
-            os.path.relpath(p, self.files) + "/"[: p.is_dir()]
-            for p in self.files.iterdir()
-            if p.name[0] not in (".", "_") and p.name != "tests"
-        )
-        doclines = [
-            f"Load package files relative to ``{self._anchor}``.",
-            "",
-            "This package contains the following (top-level) files/directories:",
-            "",
-            *(f"* ``{path}``" for path in top_level),
-        ]
-
-        return "\n".join(doclines)
-
-    @cache
-    def __call__(self, *segments) -> Path:
-        """Ensure data is available as a :class:`~pathlib.Path`.
-
-        Any temporary files that are created remain available throughout
-        the duration of the program, and are deleted when Python exits.
-
-        Results are cached so that multiple calls do not unpack the same
-        data multiple times, but the cache is sensitive to the specific
-        argument(s) passed.
-        """
-        return self.exit_stack.enter_context(as_file(self.files.joinpath(*segments)))
+.. automethod:: load.cached
+"""
 
+from acres import Loader
 
-load_resource = Loader(__package__)
+load = Loader(__spec__.name)

tools/schemacode/src/bidsschematools/schema.py

@@ -10,8 +10,7 @@
 
 from jsonschema import ValidationError, validate
 
-from . import __bids_version__, __version__, utils
-from .data import load_resource
+from . import __bids_version__, __version__, data, utils
 from .types import Namespace
 
 lgr = utils.get_logger()
@@ -204,7 +203,7 @@ def load_schema(schema_path=None):
     This function is cached, so it will only be called once per schema path.
     """
     if schema_path is None:
-        schema_path = utils.get_bundled_schema_path()
+        schema_path = data.load.readable("schema")
         lgr.info("No schema path specified, defaulting to the bundled schema, `%s`.", schema_path)
     schema = Namespace.from_directory(schema_path)
     if not schema.objects:
@@ -293,7 +292,9 @@ def filter_schema(schema, **kwargs):
 
 def validate_schema(schema: Namespace):
     """Validate a schema against the BIDS metaschema."""
-    metaschema = json.loads(load_resource("metaschema.json").read_text())
+    from .data import load
+
+    metaschema = json.loads(load.readable("metaschema.json").read_text())
 
     # validate is put in this try/except clause because the error is sometimes too long to
     # print in the terminal

tools/schemacode/src/bidsschematools/tests/data/__init__.py

@@ -1,10 +1,16 @@
 """Test data module
 
 .. autofunction:: load_test_data
+
+.. automethod:: load_test_data.readable
+
+.. automethod:: load_test_data.as_path
+
+.. automethod:: load_test_data.cached
 """
 
-from ...data import Loader
+from acres import Loader
 
 __all__ = ("load_test_data",)
 
-load_test_data = Loader(__package__)
+load_test_data = Loader(__spec__.name)

tools/schemacode/src/bidsschematools/tests/test_schema.py

@@ -8,12 +8,12 @@
 
 from bidsschematools import __bids_version__, schema, types
 
-from ..data import load_resource
+from ..data import load
 
 
 def test__get_bids_version(tmp_path):
     # Is the version being read in correctly?
-    schema_path = str(load_resource("schema"))
+    schema_path = str(load("schema"))
     bids_version = schema._get_bids_version(schema_path)
     assert bids_version == __bids_version__
 

tools/schemacode/src/bidsschematools/tests/test_validator.py

@@ -6,7 +6,7 @@
 from bidsschematools.conftest import BIDS_ERROR_SELECTION, BIDS_SELECTION
 from bidsschematools.validator import select_schema_path, validate_bids
 
-from ..data import load_resource
+from ..data import load
 from .data import load_test_data
 
 
@@ -155,9 +155,8 @@ def test_validate_bids(bids_examples, tmp_path):
     assert len(result["path_tracking"]) == 0
 
     # Is the schema version recorded correctly?
-    schema_path = load_resource("schema")
-    with open(os.path.join(schema_path, "BIDS_VERSION")) as f:
-        expected_version = f.readline().rstrip()
+    schema_path = load.readable("schema")
+    expected_version = schema_path.joinpath("BIDS_VERSION").read_text().rstrip()
     assert result["bids_version"] == expected_version
 
 
@@ -279,9 +278,7 @@ def test_bids_schema_versioncheck(monkeypatch):
     """Test incompatible version."""
     import bidsschematools as bst
 
-    from ..utils import get_bundled_schema_path
-
-    schema_dir = get_bundled_schema_path()
+    schema_dir = bst.data.load.readable("schema")
     assert bst.validator._bids_schema_versioncheck(schema_dir)
     monkeypatch.setattr(bst, "__version__", "99.99.99")
     assert not bst.validator._bids_schema_versioncheck(schema_dir)