junifer 0.0.5.dev183__py3-none-any.whl → 0.0.5.dev202__py3-none-any.whl

junifer/markers/falff/tests/test_falff_spheres.py

@@ -21,6 +21,28 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 COORDINATES = "DMNBuckner"
 
 
+@pytest.mark.parametrize(
+    "feature",
+    [
+        "alff",
+        "falff",
+    ],
+)
+def test_ALFFSpheres_get_output_type(feature: str) -> None:
+    """Test ALFFSpheres get_output_type().
+
+    Parameters
+    ----------
+    feature : str
+        The parametrized feature name.
+
+    """
+    assert "vector" == ALFFSpheres(
+        coords=COORDINATES,
+        using="junifer",
+    ).get_output_type(input_type="BOLD", output_feature=feature)
+
+
 def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
     """Test ALFFSpheres.
 
@@ -41,7 +63,6 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Initialize marker
             marker = ALFFSpheres(
                 coords=COORDINATES,
-                fractional=False,
                 using="junifer",
                 radius=5.0,
             )
@@ -52,15 +73,16 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # 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
+            for feature in output["BOLD"].keys():
+                output_bold = output["BOLD"][feature]
+                # 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 output_bold_data.shape == (1, 6)
+                output_bold_data = output_bold["data"]
+                # Assert BOLD output data dimension
+                assert output_bold_data.ndim == 2
+                assert output_bold_data.shape == (1, 6)
 
             # Reset log capture
             caplog.clear()
@@ -78,18 +100,13 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-@pytest.mark.parametrize(
-    "fractional", [True, False], ids=["fractional", "non-fractional"]
-)
-def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
+def test_ALFFSpheres_comparison(tmp_path: Path) -> None:
     """Test ALFFSpheres implementation comparison.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
-    fractional : bool
-        Whether to compute fractional ALFF or not.
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
@@ -100,7 +117,6 @@ def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
         # Initialize marker
         junifer_marker = ALFFSpheres(
             coords=COORDINATES,
-            fractional=fractional,
             using="junifer",
             radius=5.0,
         )
@@ -112,7 +128,6 @@ def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
         # Initialize marker
         afni_marker = ALFFSpheres(
             coords=COORDINATES,
-            fractional=fractional,
             using="afni",
             radius=5.0,
         )
@@ -121,9 +136,10 @@ def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> None:
         # Get BOLD output
         afni_output_bold = afni_output["BOLD"]
 
-        # Check for Pearson correlation coefficient
-        r, _ = sp.stats.pearsonr(
-            junifer_output_bold["data"][0],
-            afni_output_bold["data"][0],
-        )
-        assert r > 0.99
+        for feature in afni_output_bold.keys():
+            # Check for Pearson correlation coefficient
+            r, _ = sp.stats.pearsonr(
+                junifer_output_bold[feature]["data"][0],
+                afni_output_bold[feature]["data"][0],
+            )
+            assert r > 0.99

junifer/markers/functional_connectivity/crossparcellation_functional_connectivity.py

@@ -45,6 +45,12 @@ class CrossParcellationFC(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "functional_connectivity": "matrix",
+        },
+    }
+
     def __init__(
         self,
         parcellation_one: str,
@@ -65,33 +71,6 @@ class CrossParcellationFC(BaseMarker):
         self.masks = masks
         super().__init__(on=["BOLD"], name=name)
 
-    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 "matrix"
-
     def compute(
         self,
         input: Dict[str, Any],
@@ -118,10 +97,14 @@ class CrossParcellationFC(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:
 
-            * ``data`` : the correlation values between the two parcellations
-              as a numpy.ndarray
-            * ``col_names`` : the ROIs for first parcellation as a list
-            * ``row_names`` : the ROIs for second parcellation as a list
+            * ``functional_connectivity`` : dictionary with the following keys:
+
+              - ``data`` : correlation between the two parcellations as
+                           ``numpy.ndarray``
+              - ``col_names`` : ROI labels for first parcellation as list of
+                                str
+              - ``row_names`` : ROI labels for second parcellation as list of
+                                str
 
         """
         logger.debug(
@@ -129,31 +112,32 @@ class CrossParcellationFC(BaseMarker):
             f" {self.parcellation_one} and "
             f"{self.parcellation_two} parcellations."
         )
-        # Initialize a ParcelAggregation
-        parcellation_one_dict = ParcelAggregation(
+        # Perform aggregation using two parcellations
+        aggregation_parcellation_one = ParcelAggregation(
             parcellation=self.parcellation_one,
             method=self.aggregation_method,
             masks=self.masks,
         ).compute(input, extra_input=extra_input)
-        parcellation_two_dict = ParcelAggregation(
+        aggregation_parcellation_two = ParcelAggregation(
             parcellation=self.parcellation_two,
             method=self.aggregation_method,
             masks=self.masks,
         ).compute(input, extra_input=extra_input)
 
-        parcellated_ts_one = parcellation_one_dict["data"]
-        parcellated_ts_two = parcellation_two_dict["data"]
-        # columns should be named after parcellation 1
-        # rows should be named after parcellation 2
-
-        result = _correlate_dataframes(
-            pd.DataFrame(parcellated_ts_one),
-            pd.DataFrame(parcellated_ts_two),
-            method=self.correlation_method,
-        ).values
-
         return {
-            "data": result,
-            "col_names": parcellation_one_dict["col_names"],
-            "row_names": parcellation_two_dict["col_names"],
+            "functional_connectivity": {
+                "data": _correlate_dataframes(
+                    pd.DataFrame(
+                        aggregation_parcellation_one["aggregation"]["data"]
+                    ),
+                    pd.DataFrame(
+                        aggregation_parcellation_two["aggregation"]["data"]
+                    ),
+                    method=self.correlation_method,
+                ).values,
+                # Columns should be named after parcellation 1
+                "col_names": aggregation_parcellation_one["col_names"],
+                # Rows should be named after parcellation 2
+                "row_names": aggregation_parcellation_two["col_names"],
+            },
         }

junifer/markers/functional_connectivity/edge_functional_connectivity_parcels.py

@@ -98,23 +98,29 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
             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`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        parcel_aggregation = ParcelAggregation(
+        # Perform aggregation
+        aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-
-        bold_aggregated = parcel_aggregation.compute(
-            input, extra_input=extra_input
-        )
+        ).compute(input, extra_input=extra_input)
+        # Compute edgewise timeseries
         ets, edge_names = _ets(
-            bold_aggregated["data"], bold_aggregated["col_names"]
+            bold_ts=aggregation["aggregation"]["data"],
+            roi_names=aggregation["aggregation"]["col_names"],
         )
 
-        return {"data": ets, "col_names": edge_names}
+        return {
+            "aggregation": {
+                "data": ets,
+                "col_names": edge_names,
+            },
+        }

junifer/markers/functional_connectivity/edge_functional_connectivity_spheres.py

@@ -110,11 +110,14 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
             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`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        sphere_aggregation = SphereAggregation(
+        # Perform aggregation
+        aggregation = SphereAggregation(
             coords=self.coords,
             radius=self.radius,
             allow_overlap=self.allow_overlap,
@@ -122,12 +125,13 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        bold_aggregated = sphere_aggregation.compute(
-            input, extra_input=extra_input
-        )
+        ).compute(input, extra_input=extra_input)
+        # Compute edgewise timeseries
         ets, edge_names = _ets(
-            bold_aggregated["data"], bold_aggregated["col_names"]
+            bold_ts=aggregation["aggregation"]["data"],
+            roi_names=aggregation["aggregation"]["col_names"],
         )
 
-        return {"data": ets, "col_names": edge_names}
+        return {
+            "aggregation": {"data": ets, "col_names": edge_names},
+        }

junifer/markers/functional_connectivity/functional_connectivity_base.py

@@ -47,6 +47,12 @@ class FunctionalConnectivityBase(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "scikit-learn"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "functional_connectivity": "matrix",
+        },
+    }
+
     def __init__(
         self,
         agg_method: str = "mean",
@@ -80,33 +86,6 @@ class FunctionalConnectivityBase(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 "matrix"
-
     def compute(
         self,
         input: Dict[str, Any],
@@ -128,13 +107,16 @@ class FunctionalConnectivityBase(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:
+
+            * ``functional_connectivity`` : dictionary with the following keys:
 
-            * ``data`` : functional connectivity matrix as a ``numpy.ndarray``.
-            * ``row_names`` : row names as a list
-            * ``col_names`` : column names as a list
-            * ``matrix_kind`` : the kind of matrix (tril, triu or full)
+              - ``data`` : functional connectivity matrix as ``numpy.ndarray``
+              - ``row_names`` : ROI labels as list of str
+              - ``col_names`` : ROI labels as list of str
+              - ``matrix_kind`` : the kind of matrix (tril, triu or full)
 
         """
         # Perform necessary aggregation
@@ -148,10 +130,14 @@ class FunctionalConnectivityBase(BaseMarker):
         else:
             connectivity = ConnectivityMeasure(kind=self.cor_method)
         # Create dictionary for output
-        out = {}
-        out["data"] = connectivity.fit_transform([aggregation["data"]])[0]
-        # Create column names
-        out["row_names"] = aggregation["col_names"]
-        out["col_names"] = aggregation["col_names"]
-        out["matrix_kind"] = "tril"
-        return out
+        return {
+            "functional_connectivity": {
+                "data": connectivity.fit_transform(
+                    [aggregation["aggregation"]["data"]]
+                )[0],
+                # Create column names
+                "row_names": aggregation["aggregation"]["col_names"],
+                "col_names": aggregation["aggregation"]["col_names"],
+                "matrix_kind": "tril",
+            },
+        }

junifer/markers/functional_connectivity/functional_connectivity_parcels.py

@@ -90,16 +90,16 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
             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`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI 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, extra_input=extra_input)
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/functional_connectivity/functional_connectivity_spheres.py

@@ -104,11 +104,13 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
             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`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI 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,
@@ -116,6 +118,4 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Return the 2D timeseries after sphere aggregation
-        return sphere_aggregation.compute(input, extra_input=extra_input)
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/functional_connectivity/tests/test_crossparcellation_functional_connectivity.py

@@ -33,10 +33,11 @@ def test_init() -> None:
 
 def test_get_output_type() -> None:
     """Test CrossParcellationFC get_output_type()."""
-    crossparcellation = CrossParcellationFC(
+    assert "matrix" == CrossParcellationFC(
         parcellation_one=parcellation_one, parcellation_two=parcellation_two
+    ).get_output_type(
+        input_type="BOLD", output_feature="functional_connectivity"
     )
-    assert "matrix" == crossparcellation.get_output_type("BOLD")
 
 
 @pytest.mark.skipif(
@@ -59,7 +60,9 @@ def test_compute(tmp_path: Path) -> None:
             parcellation_two=parcellation_two,
             correlation_method="spearman",
         )
-        out = crossparcellation.compute(element_data["BOLD"])
+        out = crossparcellation.compute(element_data["BOLD"])[
+            "functional_connectivity"
+        ]
         assert out["data"].shape == (200, 100)
         assert len(out["col_names"]) == 100
         assert len(out["row_names"]) == 200
@@ -92,5 +95,6 @@ def test_store(tmp_path: Path) -> None:
         crossparcellation.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_CrossParcellationFC" for x in features.values()
+            x["name"] == "BOLD_CrossParcellationFC_functional_connectivity"
+            for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_parcels.py

@@ -28,11 +28,13 @@ def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
             cor_method_params={"empirical": True},
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         edge_fc = marker.fit_transform(element_data)
-        edge_fc_bold = edge_fc["BOLD"]
+        edge_fc_bold = edge_fc["BOLD"]["functional_connectivity"]
 
         # For 16 ROIs we should get (16 * (16 -1) / 2) edges in the ETS
         n_edges = int(16 * (16 - 1) / 2)
@@ -51,5 +53,6 @@ def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_EdgeCentricFCParcels" for x in features.values()
+            x["name"] == "BOLD_EdgeCentricFCParcels_functional_connectivity"
+            for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_spheres.py

@@ -27,11 +27,13 @@ def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
             coords="DMNBuckner", radius=5.0, cor_method="correlation"
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         edge_fc = marker.fit_transform(element_data)
-        edge_fc_bold = edge_fc["BOLD"]
+        edge_fc_bold = edge_fc["BOLD"]["functional_connectivity"]
 
         # There are six DMNBuckner coordinates, so
         # for 6 ROIs we should get (6 * (6 -1) / 2) edges in the ETS
@@ -57,5 +59,6 @@ def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_EdgeCentricFCSpheres" for x in features.values()
+            x["name"] == "BOLD_EdgeCentricFCSpheres_functional_connectivity"
+            for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_functional_connectivity_parcels.py

@@ -35,11 +35,13 @@ def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
             parcellation="TianxS1x3TxMNInonlinear2009cAsym"
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]
+        fc_bold = fc["BOLD"]["functional_connectivity"]
 
         assert "data" in fc_bold
         assert "row_names" in fc_bold
@@ -83,6 +85,7 @@ def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_FunctionalConnectivityParcels"
+            x["name"]
+            == "BOLD_FunctionalConnectivityParcels_functional_connectivity"
             for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_functional_connectivity_spheres.py

@@ -38,11 +38,13 @@ def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
             coords="DMNBuckner", radius=5.0, cor_method="correlation"
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]
+        fc_bold = fc["BOLD"]["functional_connectivity"]
 
         assert "data" in fc_bold
         assert "row_names" in fc_bold
@@ -80,7 +82,8 @@ def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_FunctionalConnectivitySpheres"
+            x["name"]
+            == "BOLD_FunctionalConnectivitySpheres_functional_connectivity"
             for x in features.values()
         )
 
@@ -103,11 +106,13 @@ def test_FunctionalConnectivitySpheres_empirical(tmp_path: Path) -> None:
             cor_method_params={"empirical": True},
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]
+        fc_bold = fc["BOLD"]["functional_connectivity"]
 
         assert "data" in fc_bold
         assert "row_names" in fc_bold