junifer 0.0.5__py3-none-any.whl → 0.0.5.dev24__py3-none-any.whl

junifer/markers/__init__.py

@@ -1,4 +1,4 @@
-"""Markers for feature extraction."""
+"""Provide imports for markers sub-package."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Leonard Sasse <l.sasse@fz-juelich.de>
@@ -23,25 +23,3 @@ from .temporal_snr import (
     TemporalSNRParcels,
     TemporalSNRSpheres,
 )
-from .brainprint import BrainPrint
-
-
-__all__ = [
-    "BaseMarker",
-    "MarkerCollection",
-    "RSSETSMarker",
-    "ParcelAggregation",
-    "SphereAggregation",
-    "FunctionalConnectivityParcels",
-    "FunctionalConnectivitySpheres",
-    "CrossParcellationFC",
-    "EdgeCentricFCParcels",
-    "EdgeCentricFCSpheres",
-    "ReHoParcels",
-    "ReHoSpheres",
-    "ALFFParcels",
-    "ALFFSpheres",
-    "TemporalSNRParcels",
-    "TemporalSNRSpheres",
-    "BrainPrint",
-]

junifer/markers/base.py

@@ -5,7 +5,6 @@
 # License: AGPL
 
 from abc import ABC, abstractmethod
-from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from ..pipeline import PipelineStepMixin, UpdateMetaMixin
@@ -16,28 +15,20 @@ if TYPE_CHECKING:
     from junifer.storage import BaseFeatureStorage
 
 
-__all__ = ["BaseMarker"]
-
-
 class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
     """Abstract base class for all markers.
 
-    For every interface that is required, one needs to provide a concrete
-    implementation of this abstract class.
-
     Parameters
     ----------
-    on : str or list of str or None, optional
-        The data type to apply the marker on. If None,
-        will work on all available data types (default None).
+    on : str or list of str
+        The kind of data to apply the marker to. By default, will work on all
+        available data.
     name : str, optional
-        The name of the marker. If None, will use the class name as the
+        The name of the marker. By default, it will use the class name as the
         name of the marker (default None).
 
     Raises
     ------
-    AttributeError
-        If the marker does not have `_MARKER_INOUT_MAPPINGS` attribute.
     ValueError
         If required input data type(s) is(are) not found.
 
@@ -48,12 +39,6 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         on: Optional[Union[List[str], str]] = None,
         name: Optional[str] = None,
     ) -> None:
-        # Check for missing mapping attribute
-        if not hasattr(self, "_MARKER_INOUT_MAPPINGS"):
-            raise_error(
-                msg=("Missing `_MARKER_INOUT_MAPPINGS` for the marker"),
-                klass=AttributeError,
-            )
         # Use all data types if not provided
         if on is None:
             on = self.get_valid_inputs()
@@ -97,6 +82,7 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
             )
         return [x for x in self._on if x in input]
 
+    @abstractmethod
     def get_valid_inputs(self) -> List[str]:
         """Get valid data types for input.
 
@@ -106,25 +92,30 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
             The list of data types that can be used as input for this marker.
 
         """
-        return list(self._MARKER_INOUT_MAPPINGS.keys())
+        raise_error(
+            msg="Concrete classes need to implement get_valid_inputs().",
+            klass=NotImplementedError,
+        )
 
-    def get_output_type(self, input_type: str, output_feature: str) -> str:
+    @abstractmethod
+    def get_output_type(self, input_type: str) -> str:
         """Get output type.
 
         Parameters
         ----------
         input_type : str
             The data type input to the marker.
-        output_feature : str
-            The feature output of the marker.
 
         Returns
         -------
         str
-            The storage type output of the marker.
+            The storage type output by the marker.
 
         """
-        return self._MARKER_INOUT_MAPPINGS[input_type][output_feature]
+        raise_error(
+            msg="Concrete classes need to implement get_output_type().",
+            klass=NotImplementedError,
+        )
 
     @abstractmethod
     def compute(self, input: Dict, extra_input: Optional[Dict] = None) -> Dict:
@@ -157,7 +148,6 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
     def store(
         self,
         type_: str,
-        feature: str,
         out: Dict[str, Any],
         storage: "BaseFeatureStorage",
     ) -> None:
@@ -167,15 +157,13 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         ----------
         type_ : str
             The data type to store.
-        feature : str
-            The feature to store.
         out : dict
             The computed result as a dictionary to store.
         storage : storage-like
             The storage class, for example, SQLiteFeatureStorage.
 
         """
-        output_type_ = self.get_output_type(type_, feature)
+        output_type_ = self.get_output_type(type_)
         logger.debug(f"Storing {output_type_} in {storage}")
         storage.store(kind=output_type_, **out)
 
@@ -204,50 +192,22 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         for type_ in self._on:
             if type_ in input.keys():
                 logger.info(f"Computing {type_}")
-                # Get data dict for data type
                 t_input = input[type_]
-                # Pass the other data types as extra input, removing
-                # the current type
                 extra_input = input.copy()
                 extra_input.pop(type_)
-                logger.debug(
-                    f"Extra data type for feature extraction: "
-                    f"{extra_input.keys()}"
-                )
-                # Copy metadata
                 t_meta = t_input["meta"].copy()
                 t_meta["type"] = type_
-                # Compute marker
+
                 t_out = self.compute(input=t_input, extra_input=extra_input)
-                # Initialize empty dictionary if no storage object is provided
-                if storage is None:
-                    out[type_] = {}
-                # Store individual features
-                for feature_name, feature_data in t_out.items():
-                    # Make deep copy of the feature data for manipulation
-                    feature_data_copy = deepcopy(feature_data)
-                    # Make deep copy of metadata and add to feature data
-                    feature_data_copy["meta"] = deepcopy(t_meta)
-                    # Update metadata for the feature,
-                    # feature data is not manipulated, only meta
-                    self.update_meta(feature_data_copy, "marker")
-                    # Update marker feature's metadata name
-                    feature_data_copy["meta"]["marker"][
-                        "name"
-                    ] += f"_{feature_name}"
-
-                    if storage is not None:
-                        logger.info(f"Storing in {storage}")
-                        self.store(
-                            type_=type_,
-                            feature=feature_name,
-                            out=feature_data_copy,
-                            storage=storage,
-                        )
-                    else:
-                        logger.info(
-                            "No storage specified, returning dictionary"
-                        )
-                        out[type_][feature_name] = feature_data_copy
+                t_out["meta"] = t_meta
+
+                self.update_meta(t_out, "marker")
+
+                if storage is not None:
+                    logger.info(f"Storing in {storage}")
+                    self.store(type_=type_, out=t_out, storage=storage)
+                else:
+                    logger.info("No storage specified, returning dictionary")
+                    out[type_] = t_out
 
         return out

junifer/markers/collection.py

@@ -19,9 +19,6 @@ if TYPE_CHECKING:
     from junifer.datagrabber import BaseDataGrabber
 
 
-__all__ = ["MarkerCollection"]
-
-
 class MarkerCollection:
     """Class for marker collection.
 
@@ -139,14 +136,9 @@ class MarkerCollection:
                     "Validating Preprocessor: "
                     f"{preprocessor.__class__.__name__}"
                 )
-                # Copy existing data types
-                old_t_data = t_data.copy()
-                logger.info(f"Preprocessor input type: {t_data}")
                 # Validate preprocessor
-                new_t_data = preprocessor.validate(old_t_data)
-                # Set new data types
-                t_data = list(set(old_t_data) | set(new_t_data))
-                logger.info(f"Preprocessor output type: {t_data}")
+                t_data = preprocessor.validate(t_data)
+                logger.info(f"Preprocess output type: {t_data}")
 
         for marker in self._markers:
             logger.info(f"Validating Marker: {marker.name}")

junifer/markers/complexity/__init__.py

@@ -25,13 +25,3 @@ else:
     from .weighted_perm_entropy import WeightedPermEntropy
     from .sample_entropy import SampleEntropy
     from .multiscale_entropy_auc import MultiscaleEntropyAUC
-
-    __all__ = [
-        "HurstExponent",
-        "RangeEntropy",
-        "RangeEntropyAUC",
-        "PermEntropy",
-        "WeightedPermEntropy",
-        "SampleEntropy",
-        "MultiscaleEntropyAUC",
-    ]

junifer/markers/complexity/complexity_base.py

@@ -24,9 +24,6 @@ if TYPE_CHECKING:
     import numpy as np
 
 
-__all__ = ["ComplexityBase"]
-
-
 class ComplexityBase(BaseMarker):
     """Base class for complexity computation.
 
@@ -53,12 +50,6 @@ class ComplexityBase(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "neurokit2"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "BOLD": {
-            "complexity": "vector",
-        },
-    }
-
     def __init__(
         self,
         parcellation: Union[str, List[str]],
@@ -84,6 +75,33 @@ class ComplexityBase(BaseMarker):
             klass=NotImplementedError,
         )
 
+    def get_valid_inputs(self) -> List[str]:
+        """Get valid data types for input.
+
+        Returns
+        -------
+        list of str
+            The list of data types that can be used as input for this marker.
+
+        """
+        return ["BOLD"]
+
+    def get_output_type(self, input_type: str) -> str:
+        """Get output type.
+
+        Parameters
+        ----------
+        input_type : str
+            The data type input to the marker.
+
+        Returns
+        -------
+        str
+            The storage type output by the marker.
+
+        """
+        return "vector"
+
     def compute(
         self,
         input: Dict[str, Any],
@@ -103,30 +121,29 @@ class ComplexityBase(BaseMarker):
         Returns
         -------
         dict
-            The computed result as dictionary. This will be either returned
-            to the user or stored in the storage by calling the store method
-            with this as a parameter. The dictionary has the following keys:
+            The computed result as dictionary. The following keys will be
+            included in the dictionary:
 
-           *  ``complexity`` : dictionary with the following keys:
-
-                - ``data`` : ROI-wise complexity measures as ``numpy.ndarray``
-                - ``col_names`` : ROI labels as list of str
+           * ``data`` : ROI-wise complexity measures as ``numpy.ndarray``
+           * ``col_names`` : ROI labels for the complexity measures as list
 
         """
-        # Extract the 2D time series using ParcelAggregation
+        # Initialize a ParcelAggregation
         parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(input=input, extra_input=extra_input)
+        )
+        # Extract the 2D time series using parcel aggregation
+        parcel_aggregation_map = parcel_aggregation.compute(
+            input=input, extra_input=extra_input
+        )
+
         # Compute complexity measure
-        return {
-            "complexity": {
-                "data": self.compute_complexity(
-                    parcel_aggregation["aggregation"]["data"]
-                ),
-                "col_names": parcel_aggregation["aggregation"]["col_names"],
-            }
-        }
+        parcel_aggregation_map["data"] = self.compute_complexity(
+            parcel_aggregation_map["data"]
+        )
+
+        return parcel_aggregation_map

junifer/markers/complexity/hurst_exponent.py

@@ -14,9 +14,6 @@ from ...utils import logger, warn_with_log
 from .complexity_base import ComplexityBase
 
 
-__all__ = ["HurstExponent"]
-
-
 @register_marker
 class HurstExponent(ComplexityBase):
     """Class for Hurst exponent of a time series.

junifer/markers/complexity/multiscale_entropy_auc.py

@@ -14,9 +14,6 @@ from ...utils import logger, warn_with_log
 from .complexity_base import ComplexityBase
 
 
-__all__ = ["MultiscaleEntropyAUC"]
-
-
 @register_marker
 class MultiscaleEntropyAUC(ComplexityBase):
     """Class for AUC of multiscale entropy of a time series.

junifer/markers/complexity/perm_entropy.py

@@ -14,9 +14,6 @@ from ...utils import logger, warn_with_log
 from .complexity_base import ComplexityBase
 
 
-__all__ = ["PermEntropy"]
-
-
 @register_marker
 class PermEntropy(ComplexityBase):
     """Class for permutation entropy of a time series.

junifer/markers/complexity/range_entropy.py

@@ -14,9 +14,6 @@ from ...utils import logger, warn_with_log
 from .complexity_base import ComplexityBase
 
 
-__all__ = ["RangeEntropy"]
-
-
 @register_marker
 class RangeEntropy(ComplexityBase):
     """Class for range entropy of a time series.

junifer/markers/complexity/range_entropy_auc.py

@@ -14,9 +14,6 @@ from ...utils import logger, warn_with_log
 from .complexity_base import ComplexityBase
 
 
-__all__ = ["RangeEntropyAUC"]
-
-
 @register_marker
 class RangeEntropyAUC(ComplexityBase):
     """Class for AUC of range entropy values of a time series over r = 0 to 1.

junifer/markers/complexity/sample_entropy.py

@@ -14,9 +14,6 @@ from ...utils import logger, warn_with_log
 from .complexity_base import ComplexityBase
 
 
-__all__ = ["SampleEntropy"]
-
-
 @register_marker
 class SampleEntropy(ComplexityBase):
     """Class for sample entropy of a time series.

junifer/markers/complexity/tests/test_hurst_exponent.py

@@ -14,7 +14,6 @@ pytest.importorskip("neurokit2")
 
 from junifer.datareader import DefaultDataReader  # noqa: E402
 from junifer.markers.complexity import HurstExponent  # noqa: E402
-from junifer.pipeline.utils import _check_ants  # noqa: E402
 from junifer.storage import SQLiteFeatureStorage  # noqa: E402
 from junifer.testing.datagrabbers import (  # noqa: E402
     SPMAuditoryTestingDataGrabber,
@@ -25,9 +24,6 @@ from junifer.testing.datagrabbers import (  # noqa: E402
 PARCELLATION = "Schaefer100x17"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_compute() -> None:
     """Test HurstExponent compute()."""
     with SPMAuditoryTestingDataGrabber() as dg:
@@ -40,19 +36,15 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        assert feature_map["BOLD"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test HurstExponent get_output_type()."""
-    assert "vector" == HurstExponent(
-        parcellation=PARCELLATION
-    ).get_output_type(input_type="BOLD", output_feature="complexity")
+    marker = HurstExponent(parcellation=PARCELLATION)
+    assert marker.get_output_type("BOLD") == "vector"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_store(tmp_path: Path) -> None:
     """Test HurstExponent store().
 

junifer/markers/complexity/tests/test_multiscale_entropy_auc.py

@@ -13,7 +13,6 @@ pytest.importorskip("neurokit2")
 
 from junifer.datareader import DefaultDataReader  # noqa: E402
 from junifer.markers.complexity import MultiscaleEntropyAUC  # noqa: E402
-from junifer.pipeline.utils import _check_ants  # noqa: E402
 from junifer.storage import SQLiteFeatureStorage  # noqa: E402
 from junifer.testing.datagrabbers import (  # noqa: E402
     SPMAuditoryTestingDataGrabber,
@@ -24,9 +23,6 @@ from junifer.testing.datagrabbers import (  # noqa: E402
 PARCELLATION = "Schaefer100x17"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_compute() -> None:
     """Test MultiscaleEntropyAUC compute()."""
     with SPMAuditoryTestingDataGrabber() as dg:
@@ -39,19 +35,15 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        assert feature_map["BOLD"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test MultiscaleEntropyAUC get_output_type()."""
-    assert "vector" == MultiscaleEntropyAUC(
-        parcellation=PARCELLATION
-    ).get_output_type(input_type="BOLD", output_feature="complexity")
+    marker = MultiscaleEntropyAUC(parcellation=PARCELLATION)
+    assert marker.get_output_type("BOLD") == "vector"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_store(tmp_path: Path) -> None:
     """Test MultiscaleEntropyAUC store().
 

junifer/markers/complexity/tests/test_perm_entropy.py

@@ -13,7 +13,6 @@ pytest.importorskip("neurokit2")
 
 from junifer.datareader import DefaultDataReader  # noqa: E402
 from junifer.markers.complexity import PermEntropy  # noqa: E402
-from junifer.pipeline.utils import _check_ants  # noqa: E402
 from junifer.storage import SQLiteFeatureStorage  # noqa: E402
 from junifer.testing.datagrabbers import (  # noqa: E402
     SPMAuditoryTestingDataGrabber,
@@ -24,9 +23,6 @@ from junifer.testing.datagrabbers import (  # noqa: E402
 PARCELLATION = "Schaefer100x17"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_compute() -> None:
     """Test PermEntropy compute()."""
     with SPMAuditoryTestingDataGrabber() as dg:
@@ -39,19 +35,15 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        assert feature_map["BOLD"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test PermEntropy get_output_type()."""
-    assert "vector" == PermEntropy(parcellation=PARCELLATION).get_output_type(
-        input_type="BOLD", output_feature="complexity"
-    )
+    marker = PermEntropy(parcellation=PARCELLATION)
+    assert marker.get_output_type("BOLD") == "vector"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_store(tmp_path: Path) -> None:
     """Test PermEntropy store().
 

junifer/markers/complexity/tests/test_range_entropy.py

@@ -14,7 +14,6 @@ pytest.importorskip("neurokit2")
 
 from junifer.datareader import DefaultDataReader  # noqa: E402
 from junifer.markers.complexity import RangeEntropy  # noqa: E402
-from junifer.pipeline.utils import _check_ants  # noqa: E402
 from junifer.storage import SQLiteFeatureStorage  # noqa: E402
 from junifer.testing.datagrabbers import (  # noqa: E402
     SPMAuditoryTestingDataGrabber,
@@ -25,9 +24,6 @@ from junifer.testing.datagrabbers import (  # noqa: E402
 PARCELLATION = "Schaefer100x17"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_compute() -> None:
     """Test RangeEntropy compute()."""
     with SPMAuditoryTestingDataGrabber() as dg:
@@ -40,19 +36,15 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        assert feature_map["BOLD"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test RangeEntropy get_output_type()."""
-    assert "vector" == RangeEntropy(parcellation=PARCELLATION).get_output_type(
-        input_type="BOLD", output_feature="complexity"
-    )
+    marker = RangeEntropy(parcellation=PARCELLATION)
+    assert marker.get_output_type("BOLD") == "vector"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_store(tmp_path: Path) -> None:
     """Test RangeEntropy store().
 

junifer/markers/complexity/tests/test_range_entropy_auc.py

@@ -14,7 +14,6 @@ pytest.importorskip("neurokit2")
 
 from junifer.datareader import DefaultDataReader  # noqa: E402
 from junifer.markers.complexity import RangeEntropyAUC  # noqa: E402
-from junifer.pipeline.utils import _check_ants  # noqa: E402
 from junifer.storage import SQLiteFeatureStorage  # noqa: E402
 from junifer.testing.datagrabbers import (  # noqa: E402
     SPMAuditoryTestingDataGrabber,
@@ -25,9 +24,6 @@ from junifer.testing.datagrabbers import (  # noqa: E402
 PARCELLATION = "Schaefer100x17"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_compute() -> None:
     """Test RangeEntropyAUC compute()."""
     with SPMAuditoryTestingDataGrabber() as dg:
@@ -40,19 +36,15 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        assert feature_map["BOLD"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test RangeEntropyAUC get_output_type()."""
-    assert "vector" == RangeEntropyAUC(
-        parcellation=PARCELLATION
-    ).get_output_type(input_type="BOLD", output_feature="complexity")
+    marker = RangeEntropyAUC(parcellation=PARCELLATION)
+    assert marker.get_output_type("BOLD") == "vector"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_store(tmp_path: Path) -> None:
     """Test RangeEntropyAUC store().
 

junifer/markers/complexity/tests/test_sample_entropy.py

@@ -13,7 +13,6 @@ pytest.importorskip("neurokit2")
 
 from junifer.datareader import DefaultDataReader  # noqa: E402
 from junifer.markers.complexity import SampleEntropy  # noqa: E402
-from junifer.pipeline.utils import _check_ants  # noqa: E402
 from junifer.storage import SQLiteFeatureStorage  # noqa: E402
 from junifer.testing.datagrabbers import (  # noqa: E402
     SPMAuditoryTestingDataGrabber,
@@ -24,9 +23,6 @@ from junifer.testing.datagrabbers import (  # noqa: E402
 PARCELLATION = "Schaefer100x17"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_compute() -> None:
     """Test SampleEntropy compute()."""
     with SPMAuditoryTestingDataGrabber() as dg:
@@ -39,19 +35,15 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        assert feature_map["BOLD"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test SampleEntropy get_output_type()."""
-    assert "vector" == SampleEntropy(
-        parcellation=PARCELLATION
-    ).get_output_type(input_type="BOLD", output_feature="complexity")
+    marker = SampleEntropy(parcellation=PARCELLATION)
+    assert marker.get_output_type("BOLD") == "vector"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 def test_store(tmp_path: Path) -> None:
     """Test SampleEntropy store().