junifer 0.0.7.dev332__py3-none-any.whl → 0.0.8__py3-none-any.whl

junifer/markers/reho/tests/test_reho_parcels.py

@@ -7,19 +7,23 @@ import logging
 from pathlib import Path
 
 import pytest
-import scipy as sp
+from numpy.testing import assert_allclose
 
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
-from junifer.markers import ReHoParcels
+from junifer.markers import ReHoImpl, ReHoParcels
 from junifer.pipeline import WorkDirManager
-from junifer.pipeline.utils import _check_afni, _check_ants
-from junifer.storage import SQLiteFeatureStorage
+from junifer.pipeline.utils import _check_afni
+from junifer.storage import HDF5FeatureStorage
 from junifer.testing.datagrabbers import (
+    ADHDTestingDataGrabber,
     PartlyCloudyTestingDataGrabber,
-    SPMAuditoryTestingDataGrabber,
 )
 
 
+pytestmark = pytest.mark.external
+
+
 def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
     """Test ReHoParcels.
 
@@ -32,7 +36,7 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
     """
     with caplog.at_level(logging.DEBUG):
-        with PartlyCloudyTestingDataGrabber() as dg:
+        with PartlyCloudyTestingDataGrabber(n_timepoints=50) as dg:
             element_data = DefaultDataReader().fit_transform(dg["sub-01"])
             # Update workdir to current test's tmp_path
             WorkDirManager().workdir = tmp_path
@@ -40,11 +44,11 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Initialize marker
             marker = ReHoParcels(
                 parcellation="TianxS1x3TxMNInonlinear2009cAsym",
-                using="junifer",
+                using=ReHoImpl.junifer,
             )
             # Check correct output
             assert "vector" == marker.storage_type(
-                input_type="BOLD", output_feature="reho"
+                input_type=DataType.BOLD, output_feature="reho"
             )
 
             # Fit transform marker on data
@@ -70,7 +74,7 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Reset log capture
             caplog.clear()
             # Initialize storage
-            storage = SQLiteFeatureStorage(tmp_path / "reho_parcels.sqlite")
+            storage = HDF5FeatureStorage(uri=tmp_path / "reho_parcels.hdf5")
             # Fit transform marker on data with storage
             marker.fit_transform(
                 input=element_data,
@@ -80,29 +84,31 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             assert "Creating cache" not in caplog.text
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_ReHoParcels_comparison(tmp_path: Path) -> None:
+@pytest.mark.parametrize("masks", [None, "compute_brain_mask"])
+def test_ReHoParcels_comparison(tmp_path: Path, masks: str | None) -> None:
     """Test ReHoParcels implementation comparison.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    masks : str or None
+        The masks to use.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+    # Use float data with few ties: ReHo is rank-based and the
+    # implementations handle tied values differently
+    with ADHDTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         # Update workdir to current test's tmp_path
         WorkDirManager().workdir = tmp_path
 
         # Initialize marker
         junifer_marker = ReHoParcels(
-            parcellation="Schaefer100x7", using="junifer"
+            parcellation="Schaefer100x7", using=ReHoImpl.junifer, masks=masks
         )
         # Fit transform marker on data
         junifer_output = junifer_marker.fit_transform(element_data)
@@ -110,15 +116,15 @@ def test_ReHoParcels_comparison(tmp_path: Path) -> None:
         junifer_output_bold = junifer_output["BOLD"]["reho"]
 
         # Initialize marker
-        afni_marker = ReHoParcels(parcellation="Schaefer100x7", using="afni")
+        afni_marker = ReHoParcels(
+            parcellation="Schaefer100x7", using=ReHoImpl.afni, masks=masks
+        )
         # Fit transform marker on data
         afni_output = afni_marker.fit_transform(element_data)
         # Get BOLD output
         afni_output_bold = afni_output["BOLD"]["reho"]
 
-        # Check for Pearson correlation coefficient
-        r, _ = sp.stats.pearsonr(
-            junifer_output_bold["data"].flatten(),
-            afni_output_bold["data"].flatten(),
+        # Both implementations should give the same results
+        assert_allclose(
+            junifer_output_bold["data"], afni_output_bold["data"], atol=1e-6
         )
-        assert r >= 0.2  # this is very bad, but they differ...

junifer/markers/reho/tests/test_reho_spheres.py

@@ -7,16 +7,20 @@ import logging
 from pathlib import Path
 
 import pytest
-import scipy as sp
+import scipy.stats as sps
 
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
-from junifer.markers import ReHoSpheres
+from junifer.markers import ReHoImpl, ReHoSpheres
 from junifer.pipeline import WorkDirManager
 from junifer.pipeline.utils import _check_afni
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
+pytestmark = pytest.mark.external
+
+
 COORDINATES = "DMNBuckner"
 
 
@@ -32,17 +36,17 @@ def test_ReHoSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
     """
     with caplog.at_level(logging.DEBUG):
-        with SPMAuditoryTestingDataGrabber() as dg:
+        with SPMAuditoryTestingDataGrabber(n_timepoints=50) as dg:
             element_data = DefaultDataReader().fit_transform(dg["sub001"])
             # Update workdir to current test's tmp_path
             WorkDirManager().workdir = tmp_path
             # Initialize marker
             marker = ReHoSpheres(
-                coords=COORDINATES, using="junifer", radius=10.0
+                coords=COORDINATES, using=ReHoImpl.junifer, radius=10.0
             )
             # Check correct output
             assert "vector" == marker.storage_type(
-                input_type="BOLD", output_feature="reho"
+                input_type=DataType.BOLD, output_feature="reho"
             )
 
             # Fit transform marker on data
@@ -68,7 +72,7 @@ def test_ReHoSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Reset log capture
             caplog.clear()
             # Initialize storage
-            storage = SQLiteFeatureStorage(tmp_path / "reho_spheres.sqlite")
+            storage = HDF5FeatureStorage(uri=tmp_path / "reho_spheres.hdf5")
             # Fit transform marker on data with storage
             marker.fit_transform(
                 input=element_data,
@@ -90,7 +94,7 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
+    with SPMAuditoryTestingDataGrabber(n_timepoints=50) as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
         # Update workdir to current test's tmp_path
         WorkDirManager().workdir = tmp_path
@@ -98,7 +102,7 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         # Initialize marker
         junifer_marker = ReHoSpheres(
             coords=COORDINATES,
-            using="junifer",
+            using=ReHoImpl.junifer,
             radius=10.0,
         )
         # Fit transform marker on data
@@ -109,7 +113,7 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         # Initialize marker
         afni_marker = ReHoSpheres(
             coords=COORDINATES,
-            using="afni",
+            using=ReHoImpl.afni,
             radius=10.0,
         )
         # Fit transform marker on data
@@ -118,8 +122,8 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         afni_output_bold = afni_output["BOLD"]["reho"]
 
         # Check for Pearson correlation coefficient
-        r, _ = sp.stats.pearsonr(
+        r, _ = sps.pearsonr(
             junifer_output_bold["data"].flatten(),
             afni_output_bold["data"].flatten(),
         )
-        assert r >= 0.8  # 0.8 is a loose threshold
+        assert r >= 0.99

junifer/markers/sphere_aggregation.py

@@ -4,19 +4,36 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, ClassVar, Optional, Union
+from typing import Annotated, Any, ClassVar, Literal
+
+import numpy as np
+from pydantic import BeforeValidator, PositiveFloat
 
 from ..api.decorators import register_marker
 from ..data import get_data
+from ..datagrabber import DataType
 from ..external.nilearn import JuniferNiftiSpheresMasker
 from ..stats import get_aggfunc_by_name
+from ..storage import StorageType
 from ..typing import Dependencies, MarkerInOutMappings
-from ..utils import logger, raise_error, warn_with_log
-from .base import BaseMarker
+from ..utils import ensure_list_or_none, raise_error, warn_with_log
+from .base import BaseMarker, logger
 
 
 __all__ = ["SphereAggregation"]
 
+_on = Literal[
+    DataType.T1w,
+    DataType.T2w,
+    DataType.BOLD,
+    DataType.VBM_GM,
+    DataType.VBM_WM,
+    DataType.VBM_CSF,
+    DataType.FALFF,
+    DataType.GCOR,
+    DataType.LCOR,
+]
+
 
 @register_marker
 class SphereAggregation(BaseMarker):
@@ -27,37 +44,41 @@ class SphereAggregation(BaseMarker):
     coords : str
         The name of the coordinates list to use.
         See :func:`.list_data` for options.
-    radius : float, optional
-        The radius of the sphere in millimeters. If None, the signal will be
-        extracted from a single voxel. See
-        :class:`nilearn.maskers.NiftiSpheresMasker` for more information
+    radius : ``zero`` or positive float or None, optional
+        The radius of the sphere in millimeters.
+        If None, the signal will be extracted from a single voxel.
+        See :class:`.JuniferNiftiSpheresMasker` for more information
         (default None).
     allow_overlap : bool, optional
-        Whether to allow overlapping spheres. If False, an error is raised if
-        the spheres overlap (default is False).
+        Whether to allow overlapping spheres.
+        If False, an error is raised if the spheres overlap (default False).
     method : str, optional
-        The aggregation method to use.
-        See :func:`.get_aggfunc_by_name` for more information
+        The aggregation function to use.
+        See :func:`.get_aggfunc_by_name` for options
         (default "mean").
-    method_params : dict, optional
-        The parameters to pass to the aggregation method (default None).
-    time_method : str, optional
-        The method to use to aggregate the time series over the time points,
-        after applying :term:`method` (only applicable to BOLD data). If None,
+    method_params : dict or None, optional
+        The parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options (default None).
+    time_method : str or None, optional
+        The aggregation function to use for time series after applying
+        :term:`method` (only applicable to BOLD data). If None,
         it will not operate on the time dimension (default None).
-    time_method_params : dict, optional
-        The parameters to pass to the time aggregation method (default None).
-    masks : str, dict or list of dict or str, optional
+    time_method_params : dict or None, optional
+        The parameters to pass to the time aggregation function (default None).
+    on : {``DataType.T1w``, ``DataType.T2w``, ``DataType.BOLD``, \
+        ``DataType.VBM_GM``, ``DataType.VBM_WM``, ``DataType.VBM_CSF``, \
+        ``DataType.FALFF``, ``DataType.GCOR``, ``DataType.LCOR``} or \
+        list of them or None, optional
+        The data type(s) to apply the marker on.
+        If None, will work on all available data.
+        Check :enum:`.DataType` for valid values (default None).
+    masks : str, dict, list of them or None, optional
         The specification of the masks to apply to regions before extracting
         signals. Check :ref:`Using Masks <using_masks>` for more details.
         If None, will not apply any mask (default None).
-    on : {"T1w", "T2w", "BOLD", "VBM_GM", "VBM_WM", "VBM_CSF", "fALFF", \
-        "GCOR", "LCOR"} or list of the options, optional
-        The data types to apply the marker to. If None, will work on all
-        available data (default None).
-    name : str, optional
-        The name of the marker. By default, it will use KIND_SphereAggregation
-        where KIND is the kind of data it was applied to (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     Raises
     ------
@@ -70,74 +91,68 @@ class SphereAggregation(BaseMarker):
     _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn", "numpy"}
 
     _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
-        "T1w": {
-            "aggregation": "vector",
+        DataType.T1w: {
+            "aggregation": StorageType.Vector,
         },
-        "T2w": {
-            "aggregation": "vector",
+        DataType.T2w: {
+            "aggregation": StorageType.Vector,
         },
-        "BOLD": {
-            "aggregation": "timeseries",
+        DataType.BOLD: {
+            "aggregation": StorageType.Timeseries,
         },
-        "VBM_GM": {
-            "aggregation": "vector",
+        DataType.VBM_GM: {
+            "aggregation": StorageType.Vector,
         },
-        "VBM_WM": {
-            "aggregation": "vector",
+        DataType.VBM_WM: {
+            "aggregation": StorageType.Vector,
         },
-        "VBM_CSF": {
-            "aggregation": "vector",
+        DataType.VBM_CSF: {
+            "aggregation": StorageType.Vector,
         },
-        "fALFF": {
-            "aggregation": "vector",
+        DataType.FALFF: {
+            "aggregation": StorageType.Vector,
         },
-        "GCOR": {
-            "aggregation": "vector",
+        DataType.GCOR: {
+            "aggregation": StorageType.Vector,
         },
-        "LCOR": {
-            "aggregation": "vector",
+        DataType.LCOR: {
+            "aggregation": StorageType.Vector,
         },
     }
 
-    def __init__(
-        self,
-        coords: str,
-        radius: Optional[float] = None,
-        allow_overlap: bool = False,
-        method: str = "mean",
-        method_params: Optional[dict[str, Any]] = None,
-        time_method: Optional[str] = None,
-        time_method_params: Optional[dict[str, Any]] = None,
-        masks: Union[str, dict, list[Union[dict, str]], None] = None,
-        on: Union[list[str], str, None] = None,
-        name: Optional[str] = None,
-    ) -> None:
-        self.coords = coords
-        self.radius = radius
-        self.allow_overlap = allow_overlap
-        self.method = method
-        self.method_params = method_params or {}
-        self.masks = masks
-        super().__init__(on=on, name=name)
-
-        # Verify after super init so self._on is set
-        if "BOLD" not in self._on and time_method is not None:
+    coords: str
+    radius: Literal[0] | PositiveFloat | None = None
+    allow_overlap: bool = False
+    method: str = "mean"
+    method_params: dict[str, Any] | None = None
+    time_method: str | None = None
+    time_method_params: dict[str, Any] | None = None
+    masks: Annotated[
+        dict | str | list[dict | str] | None,
+        BeforeValidator(ensure_list_or_none),
+    ] = None
+    on: Annotated[
+        _on | list[_on] | None, BeforeValidator(ensure_list_or_none)
+    ] = None
+
+    def validate_marker_params(self) -> None:
+        """Run extra logical validation for marker."""
+        # self.on is set already
+        if "BOLD" not in self.on and self.time_method is not None:
             raise_error(
                 "`time_method` can only be used with BOLD data. "
                 "Please remove `time_method` parameter."
             )
-        if time_method is None and time_method_params is not None:
+        if self.time_method is None and self.time_method_params is not None:
             raise_error(
                 "`time_method_params` can only be used with `time_method`. "
                 "Please remove `time_method_params` parameter."
             )
-        self.time_method = time_method
-        self.time_method_params = time_method_params or {}
 
     def compute(
         self,
         input: dict[str, Any],
-        extra_input: Optional[dict] = None,
+        extra_input: dict | None = None,
     ) -> dict:
         """Compute.
 
@@ -207,7 +222,8 @@ class SphereAggregation(BaseMarker):
             agg_func=agg_func,
         )
         # Fit and transform the marker on the data
-        out_values = masker.fit_transform(t_input_img)
+        # nilearn maskers return 1D arrays for 3D images, keep 2D
+        out_values = np.atleast_2d(masker.fit_transform(t_input_img))
 
         # Apply time dimension aggregation if required
         if self.time_method is not None:

junifer/markers/temporal_snr/temporal_snr_base.py

@@ -1,15 +1,19 @@
 """Provide abstract base class for temporal signal-to-noise ratio (tSNR)."""
 
 # Authors: Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from abc import abstractmethod
-from typing import Any, ClassVar, Optional, Union
+from typing import Annotated, Any, ClassVar
 
 from nilearn import image as nimg
+from pydantic import BeforeValidator
 
+from ...datagrabber import DataType
+from ...storage import StorageType
 from ...typing import Dependencies, MarkerInOutMappings
-from ...utils import raise_error
+from ...utils import ensure_list_or_none, raise_error
 from ..base import BaseMarker
 
 
@@ -22,44 +26,40 @@ class TemporalSNRBase(BaseMarker):
     Parameters
     ----------
     agg_method : str, optional
-        The method to perform aggregation using. Check valid options in
-        :func:`.get_aggfunc_by_name` (default "mean").
-    agg_method_params : dict, optional
-        Parameters to pass to the aggregation function. Check valid options in
-        :func:`.get_aggfunc_by_name` (default None).
-    masks : str, dict or list of dict or str, optional
+        The aggregation function to use.
+        See :func:`.get_aggfunc_by_name` for options
+        (default "mean").
+    agg_method_params : dict or None, optional
+        The parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options (default None).
+    masks : str, dict, list of them or None, optional
         The specification of the masks to apply to regions before extracting
         signals. Check :ref:`Using Masks <using_masks>` for more details.
         If None, will not apply any mask (default None).
-    name : str, optional
-        The name of the marker. If None, will use the class name (default
-        None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     """
 
     _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn"}
 
     _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
-        "BOLD": {
-            "tsnr": "vector",
+        DataType.BOLD: {
+            "tsnr": StorageType.Vector,
         },
     }
 
-    def __init__(
-        self,
-        agg_method: str = "mean",
-        agg_method_params: Optional[dict] = None,
-        masks: Union[str, dict, list[Union[dict, str]], None] = None,
-        name: Optional[str] = None,
-    ) -> None:
-        self.agg_method = agg_method
-        self.agg_method_params = agg_method_params
-        self.masks = masks
-        super().__init__(on="BOLD", name=name)
+    agg_method: str = "mean"
+    agg_method_params: dict | None = None
+    masks: Annotated[
+        dict | str | list[dict | str] | None,
+        BeforeValidator(ensure_list_or_none),
+    ] = None
 
     @abstractmethod
     def aggregate(
-        self, input: dict[str, Any], extra_input: Optional[dict] = None
+        self, input: dict[str, Any], extra_input: dict | None = None
     ) -> dict[str, Any]:
         """Perform aggregation."""
         raise_error(
@@ -70,7 +70,7 @@ class TemporalSNRBase(BaseMarker):
     def compute(
         self,
         input: dict[str, Any],
-        extra_input: Optional[dict] = None,
+        extra_input: dict | None = None,
     ) -> dict:
         """Compute.
 
@@ -104,7 +104,9 @@ class TemporalSNRBase(BaseMarker):
             "img.std(axis=-1).squeeze()", img=input["data"]
         )
         mask_img = nimg.math_img("(stdv_img != 0)", stdv_img=stdv_img)
-        input["data"] = nimg.math_img(
+        # Aggregate the tSNR image, without changing the input
+        aggregation_input = dict(input.items())
+        aggregation_input["data"] = nimg.math_img(
             "np.divide(mean_img, stdv_img, where=mask_img.astype(bool))",
             mean_img=mean_img,
             stdv_img=stdv_img,
@@ -113,8 +115,8 @@ class TemporalSNRBase(BaseMarker):
         # Perform necessary aggregation and return
         return {
             "tsnr": {
-                **self.aggregate(input=input, extra_input=extra_input)[
-                    "aggregation"
-                ]
+                **self.aggregate(
+                    input=aggregation_input, extra_input=extra_input
+                )["aggregation"]
             }
         }

junifer/markers/temporal_snr/temporal_snr_maps.py

@@ -3,9 +3,10 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Optional, Union
+from typing import Any
 
 from ...api.decorators import register_marker
+from ...datagrabber import DataType
 from ..maps_aggregation import MapsAggregation
 from .temporal_snr_base import TemporalSNRBase
 
@@ -22,30 +23,20 @@ class TemporalSNRMaps(TemporalSNRBase):
     maps : str
         The name of the map(s) to use.
         See :func:`.list_data` for options.
-    masks : str, dict or list of dict or str, optional
+    masks : str, dict, list of them or None, optional
         The specification of the masks to apply to regions before extracting
         signals. Check :ref:`Using Masks <using_masks>` for more details.
         If None, will not apply any mask (default None).
-    name : str, optional
-        The name of the marker. If None, will use the class name (default
-        None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     """
 
-    def __init__(
-        self,
-        maps: str,
-        masks: Union[str, dict, list[Union[dict, str]], None] = None,
-        name: Optional[str] = None,
-    ) -> None:
-        self.maps = maps
-        super().__init__(
-            masks=masks,
-            name=name,
-        )
+    maps: str
 
     def aggregate(
-        self, input: dict[str, Any], extra_input: Optional[dict] = None
+        self, input: dict[str, Any], extra_input: dict | None = None
     ) -> dict:
         """Perform maps aggregation.
 
@@ -76,5 +67,5 @@ class TemporalSNRMaps(TemporalSNRBase):
         return MapsAggregation(
             maps=self.maps,
             masks=self.masks,
-            on="BOLD",
+            on=DataType.BOLD,
         ).compute(input=input, extra_input=extra_input)