junifer 0.0.3.dev186__py3-none-any.whl → 0.0.4__py3-none-any.whl

junifer/markers/reho/tests/test_reho_spheres.py

@@ -1,118 +1,120 @@
-"""Provide tests for ReHo on spheres."""
+"""Provide tests for ReHoSpheres."""
 
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+import logging
 from pathlib import Path
 
 import pytest
-from nilearn import image as nimg
-from scipy.stats import pearsonr
+import scipy as sp
 
-from junifer.markers.reho.reho_spheres import ReHoSpheres
+from junifer.datareader import DefaultDataReader
+from junifer.markers import ReHoSpheres
+from junifer.pipeline import WorkDirManager
 from junifer.pipeline.utils import _check_afni
-from junifer.storage.sqlite import SQLiteFeatureStorage
+from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
 COORDINATES = "DMNBuckner"
 
 
-def test_reho_spheres_computation() -> None:
-    """Test ReHoSpheres fit-transform."""
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Use first subject
-        subject_data = dg["sub001"]
-        # Load image to memory
-        fmri_img = nimg.load_img(subject_data["BOLD"]["path"])
-        # Initialize marker
-        reho_spheres_marker = ReHoSpheres(coords=COORDINATES, radius=10.0)
-        # Fit transform marker on data
-        reho_spheres_output = reho_spheres_marker.fit_transform(
-            {"BOLD": {"path": "/tmp", "data": fmri_img, "meta": {}}}
-        )
-        # Get BOLD output
-        reho_spheres_output_bold = reho_spheres_output["BOLD"]
-        # Assert BOLD output keys
-        assert "data" in reho_spheres_output_bold
-        assert "col_names" in reho_spheres_output_bold
+def test_ReHoSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
+    """Test ReHoSpheres.
+
+    Parameters
+    ----------
+    caplog : pytest.LogCaptureFixture
+        The pytest.LogCaptureFixture object.
+    tmp_path : pathlib.Path
+        The path to the test directory.
 
-        reho_spheres_output_bold_data = reho_spheres_output_bold["data"]
-        # Assert BOLD output data dimension
-        assert reho_spheres_output_bold_data.ndim == 2
-        # Assert BOLD output data is normalized
-        assert (reho_spheres_output_bold_data > 0).all() and (
-            reho_spheres_output_bold_data < 1
-        ).all()
+    """
+    with caplog.at_level(logging.DEBUG):
+        with SPMAuditoryTestingDataGrabber() 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
+            )
+            # Fit transform marker on data
+            output = marker.fit_transform(element_data)
+
+            assert "Creating cache" in caplog.text
+
+            # Get BOLD output
+            assert "BOLD" in output
+            output_bold = output["BOLD"]
+            # Assert BOLD output keys
+            assert "data" in output_bold
+            assert "col_names" in output_bold
+
+            output_bold_data = output_bold["data"]
+            # Assert BOLD output data dimension
+            assert output_bold_data.ndim == 2
+            # Assert BOLD output data is normalized
+            assert (output_bold_data > 0).all() and (
+                output_bold_data < 1
+            ).all()
+
+            # Reset log capture
+            caplog.clear()
+            # Initialize storage
+            storage = SQLiteFeatureStorage(tmp_path / "reho_spheres.sqlite")
+            # Fit transform marker on data with storage
+            marker.fit_transform(
+                input=element_data,
+                storage=storage,
+            )
+            # Cache working correctly
+            assert "Creating cache" not in caplog.text
 
 
 @pytest.mark.skipif(
-    _check_afni() is False, reason="requires afni to be in PATH"
+    _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_reho_spheres_computation_comparison() -> None:
-    """Test ReHoSpheres fit-transform implementation comparison.."""
+def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
+    """Test ReHoSpheres implementation comparison.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
     with SPMAuditoryTestingDataGrabber() as dg:
-        # Use first subject
-        subject_data = dg["sub001"]
-        # Load image to memory
-        fmri_img = nimg.load_img(subject_data["BOLD"]["path"])
-
-        # Initialize marker with use_afni=False
-        reho_spheres_marker_python = ReHoSpheres(
-            coords=COORDINATES, radius=10.0, use_afni=False
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        # Update workdir to current test's tmp_path
+        WorkDirManager().workdir = tmp_path
+
+        # Initialize marker
+        junifer_marker = ReHoSpheres(
+            coords=COORDINATES,
+            using="junifer",
+            radius=10.0,
         )
         # Fit transform marker on data
-        reho_spheres_output_python = reho_spheres_marker_python.fit_transform(
-            {"BOLD": {"path": "/tmp", "data": fmri_img, "meta": {}}}
-        )
+        junifer_output = junifer_marker.fit_transform(element_data)
         # Get BOLD output
-        reho_spheres_output_bold_python = reho_spheres_output_python["BOLD"]
+        junifer_output_bold = junifer_output["BOLD"]
 
-        # Initialize marker with use_afni=True
-        reho_spheres_marker_afni = ReHoSpheres(
-            coords=COORDINATES, radius=10.0, use_afni=True
+        # Initialize marker
+        afni_marker = ReHoSpheres(
+            coords=COORDINATES,
+            using="afni",
+            radius=10.0,
         )
         # Fit transform marker on data
-        reho_spheres_output_afni = reho_spheres_marker_afni.fit_transform(
-            {"BOLD": {"path": "/tmp", "data": fmri_img, "meta": {}}}
-        )
+        afni_output = afni_marker.fit_transform(element_data)
         # Get BOLD output
-        reho_spheres_output_bold_afni = reho_spheres_output_afni["BOLD"]
+        afni_output_bold = afni_output["BOLD"]
 
         # Check for Pearson correlation coefficient
-        r, _ = pearsonr(
-            reho_spheres_output_bold_python["data"].flatten(),
-            reho_spheres_output_bold_afni["data"].flatten(),
+        r, _ = sp.stats.pearsonr(
+            junifer_output_bold["data"].flatten(),
+            afni_output_bold["data"].flatten(),
         )
         assert r >= 0.8  # 0.8 is a loose threshold
-
-
-def test_reho_spheres_storage(tmp_path: Path) -> None:
-    """Test ReHoSpheres storage.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-
-    """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Use first subject
-        subject_data = dg["sub001"]
-        # Load image to memory
-        fmri_img = nimg.load_img(subject_data["BOLD"]["path"])
-        # Initialize marker
-        reho_spheres_marker = ReHoSpheres(coords=COORDINATES, radius=10.0)
-        # Initialize storage
-        reho_spheres_storage = SQLiteFeatureStorage(
-            tmp_path / "reho_spheres.sqlite"
-        )
-        # Generate meta
-        meta = {
-            "element": {"subject": "sub001"}
-        }  # only requires element key for storing
-        # Fit transform marker on data with storage
-        reho_spheres_marker.fit_transform(
-            input={"BOLD": {"path": "/tmp", "data": fmri_img, "meta": meta}},
-            storage=reho_spheres_storage,
-        )

junifer/markers/sphere_aggregation.py

@@ -7,7 +7,7 @@
 from typing import Any, ClassVar, Dict, List, Optional, Set, Union
 
 from ..api.decorators import register_marker
-from ..data import get_mask, load_coordinates
+from ..data import get_coordinates, get_mask
 from ..external.nilearn import JuniferNiftiSpheresMasker
 from ..stats import get_aggfunc_by_name
 from ..utils import logger, raise_error, warn_with_log
@@ -47,14 +47,20 @@ class SphereAggregation(BaseMarker):
         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", "BOLD", "VBM_GM", "VBM_WM", "fALFF", "GCOR", "LCOR"} or \
-         list of the options, optional
+    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).
 
+    Raises
+    ------
+    ValueError
+        If ``time_method`` is specified for non-BOLD data or if
+        ``time_method_params`` is not None when ``time_method`` is None.
+
     """
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "numpy"}
@@ -103,7 +109,17 @@ class SphereAggregation(BaseMarker):
             The list of data types that can be used as input for this marker.
 
         """
-        return ["T1w", "BOLD", "VBM_GM", "VBM_WM", "fALFF", "GCOR", "LCOR"]
+        return [
+            "T1w",
+            "T2w",
+            "BOLD",
+            "VBM_GM",
+            "VBM_WM",
+            "VBM_CSF",
+            "fALFF",
+            "GCOR",
+            "LCOR",
+        ]
 
     def get_output_type(self, input_type: str) -> str:
         """Get output type.
@@ -118,14 +134,26 @@ class SphereAggregation(BaseMarker):
         str
             The storage type output by the marker.
 
+        Raises
+        ------
+        ValueError
+            If the ``input_type`` is invalid.
+
         """
 
-        if input_type in ["VBM_GM", "VBM_WM", "fALFF", "GCOR", "LCOR"]:
+        if input_type in [
+            "VBM_GM",
+            "VBM_WM",
+            "VBM_CSF",
+            "fALFF",
+            "GCOR",
+            "LCOR",
+        ]:
             return "vector"
         elif input_type == "BOLD":
             return "timeseries"
         else:
-            raise ValueError(f"Unknown input kind for {input_type}")
+            raise_error(f"Unknown input kind for {input_type}")
 
     def compute(
         self,
@@ -155,6 +183,11 @@ class SphereAggregation(BaseMarker):
             * ``data`` : the actual computed values as a numpy.ndarray
             * ``col_names`` : the column labels for the computed values as list
 
+        Warns
+        -----
+        RuntimeWarning
+            If time aggregation is required but only time point is available.
+
         """
         t_input_img = input["data"]
         logger.debug(f"Sphere aggregation using {self.method}")
@@ -162,15 +195,25 @@ class SphereAggregation(BaseMarker):
         agg_func = get_aggfunc_by_name(
             self.method, func_params=self.method_params
         )
+
+        # Get seeds and labels tailored to target image
+        coords, labels = get_coordinates(
+            coords=self.coords,
+            target_data=input,
+            extra_input=extra_input,
+        )
+
         # Load mask
         mask_img = None
         if self.masks is not None:
             logger.debug(f"Masking with {self.masks}")
+            # Get tailored mask
             mask_img = get_mask(
                 masks=self.masks, target_data=input, extra_input=extra_input
             )
-        # Get seeds and labels
-        coords, out_labels = load_coordinates(name=self.coords)
+
+        # Initialize masker
+        logger.debug("Masking")
         masker = JuniferNiftiSpheresMasker(
             seeds=coords,
             radius=self.radius,
@@ -180,6 +223,8 @@ class SphereAggregation(BaseMarker):
         )
         # Fit and transform the marker on the data
         out_values = masker.fit_transform(t_input_img)
+
+        # Apply time dimension aggregation if required
         if self.time_method is not None:
             if out_values.shape[0] > 1:
                 logger.debug("Aggregating time dimension")
@@ -193,5 +238,5 @@ class SphereAggregation(BaseMarker):
                     "available."
                 )
         # Format the output
-        out = {"data": out_values, "col_names": out_labels}
+        out = {"data": out_values, "col_names": labels}
         return out

junifer/markers/temporal_snr/temporal_snr_base.py

@@ -65,6 +65,7 @@ class TemporalSNRBase(BaseMarker):
         -------
         list of str
             The list of data types that can be used as input for this marker.
+
         """
         return ["BOLD"]
 

junifer/markers/temporal_snr/tests/test_temporal_snr_parcels.py

@@ -1,18 +1,39 @@
 """Provide tests for temporal signal-to-noise ratio using parcellation."""
 
 # Authors: Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
-from nilearn import datasets, image
-
+from junifer.datareader import DefaultDataReader
 from junifer.markers.temporal_snr import TemporalSNRParcels
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
+from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
+
+
+def test_TemporalSNRParcels_computation() -> None:
+    """Test TemporalSNRParcels fit-transform."""
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        marker = TemporalSNRParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym"
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "vector"
+
+        # Fit-transform the data
+        tsnr_parcels = marker.fit_transform(element_data)
+        tsnr_parcels_bold = tsnr_parcels["BOLD"]
+
+        assert "data" in tsnr_parcels_bold
+        assert "col_names" in tsnr_parcels_bold
+        assert tsnr_parcels_bold["data"].shape == (1, 16)
+        assert len(set(tsnr_parcels_bold["col_names"])) == 16
 
 
-def test_TemporalSNRParcels(tmp_path: Path) -> None:
-    """Test TemporalSNRParcels.
+def test_TemporalSNRParcels_storage(tmp_path: Path) -> None:
+    """Test TemporalSNRParcels store.
 
     Parameters
     ----------
@@ -20,35 +41,15 @@ def test_TemporalSNRParcels(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    tsnr_parcels = TemporalSNRParcels(parcellation="Schaefer100x7")
-    all_out = tsnr_parcels.fit_transform(
-        {"BOLD": {"data": fmri_img, "meta": {}}}
-    )
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "col_names" in out
-
-    assert out["data"].shape[0] == 1
-    assert out["data"].shape[1] == 100
-    assert len(set(out["col_names"])) == 100
-
-    # check correct output
-    assert tsnr_parcels.get_output_type("BOLD") == "vector"
-
-    uri = tmp_path / "test_tsnr_parcellation.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {"element": {"subject": "test"}, "dependencies": {"numpy"}}
-    input = {"BOLD": {"data": fmri_img, "meta": meta}}
-    all_out = tsnr_parcels.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
-    )
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        marker = TemporalSNRParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym"
+        )
+        # Store
+        storage = HDF5FeatureStorage(tmp_path / "test_tsnr_parcels.hdf5")
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
+        )

junifer/markers/temporal_snr/tests/test_temporal_snr_spheres.py

@@ -1,19 +1,39 @@
 """Provide tests for temporal signal-to-noise spheres."""
 
 # Authors: Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
 import pytest
-from nilearn import datasets, image
 
+from junifer.datareader import DefaultDataReader
 from junifer.markers.temporal_snr import TemporalSNRSpheres
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
+from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
-def test_TemporalSNRSpheres(tmp_path: Path) -> None:
-    """Test TemporalSNRSpheres.
+def test_TemporalSNRSpheres_computation() -> None:
+    """Test TemporalSNRSpheres fit-transform."""
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "vector"
+
+        # Fit-transform the data
+        tsnr_spheres = marker.fit_transform(element_data)
+        tsnr_spheres_bold = tsnr_spheres["BOLD"]
+
+        assert "data" in tsnr_spheres_bold
+        assert "col_names" in tsnr_spheres_bold
+        assert tsnr_spheres_bold["data"].shape == (1, 6)
+        assert len(set(tsnr_spheres_bold["col_names"])) == 6
+
+
+def test_TemporalSNRSpheres_storage(tmp_path: Path) -> None:
+    """Test TemporalSNRSpheres store.
 
     Parameters
     ----------
@@ -21,40 +41,16 @@ def test_TemporalSNRSpheres(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    tsnr_spheres = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
-    all_out = tsnr_spheres.fit_transform(
-        {"BOLD": {"data": fmri_img, "meta": {}}}
-    )
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == 1
-    assert out["data"].shape[1] == 6
-    assert len(set(out["col_names"])) == 6
-
-    # check correct output
-    assert tsnr_spheres.get_output_type("BOLD") == "vector"
-
-    uri = tmp_path / "test_tsnr_coords.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {
-        "element": {"subject": "test"},
-        "dependencies": {"numpy", "nilearn"},
-    }
-    input = {"BOLD": {"data": fmri_img, "meta": meta}}
-    all_out = tsnr_spheres.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_TemporalSNRSpheres" for x in features.values()
-    )
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
+        # Store
+        storage = HDF5FeatureStorage(tmp_path / "test_tsnr_spheres.hdf5")
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_TemporalSNRSpheres" for x in features.values()
+        )
 
 
 def test_TemporalSNRSpheres_error() -> None: