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

junifer/markers/reho/tests/test_reho_parcels.py

@@ -42,11 +42,6 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
                 parcellation="TianxS1x3TxMNInonlinear2009cAsym",
                 using="junifer",
             )
-            # Check correct output
-            assert "vector" == marker.get_output_type(
-                input_type="BOLD", output_feature="reho"
-            )
-
             # Fit transform marker on data
             output = marker.fit_transform(element_data)
 
@@ -54,7 +49,7 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # Get BOLD output
             assert "BOLD" in output
-            output_bold = output["BOLD"]["reho"]
+            output_bold = output["BOLD"]
             # Assert BOLD output keys
             assert "data" in output_bold
             assert "col_names" in output_bold
@@ -107,14 +102,14 @@ def test_ReHoParcels_comparison(tmp_path: Path) -> None:
         # Fit transform marker on data
         junifer_output = junifer_marker.fit_transform(element_data)
         # Get BOLD output
-        junifer_output_bold = junifer_output["BOLD"]["reho"]
+        junifer_output_bold = junifer_output["BOLD"]
 
         # Initialize marker
         afni_marker = ReHoParcels(parcellation="Schaefer100x7", using="afni")
         # Fit transform marker on data
         afni_output = afni_marker.fit_transform(element_data)
         # Get BOLD output
-        afni_output_bold = afni_output["BOLD"]["reho"]
+        afni_output_bold = afni_output["BOLD"]
 
         # Check for Pearson correlation coefficient
         r, _ = sp.stats.pearsonr(

junifer/markers/reho/tests/test_reho_spheres.py

@@ -40,11 +40,6 @@ def test_ReHoSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             marker = ReHoSpheres(
                 coords=COORDINATES, using="junifer", radius=10.0
             )
-            # Check correct output
-            assert "vector" == marker.get_output_type(
-                input_type="BOLD", output_feature="reho"
-            )
-
             # Fit transform marker on data
             output = marker.fit_transform(element_data)
 
@@ -52,7 +47,7 @@ def test_ReHoSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # Get BOLD output
             assert "BOLD" in output
-            output_bold = output["BOLD"]["reho"]
+            output_bold = output["BOLD"]
             # Assert BOLD output keys
             assert "data" in output_bold
             assert "col_names" in output_bold
@@ -104,7 +99,7 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         # Fit transform marker on data
         junifer_output = junifer_marker.fit_transform(element_data)
         # Get BOLD output
-        junifer_output_bold = junifer_output["BOLD"]["reho"]
+        junifer_output_bold = junifer_output["BOLD"]
 
         # Initialize marker
         afni_marker = ReHoSpheres(
@@ -115,7 +110,7 @@ def test_ReHoSpheres_comparison(tmp_path: Path) -> None:
         # Fit transform marker on data
         afni_output = afni_marker.fit_transform(element_data)
         # Get BOLD output
-        afni_output_bold = afni_output["BOLD"]["reho"]
+        afni_output_bold = afni_output["BOLD"]
 
         # Check for Pearson correlation coefficient
         r, _ = sp.stats.pearsonr(

junifer/markers/sphere_aggregation.py

@@ -14,9 +14,6 @@ from ..utils import logger, raise_error, warn_with_log
 from .base import BaseMarker
 
 
-__all__ = ["SphereAggregation"]
-
-
 @register_marker
 class SphereAggregation(BaseMarker):
     """Class for sphere aggregation.
@@ -68,36 +65,6 @@ class SphereAggregation(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "numpy"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "T1w": {
-            "aggregation": "vector",
-        },
-        "T2w": {
-            "aggregation": "vector",
-        },
-        "BOLD": {
-            "aggregation": "timeseries",
-        },
-        "VBM_GM": {
-            "aggregation": "vector",
-        },
-        "VBM_WM": {
-            "aggregation": "vector",
-        },
-        "VBM_CSF": {
-            "aggregation": "vector",
-        },
-        "fALFF": {
-            "aggregation": "vector",
-        },
-        "GCOR": {
-            "aggregation": "vector",
-        },
-        "LCOR": {
-            "aggregation": "vector",
-        },
-    }
-
     def __init__(
         self,
         coords: str,
@@ -133,6 +100,61 @@ class SphereAggregation(BaseMarker):
         self.time_method = time_method
         self.time_method_params = time_method_params or {}
 
+    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 [
+            "T1w",
+            "T2w",
+            "BOLD",
+            "VBM_GM",
+            "VBM_WM",
+            "VBM_CSF",
+            "fALFF",
+            "GCOR",
+            "LCOR",
+        ]
+
+    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.
+
+        Raises
+        ------
+        ValueError
+            If the ``input_type`` is invalid.
+
+        """
+
+        if input_type in [
+            "VBM_GM",
+            "VBM_WM",
+            "VBM_CSF",
+            "fALFF",
+            "GCOR",
+            "LCOR",
+        ]:
+            return "vector"
+        elif input_type == "BOLD":
+            return "timeseries"
+        else:
+            raise_error(f"Unknown input kind for {input_type}")
+
     def compute(
         self,
         input: Dict[str, Any],
@@ -158,10 +180,8 @@ class SphereAggregation(BaseMarker):
             to the user or stored in the storage by calling the store method
             with this as a parameter. The dictionary has the following keys:
 
-            * ``aggregation`` : dictionary with the following keys:
-
-                - ``data`` : ROI values as ``numpy.ndarray``
-                - ``col_names`` : ROI labels as list of str
+            * ``data`` : the actual computed values as a numpy.ndarray
+            * ``col_names`` : the column labels for the computed values as list
 
         Warns
         -----
@@ -218,9 +238,5 @@ class SphereAggregation(BaseMarker):
                     "available."
                 )
         # Format the output
-        return {
-            "aggregation": {
-                "data": out_values,
-                "col_names": labels,
-            },
-        }
+        out = {"data": out_values, "col_names": labels}
+        return out

junifer/markers/temporal_snr/__init__.py

@@ -5,6 +5,3 @@
 
 from .temporal_snr_parcels import TemporalSNRParcels
 from .temporal_snr_spheres import TemporalSNRSpheres
-
-
-__all__ = ["TemporalSNRParcels", "TemporalSNRSpheres"]

junifer/markers/temporal_snr/temporal_snr_base.py

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

junifer/markers/temporal_snr/temporal_snr_parcels.py

@@ -10,9 +10,6 @@ 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.
@@ -77,16 +74,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:
 
-            * ``aggregation`` : dictionary with the following keys:
-
-                - ``data`` : ROI-wise tSNR values as ``numpy.ndarray``
-                - ``col_names`` : ROI labels as list of str
+            * ``data`` : ROI-wise temporal SNR as a ``numpy.ndarray``
+            * ``col_names`` : the ROI labels for the computed values as list
 
         """
-        return 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)
+        )
+        # Return the 2D timeseries after parcel aggregation
+        return parcel_aggregation.compute(input=input, extra_input=extra_input)

junifer/markers/temporal_snr/temporal_snr_spheres.py

@@ -11,9 +11,6 @@ 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).
@@ -92,13 +89,11 @@ 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:
 
-            * ``aggregation`` : dictionary with the following keys:
-
-                - ``data`` : ROI-wise tSNR values as ``numpy.ndarray``
-                - ``col_names`` : ROI labels as list of str
+            * ``data`` : VOI-wise temporal SNR as a ``numpy.ndarray``
+            * ``col_names`` : the VOI labels for the computed values as list
 
         """
-        return SphereAggregation(
+        sphere_aggregation = SphereAggregation(
             coords=self.coords,
             radius=self.radius,
             allow_overlap=self.allow_overlap,
@@ -106,4 +101,6 @@ class TemporalSNRSpheres(TemporalSNRBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(input=input, extra_input=extra_input)
+        )
+        # Return the 2D timeseries after sphere aggregation
+        return sphere_aggregation.compute(input=input, extra_input=extra_input)

junifer/markers/temporal_snr/tests/test_temporal_snr_parcels.py

@@ -20,13 +20,11 @@ def test_TemporalSNRParcels_computation() -> None:
             parcellation="TianxS1x3TxMNInonlinear2009cAsym"
         )
         # Check correct output
-        assert "vector" == marker.get_output_type(
-            input_type="BOLD", output_feature="tsnr"
-        )
+        assert marker.get_output_type("BOLD") == "vector"
 
         # Fit-transform the data
         tsnr_parcels = marker.fit_transform(element_data)
-        tsnr_parcels_bold = tsnr_parcels["BOLD"]["tsnr"]
+        tsnr_parcels_bold = tsnr_parcels["BOLD"]
 
         assert "data" in tsnr_parcels_bold
         assert "col_names" in tsnr_parcels_bold
@@ -53,6 +51,5 @@ 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_tsnr"
-            for x in features.values()
+            x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
         )

junifer/markers/temporal_snr/tests/test_temporal_snr_spheres.py

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

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"]["aggregation"]
+            t_bold = out[t_name]["BOLD"]
             assert "data" in t_bold
             assert "col_names" in t_bold
             assert "meta" in t_bold
@@ -107,8 +107,7 @@ def test_marker_collection() -> None:
         for t_marker in markers:
             t_name = t_marker.name
             assert_array_equal(
-                out[t_name]["BOLD"]["aggregation"]["data"],
-                out2[t_name]["BOLD"]["aggregation"]["data"],
+                out[t_name]["BOLD"]["data"], out2[t_name]["BOLD"]["data"]
             )
 
 
@@ -202,20 +201,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"]["aggregation"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["aggregation"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["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"]["aggregation"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["aggregation"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["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"]["aggregation"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["aggregation"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore

junifer/markers/tests/test_ets_rss.py

@@ -26,9 +26,8 @@ def test_compute() -> None:
     with PartlyCloudyTestingDataGrabber() as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         # Compute the RSSETSMarker
-        rss_ets = RSSETSMarker(parcellation=PARCELLATION).compute(
-            element_data["BOLD"]
-        )
+        marker = RSSETSMarker(parcellation=PARCELLATION)
+        rss_ets = marker.compute(element_data["BOLD"])
 
         # Compare with nilearn
         # Load testing parcellation
@@ -42,14 +41,14 @@ def test_compute() -> None:
             element_data["BOLD"]["data"]
         )
         # Assert the dimension of timeseries
-        assert extacted_timeseries.shape[0] == len(rss_ets["rss_ets"]["data"])
+        assert extacted_timeseries.shape[0] == len(rss_ets["data"])
 
 
 def test_get_output_type() -> None:
     """Test RSS ETS get_output_type()."""
     assert "timeseries" == RSSETSMarker(
         parcellation=PARCELLATION
-    ).get_output_type(input_type="BOLD", output_feature="rss_ets")
+    ).get_output_type("BOLD")
 
 
 def test_store(tmp_path: Path) -> None:
@@ -62,17 +61,12 @@ 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")
-        # Compute the RSSETSMarker and store
-        _ = RSSETSMarker(parcellation=PARCELLATION).fit_transform(
-            input=element_data, storage=storage
-        )
-        # Retrieve features
+        # Store
+        marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
-        # Check marker name
-        assert any(
-            x["name"] == "BOLD_RSSETSMarker_rss_ets" for x in features.values()
-        )
+        assert any(x["name"] == "BOLD_RSSETSMarker" 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 {
-                "feat_1": {
-                    "data": "data",
-                    "col_names": ["columns"],
-                },
+                "data": "data",
+                "columns": "columns",
+                "row_names": "row_names",
             }
 
-    with pytest.raises(ValueError, match=r"cannot be computed on \['T1w'\]"):
-        MyBaseMarker(on=["BOLD", "T1w"])
+    with pytest.raises(ValueError, match=r"cannot be computed on \['T2w'\]"):
+        MyBaseMarker(on=["BOLD", "T2w"])
 
     # Create input for marker
     input_ = {
@@ -64,11 +64,12 @@ def test_base_marker_subclassing() -> None:
     output = marker.fit_transform(input=input_)  # process
     # Check output
     assert "BOLD" in output
-    assert "data" in output["BOLD"]["feat_1"]
-    assert "col_names" in output["BOLD"]["feat_1"]
+    assert "data" in output["BOLD"]
+    assert "columns" in output["BOLD"]
+    assert "row_names" in output["BOLD"]
 
-    assert "meta" in output["BOLD"]["feat_1"]
-    meta = output["BOLD"]["feat_1"]["meta"]
+    assert "meta" in output["BOLD"]
+    meta = output["BOLD"]["meta"]
     assert "datagrabber" in meta
     assert "element" in meta
     assert "datareader" in meta