junifer 0.0.4.dev829__py3-none-any.whl → 0.0.5__py3-none-any.whl

junifer/markers/temporal_snr/temporal_snr_base.py

@@ -13,6 +13,9 @@ from ...utils import raise_error
 from ..base import BaseMarker
 
 
+__all__ = ["TemporalSNRBase"]
+
+
 class TemporalSNRBase(BaseMarker):
     """Abstract base class for temporal SNR markers.
 
@@ -36,6 +39,12 @@ class TemporalSNRBase(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "tsnr": "vector",
+        },
+    }
+
     def __init__(
         self,
         agg_method: str = "mean",
@@ -58,33 +67,6 @@ class TemporalSNRBase(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],
@@ -104,11 +86,14 @@ class TemporalSNRBase(BaseMarker):
         Returns
         -------
         dict
-            The computed result as dictionary. The following keys will be
-            included in the dictionary:
+            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:
+
+            * ``tsnr`` : dictionary with the following keys:
 
-            * ``data`` : the computed values as a ``numpy.ndarray``
-            * ``col_names`` : the column labels for the computed values as list
+              - ``data`` : computed tSNR as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
 
         """
         # Calculate voxelwise temporal signal-to-noise ratio in an image
@@ -126,4 +111,10 @@ class TemporalSNRBase(BaseMarker):
             mask_img=mask_img,
         )
         # Perform necessary aggregation and return
-        return self.aggregate(input=input, extra_input=extra_input)
+        return {
+            "tsnr": {
+                **self.aggregate(input=input, extra_input=extra_input)[
+                    "aggregation"
+                ]
+            }
+        }

junifer/markers/temporal_snr/temporal_snr_parcels.py

@@ -10,6 +10,9 @@ from ..parcel_aggregation import ParcelAggregation
 from .temporal_snr_base import TemporalSNRBase
 
 
+__all__ = ["TemporalSNRParcels"]
+
+
 @register_marker
 class TemporalSNRParcels(TemporalSNRBase):
     """Class for temporal signal-to-noise ratio using parcellations.
@@ -74,16 +77,16 @@ class TemporalSNRParcels(TemporalSNRBase):
             to the user or stored in the storage by calling the store method
             with this as a parameter. The dictionary has the following keys:
 
-            * ``data`` : ROI-wise temporal SNR as a ``numpy.ndarray``
-            * ``col_names`` : the ROI labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI-wise tSNR values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        parcel_aggregation = ParcelAggregation(
+        return ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Return the 2D timeseries after parcel aggregation
-        return parcel_aggregation.compute(input=input, extra_input=extra_input)
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/temporal_snr/temporal_snr_spheres.py

@@ -11,6 +11,9 @@ from ..utils import raise_error
 from .temporal_snr_base import TemporalSNRBase
 
 
+__all__ = ["TemporalSNRSpheres"]
+
+
 @register_marker
 class TemporalSNRSpheres(TemporalSNRBase):
     """Class for temporal signal-to-noise ratio using coordinates (spheres).
@@ -89,11 +92,13 @@ class TemporalSNRSpheres(TemporalSNRBase):
             to the user or stored in the storage by calling the store method
             with this as a parameter. The dictionary has the following keys:
 
-            * ``data`` : VOI-wise temporal SNR as a ``numpy.ndarray``
-            * ``col_names`` : the VOI labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI-wise tSNR values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        sphere_aggregation = SphereAggregation(
+        return SphereAggregation(
             coords=self.coords,
             radius=self.radius,
             allow_overlap=self.allow_overlap,
@@ -101,6 +106,4 @@ class TemporalSNRSpheres(TemporalSNRBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Return the 2D timeseries after sphere aggregation
-        return sphere_aggregation.compute(input=input, extra_input=extra_input)
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/temporal_snr/tests/test_temporal_snr_parcels.py

@@ -20,11 +20,13 @@ def test_TemporalSNRParcels_computation() -> None:
             parcellation="TianxS1x3TxMNInonlinear2009cAsym"
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "vector"
+        assert "vector" == marker.get_output_type(
+            input_type="BOLD", output_feature="tsnr"
+        )
 
         # Fit-transform the data
         tsnr_parcels = marker.fit_transform(element_data)
-        tsnr_parcels_bold = tsnr_parcels["BOLD"]
+        tsnr_parcels_bold = tsnr_parcels["BOLD"]["tsnr"]
 
         assert "data" in tsnr_parcels_bold
         assert "col_names" in tsnr_parcels_bold
@@ -51,5 +53,6 @@ def test_TemporalSNRParcels_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
+            x["name"] == "BOLD_TemporalSNRParcels_tsnr"
+            for x in features.values()
         )

junifer/markers/temporal_snr/tests/test_temporal_snr_spheres.py

@@ -20,11 +20,13 @@ def test_TemporalSNRSpheres_computation() -> None:
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
         marker = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
         # Check correct output
-        assert marker.get_output_type("BOLD") == "vector"
+        assert "vector" == marker.get_output_type(
+            input_type="BOLD", output_feature="tsnr"
+        )
 
         # Fit-transform the data
         tsnr_spheres = marker.fit_transform(element_data)
-        tsnr_spheres_bold = tsnr_spheres["BOLD"]
+        tsnr_spheres_bold = tsnr_spheres["BOLD"]["tsnr"]
 
         assert "data" in tsnr_spheres_bold
         assert "col_names" in tsnr_spheres_bold
@@ -49,7 +51,8 @@ def test_TemporalSNRSpheres_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_TemporalSNRSpheres" for x in features.values()
+            x["name"] == "BOLD_TemporalSNRSpheres_tsnr"
+            for x in features.values()
         )
 
 

junifer/markers/tests/test_brainprint.py

@@ -0,0 +1,58 @@
+"""Provide tests for BrainPrint."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+import socket
+
+import pytest
+
+from junifer.datagrabber import DataladAOMICID1000
+from junifer.datareader import DefaultDataReader
+from junifer.markers import BrainPrint
+from junifer.pipeline.utils import _check_freesurfer
+
+
+@pytest.mark.parametrize(
+    "feature, storage_type",
+    [
+        ("eigenvalues", "scalar_table"),
+        ("areas", "vector"),
+        ("volumes", "vector"),
+        ("distances", "vector"),
+    ],
+)
+def test_get_output_type(feature: str, storage_type: str) -> None:
+    """Test BrainPrint get_output_type().
+
+    Parameters
+    ----------
+    feature : str
+        The parametrized feature name.
+    storage_type : str
+        The parametrized storage type.
+
+    """
+    assert storage_type == BrainPrint().get_output_type(
+        input_type="FreeSurfer", output_feature=feature
+    )
+
+
+@pytest.mark.skipif(
+    _check_freesurfer() is False, reason="requires FreeSurfer to be in PATH"
+)
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+def test_compute() -> None:
+    """Test BrainPrint compute()."""
+    with DataladAOMICID1000(types="FreeSurfer") as dg:
+        # Fetch element
+        element = dg["sub-0001"]
+        # Fetch element data
+        element_data = DefaultDataReader().fit_transform(element)
+        # Compute marker
+        feature_map = BrainPrint().fit_transform(element_data)
+        # Assert the output keys
+        assert {"eigenvalues", "areas", "volumes"} == set(feature_map.keys())

junifer/markers/tests/test_collection.py

@@ -84,7 +84,7 @@ def test_marker_collection() -> None:
         for t_marker in markers:
             t_name = t_marker.name
             assert "BOLD" in out[t_name]
-            t_bold = out[t_name]["BOLD"]
+            t_bold = out[t_name]["BOLD"]["aggregation"]
             assert "data" in t_bold
             assert "col_names" in t_bold
             assert "meta" in t_bold
@@ -107,7 +107,8 @@ def test_marker_collection() -> None:
         for t_marker in markers:
             t_name = t_marker.name
             assert_array_equal(
-                out[t_name]["BOLD"]["data"], out2[t_name]["BOLD"]["data"]
+                out[t_name]["BOLD"]["aggregation"]["data"],
+                out2[t_name]["BOLD"]["aggregation"]["data"],
             )
 
 
@@ -201,20 +202,20 @@ def test_marker_collection_storage(tmp_path: Path) -> None:
     feature_md5 = next(iter(features.keys()))
     t_feature = storage.read_df(feature_md5=feature_md5)
     fname = "tian_mean"
-    t_data = out[fname]["BOLD"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["aggregation"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["aggregation"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore
 
     feature_md5 = list(features.keys())[1]
     t_feature = storage.read_df(feature_md5=feature_md5)
     fname = "tian_std"
-    t_data = out[fname]["BOLD"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["aggregation"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["aggregation"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore
 
     feature_md5 = list(features.keys())[2]
     t_feature = storage.read_df(feature_md5=feature_md5)
     fname = "tian_trim_mean90"
-    t_data = out[fname]["BOLD"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["aggregation"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["aggregation"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore

junifer/markers/tests/test_ets_rss.py

@@ -26,8 +26,9 @@ def test_compute() -> None:
     with PartlyCloudyTestingDataGrabber() as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         # Compute the RSSETSMarker
-        marker = RSSETSMarker(parcellation=PARCELLATION)
-        rss_ets = marker.compute(element_data["BOLD"])
+        rss_ets = RSSETSMarker(parcellation=PARCELLATION).compute(
+            element_data["BOLD"]
+        )
 
         # Compare with nilearn
         # Load testing parcellation
@@ -41,14 +42,14 @@ def test_compute() -> None:
             element_data["BOLD"]["data"]
         )
         # Assert the dimension of timeseries
-        assert extacted_timeseries.shape[0] == len(rss_ets["data"])
+        assert extacted_timeseries.shape[0] == len(rss_ets["rss_ets"]["data"])
 
 
 def test_get_output_type() -> None:
     """Test RSS ETS get_output_type()."""
     assert "timeseries" == RSSETSMarker(
         parcellation=PARCELLATION
-    ).get_output_type("BOLD")
+    ).get_output_type(input_type="BOLD", output_feature="rss_ets")
 
 
 def test_store(tmp_path: Path) -> None:
@@ -61,12 +62,17 @@ def test_store(tmp_path: Path) -> None:
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
+        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
-        # Compute the RSSETSMarker
-        marker = RSSETSMarker(parcellation=PARCELLATION)
         # Create storage
         storage = SQLiteFeatureStorage(tmp_path / "test_rss_ets.sqlite")
-        # Store
-        marker.fit_transform(input=element_data, storage=storage)
+        # Compute the RSSETSMarker and store
+        _ = RSSETSMarker(parcellation=PARCELLATION).fit_transform(
+            input=element_data, storage=storage
+        )
+        # Retrieve features
         features = storage.list_features()
-        assert any(x["name"] == "BOLD_RSSETSMarker" for x in features.values())
+        # Check marker name
+        assert any(
+            x["name"] == "BOLD_RSSETSMarker_rss_ets" for x in features.values()
+        )

junifer/markers/tests/test_markers_base.py

@@ -20,27 +20,27 @@ def test_base_marker_subclassing() -> None:
 
     # Create concrete class
     class MyBaseMarker(BaseMarker):
+
+        _MARKER_INOUT_MAPPINGS = {  # noqa: RUF012
+            "BOLD": {
+                "feat_1": "timeseries",
+            },
+        }
+
         def __init__(self, on, name=None) -> None:
             self.parameter = 1
             super().__init__(on, name)
 
-        def get_valid_inputs(self):
-            return ["BOLD", "T1w"]
-
-        def get_output_type(self, input):
-            if input == "BOLD":
-                return "timeseries"
-            raise ValueError(f"Cannot compute output type for {input}")
-
         def compute(self, input, extra_input):
             return {
-                "data": "data",
-                "columns": "columns",
-                "row_names": "row_names",
+                "feat_1": {
+                    "data": "data",
+                    "col_names": ["columns"],
+                },
             }
 
-    with pytest.raises(ValueError, match=r"cannot be computed on \['T2w'\]"):
-        MyBaseMarker(on=["BOLD", "T2w"])
+    with pytest.raises(ValueError, match=r"cannot be computed on \['T1w'\]"):
+        MyBaseMarker(on=["BOLD", "T1w"])
 
     # Create input for marker
     input_ = {
@@ -64,12 +64,11 @@ def test_base_marker_subclassing() -> None:
     output = marker.fit_transform(input=input_)  # process
     # Check output
     assert "BOLD" in output
-    assert "data" in output["BOLD"]
-    assert "columns" in output["BOLD"]
-    assert "row_names" in output["BOLD"]
+    assert "data" in output["BOLD"]["feat_1"]
+    assert "col_names" in output["BOLD"]["feat_1"]
 
-    assert "meta" in output["BOLD"]
-    meta = output["BOLD"]["meta"]
+    assert "meta" in output["BOLD"]["feat_1"]
+    meta = output["BOLD"]["feat_1"]["meta"]
     assert "datagrabber" in meta
     assert "element" in meta
     assert "datareader" in meta

junifer/markers/tests/test_parcel_aggregation.py

@@ -23,16 +23,63 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-def test_ParcelAggregation_input_output() -> None:
-    """Test ParcelAggregation input and output types."""
-    marker = ParcelAggregation(
-        parcellation="Schaefer100x7", method="mean", on="VBM_GM"
-    )
-    for in_, out_ in [("VBM_GM", "vector"), ("BOLD", "timeseries")]:
-        assert marker.get_output_type(in_) == out_
+@pytest.mark.parametrize(
+    "input_type, storage_type",
+    [
+        (
+            "T1w",
+            "vector",
+        ),
+        (
+            "T2w",
+            "vector",
+        ),
+        (
+            "BOLD",
+            "timeseries",
+        ),
+        (
+            "VBM_GM",
+            "vector",
+        ),
+        (
+            "VBM_WM",
+            "vector",
+        ),
+        (
+            "VBM_CSF",
+            "vector",
+        ),
+        (
+            "fALFF",
+            "vector",
+        ),
+        (
+            "GCOR",
+            "vector",
+        ),
+        (
+            "LCOR",
+            "vector",
+        ),
+    ],
+)
+def test_ParcelAggregation_input_output(
+    input_type: str, storage_type: str
+) -> None:
+    """Test ParcelAggregation input and output types.
 
-    with pytest.raises(ValueError, match="Unknown input"):
-        marker.get_output_type("unknown")
+    Parameters
+    ----------
+    input_type : str
+        The parametrized input type.
+    storage_type : str
+        The parametrized storage type.
+
+    """
+    assert storage_type == ParcelAggregation(
+        parcellation="Schaefer100x7", method="mean", on=input_type
+    ).get_output_type(input_type=input_type, output_feature="aggregation")
 
 
 def test_ParcelAggregation_3D() -> None:
@@ -85,8 +132,8 @@ def test_ParcelAggregation_3D() -> None:
         )
 
         parcel_agg_mean_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
         # Check that arrays are almost equal
         assert_array_equal(parcel_agg_mean_bold_data, manual)
         assert_array_almost_equal(nifti_labels_masked_bold, manual)
@@ -113,8 +160,8 @@ def test_ParcelAggregation_3D() -> None:
             on="BOLD",
         )
         parcel_agg_std_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
         assert parcel_agg_std_bold_data.ndim == 2
         assert parcel_agg_std_bold_data.shape[0] == 1
         assert_array_equal(parcel_agg_std_bold_data, manual)
@@ -139,7 +186,7 @@ def test_ParcelAggregation_3D() -> None:
         )
         parcel_agg_trim_mean_bold_data = marker.fit_transform(element_data)[
             "BOLD"
-        ]["data"]
+        ]["aggregation"]["data"]
         assert parcel_agg_trim_mean_bold_data.ndim == 2
         assert parcel_agg_trim_mean_bold_data.shape[0] == 1
         assert_array_equal(parcel_agg_trim_mean_bold_data, manual)
@@ -154,8 +201,8 @@ def test_ParcelAggregation_4D():
             parcellation="TianxS1x3TxMNInonlinear2009cAsym", method="mean"
         )
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing parcellation
@@ -204,7 +251,8 @@ def test_ParcelAggregation_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_ParcelAggregation" for x in features.values()
+            x["name"] == "BOLD_ParcelAggregation_aggregation"
+            for x in features.values()
         )
 
     # Store 4D
@@ -221,7 +269,8 @@ def test_ParcelAggregation_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_ParcelAggregation" for x in features.values()
+            x["name"] == "BOLD_ParcelAggregation_aggregation"
+            for x in features.values()
         )
 
 
@@ -241,8 +290,8 @@ def test_ParcelAggregation_3D_mask() -> None:
             ..., 0:1
         ]
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing parcellation
@@ -316,8 +365,8 @@ def test_ParcelAggregation_3D_mask_computed() -> None:
             on="BOLD",
         )
         parcel_agg_mean_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         assert parcel_agg_mean_bold_data.ndim == 2
         assert parcel_agg_mean_bold_data.shape[0] == 1
@@ -397,7 +446,9 @@ def test_ParcelAggregation_3D_multiple_non_overlapping(tmp_path: Path) -> None:
             name="tian_mean",
             on="BOLD",
         )
-        orig_mean = marker_original.fit_transform(element_data)["BOLD"]
+        orig_mean = marker_original.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]
 
         orig_mean_data = orig_mean["data"]
         assert orig_mean_data.ndim == 2
@@ -417,7 +468,9 @@ def test_ParcelAggregation_3D_multiple_non_overlapping(tmp_path: Path) -> None:
         # No warnings should be raised
         with warnings.catch_warnings():
             warnings.simplefilter("error", category=UserWarning)
-            split_mean = marker_split.fit_transform(element_data)["BOLD"]
+            split_mean = marker_split.fit_transform(element_data)["BOLD"][
+                "aggregation"
+            ]
 
         split_mean_data = split_mean["data"]
 
@@ -497,7 +550,9 @@ def test_ParcelAggregation_3D_multiple_overlapping(tmp_path: Path) -> None:
             name="tian_mean",
             on="BOLD",
         )
-        orig_mean = marker_original.fit_transform(element_data)["BOLD"]
+        orig_mean = marker_original.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]
 
         orig_mean_data = orig_mean["data"]
         assert orig_mean_data.ndim == 2
@@ -515,7 +570,9 @@ def test_ParcelAggregation_3D_multiple_overlapping(tmp_path: Path) -> None:
         )
         # Warning should be raised
         with pytest.warns(RuntimeWarning, match="overlapping voxels"):
-            split_mean = marker_split.fit_transform(element_data)["BOLD"]
+            split_mean = marker_split.fit_transform(element_data)["BOLD"][
+                "aggregation"
+            ]
 
         split_mean_data = split_mean["data"]
 
@@ -602,7 +659,9 @@ def test_ParcelAggregation_3D_multiple_duplicated_labels(
             name="tian_mean",
             on="BOLD",
         )
-        orig_mean = marker_original.fit_transform(element_data)["BOLD"]
+        orig_mean = marker_original.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]
 
         orig_mean_data = orig_mean["data"]
         assert orig_mean_data.ndim == 2
@@ -621,7 +680,9 @@ def test_ParcelAggregation_3D_multiple_duplicated_labels(
 
         # Warning should be raised
         with pytest.warns(RuntimeWarning, match="duplicated labels."):
-            split_mean = marker_split.fit_transform(element_data)["BOLD"]
+            split_mean = marker_split.fit_transform(element_data)["BOLD"][
+                "aggregation"
+            ]
 
         split_mean_data = split_mean["data"]
 
@@ -653,8 +714,8 @@ def test_ParcelAggregation_4D_agg_time():
             on="BOLD",
         )
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Loading testing parcellation
@@ -689,8 +750,8 @@ def test_ParcelAggregation_4D_agg_time():
             on="BOLD",
         )
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         assert parcel_agg_bold_data.ndim == 2
         assert_array_equal(