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

junifer/markers/falff/tests/test_falff_spheres.py

@@ -21,28 +21,6 @@ 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.
 
@@ -63,6 +41,7 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Initialize marker
             marker = ALFFSpheres(
                 coords=COORDINATES,
+                fractional=False,
                 using="junifer",
                 radius=5.0,
             )
@@ -73,16 +52,15 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
             # Get BOLD output
             assert "BOLD" in output
-            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 = 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 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()
@@ -100,13 +78,18 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_ALFFSpheres_comparison(tmp_path: Path) -> None:
+@pytest.mark.parametrize(
+    "fractional", [True, False], ids=["fractional", "non-fractional"]
+)
+def test_ALFFSpheres_comparison(tmp_path: Path, fractional: bool) -> 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:
@@ -117,6 +100,7 @@ def test_ALFFSpheres_comparison(tmp_path: Path) -> None:
         # Initialize marker
         junifer_marker = ALFFSpheres(
             coords=COORDINATES,
+            fractional=fractional,
             using="junifer",
             radius=5.0,
         )
@@ -128,6 +112,7 @@ def test_ALFFSpheres_comparison(tmp_path: Path) -> None:
         # Initialize marker
         afni_marker = ALFFSpheres(
             coords=COORDINATES,
+            fractional=fractional,
             using="afni",
             radius=5.0,
         )
@@ -136,10 +121,9 @@ def test_ALFFSpheres_comparison(tmp_path: Path) -> None:
         # Get BOLD output
         afni_output_bold = afni_output["BOLD"]
 
-        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
+        # Check for Pearson correlation coefficient
+        r, _ = sp.stats.pearsonr(
+            junifer_output_bold["data"][0],
+            afni_output_bold["data"][0],
+        )
+        assert r > 0.99

junifer/markers/functional_connectivity/__init__.py

@@ -8,12 +8,3 @@ from .functional_connectivity_spheres import FunctionalConnectivitySpheres
 from .crossparcellation_functional_connectivity import CrossParcellationFC
 from .edge_functional_connectivity_parcels import EdgeCentricFCParcels
 from .edge_functional_connectivity_spheres import EdgeCentricFCSpheres
-
-
-__all__ = [
-    "FunctionalConnectivityParcels",
-    "FunctionalConnectivitySpheres",
-    "CrossParcellationFC",
-    "EdgeCentricFCParcels",
-    "EdgeCentricFCSpheres",
-]

junifer/markers/functional_connectivity/crossparcellation_functional_connectivity.py

@@ -15,9 +15,6 @@ from ..parcel_aggregation import ParcelAggregation
 from ..utils import _correlate_dataframes
 
 
-__all__ = ["CrossParcellationFC"]
-
-
 @register_marker
 class CrossParcellationFC(BaseMarker):
     """Class for calculating parcel-wise correlations with 2 parcellations.
@@ -28,42 +25,29 @@ class CrossParcellationFC(BaseMarker):
         The name of the first parcellation.
     parcellation_two : str
         The name of the second parcellation.
-    agg_method : str, optional
-        The method to perform aggregation using.
-        See :func:`.get_aggfunc_by_name` for options
-        (default "mean").
-    agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        See :func:`.get_aggfunc_by_name` for options
-        (default None).
-    corr_method : str, optional
+    aggregation_method : str, optional
+        The aggregation method (default "mean").
+    correlation_method : str, optional
         Any method that can be passed to
-        :meth:`pandas.DataFrame.corr` (default "pearson").
+        :any:`pandas.DataFrame.corr` (default "pearson").
     masks : str, dict or list of dict or str, 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
-        ``BOLD_CrossParcellationFC`` (default None).
+        The name of the marker. If None, will use the class name
+        (default None).
 
     """
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "BOLD": {
-            "functional_connectivity": "matrix",
-        },
-    }
-
     def __init__(
         self,
         parcellation_one: str,
         parcellation_two: str,
-        agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
-        corr_method: str = "pearson",
+        aggregation_method: str = "mean",
+        correlation_method: str = "pearson",
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -73,12 +57,38 @@ class CrossParcellationFC(BaseMarker):
             )
         self.parcellation_one = parcellation_one
         self.parcellation_two = parcellation_two
-        self.agg_method = agg_method
-        self.agg_method_params = agg_method_params
-        self.corr_method = corr_method
+        self.aggregation_method = aggregation_method
+        self.correlation_method = correlation_method
         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],
@@ -105,14 +115,10 @@ 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:
 
-            * ``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
+            * ``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
 
         """
         logger.debug(
@@ -120,40 +126,31 @@ class CrossParcellationFC(BaseMarker):
             f" {self.parcellation_one} and "
             f"{self.parcellation_two} parcellations."
         )
-        # Perform aggregation using two parcellations
-        aggregation_parcellation_one = ParcelAggregation(
+        # Initialize a ParcelAggregation
+        parcellation_one_dict = ParcelAggregation(
             parcellation=self.parcellation_one,
-            method=self.agg_method,
-            method_params=self.agg_method_params,
+            method=self.aggregation_method,
             masks=self.masks,
-            on="BOLD",
         ).compute(input, extra_input=extra_input)
-        aggregation_parcellation_two = ParcelAggregation(
+        parcellation_two_dict = ParcelAggregation(
             parcellation=self.parcellation_two,
-            method=self.agg_method,
-            method_params=self.agg_method_params,
+            method=self.aggregation_method,
             masks=self.masks,
-            on="BOLD",
         ).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 {
-            "functional_connectivity": {
-                "data": _correlate_dataframes(
-                    pd.DataFrame(
-                        aggregation_parcellation_one["aggregation"]["data"]
-                    ),
-                    pd.DataFrame(
-                        aggregation_parcellation_two["aggregation"]["data"]
-                    ),
-                    method=self.corr_method,
-                ).values,
-                # Columns should be named after parcellation 1
-                "col_names": aggregation_parcellation_one["aggregation"][
-                    "col_names"
-                ],
-                # Rows should be named after parcellation 2
-                "row_names": aggregation_parcellation_two["aggregation"][
-                    "col_names"
-                ],
-            },
+            "data": result,
+            "col_names": parcellation_one_dict["col_names"],
+            "row_names": parcellation_two_dict["col_names"],
         }

junifer/markers/functional_connectivity/edge_functional_connectivity_parcels.py

@@ -12,9 +12,6 @@ from ..utils import _ets
 from .functional_connectivity_base import FunctionalConnectivityBase
 
 
-__all__ = ["EdgeCentricFCParcels"]
-
-
 @register_marker
 class EdgeCentricFCParcels(FunctionalConnectivityBase):
     """Class for edge-centric FC using parcellations.
@@ -22,40 +19,36 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
     Parameters
     ----------
     parcellation : str or list of str
-        The name(s) of the parcellation(s) to use.
-        See :func:`.list_parcellations` for options.
+        The name(s) of the parcellation(s). Check valid options by calling
+        :func:`.list_parcellations`.
     agg_method : str, optional
-        The method to perform aggregation using.
-        See :func:`.get_aggfunc_by_name` for options
+        The method to perform aggregation of BOLD time series.
+        Check valid options in :func:`.get_aggfunc_by_name`
         (default "mean").
     agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        See :func:`.get_aggfunc_by_name` for options
-        (default None).
-    conn_method : str, optional
-        The method to perform connectivity measure using.
-        See :class:`.JuniferConnectivityMeasure` for options
-        (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
-        If None, ``{"empirical": True}`` will be used, which would mean
-        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
-        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
-        desired, ``{"empirical": False}`` should be passed
-        (default None).
+        Parameters to pass to the aggregation function. Check valid options in
+        :func:`.get_aggfunc_by_name` (default None).
+    cor_method : str, optional
+        The method to perform correlation. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure`
+        (default "covariance").
+    cor_method_params : dict, optional
+        Parameters to pass to the correlation function. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
     masks : str, dict or list of dict or str, 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
-        ``BOLD_EdgeCentricFCParcels`` (default None).
+        The name of the marker. If None, will use the class name (default
+        None).
 
     References
     ----------
     .. [1] Jo et al. (2021)
-           Subject identification using edge-centric functional connectivity.
-           https://doi.org/10.1016/j.neuroimage.2021.118204
+            Subject identification using
+            edge-centric functional connectivity
+            doi: https://doi.org/10.1016/j.neuroimage.2021.118204
 
     """
 
@@ -64,8 +57,8 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
         parcellation: Union[str, List[str]],
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        conn_method: str = "correlation",
-        conn_method_params: Optional[Dict] = None,
+        cor_method: str = "covariance",
+        cor_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -73,8 +66,8 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
+            cor_method=cor_method,
+            cor_method_params=cor_method_params,
             masks=masks,
             name=name,
         )
@@ -102,29 +95,23 @@ 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:
 
-            * ``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
 
         """
-        # Perform aggregation
-        aggregation = ParcelAggregation(
+        parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(input, extra_input=extra_input)
-        # Compute edgewise timeseries
+        )
+
+        bold_aggregated = parcel_aggregation.compute(
+            input, extra_input=extra_input
+        )
         ets, edge_names = _ets(
-            bold_ts=aggregation["aggregation"]["data"],
-            roi_names=aggregation["aggregation"]["col_names"],
+            bold_aggregated["data"], bold_aggregated["col_names"]
         )
 
-        return {
-            "aggregation": {
-                "data": ets,
-                "col_names": edge_names,
-            },
-        }
+        return {"data": ets, "col_names": edge_names}

junifer/markers/functional_connectivity/edge_functional_connectivity_spheres.py

@@ -12,9 +12,6 @@ from ..utils import _ets, raise_error
 from .functional_connectivity_base import FunctionalConnectivityBase
 
 
-__all__ = ["EdgeCentricFCSpheres"]
-
-
 @register_marker
 class EdgeCentricFCSpheres(FunctionalConnectivityBase):
     """Class for edge-centric FC using coordinates (spheres).
@@ -22,48 +19,42 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
     Parameters
     ----------
     coords : str
-        The name of the coordinates list to use.
-        See :func:`.list_coordinates` for options.
-    radius : positive float, optional
-        The radius of the sphere around each coordinates in millimetres.
-        If None, the signal will be extracted from a single voxel.
-        See :class:`.JuniferNiftiSpheresMasker` for more information
-        (default None).
+        The name of the coordinates list to use. See
+        :func:`.list_coordinates` for options.
+    radius : float, optional
+        The radius of the sphere in mm. If None, the signal will be extracted
+        from a single voxel. See :class:`nilearn.maskers.NiftiSpheresMasker`
+        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 False).
+        the spheres overlap (default is False).
     agg_method : str, optional
-        The method to perform aggregation using.
-        See :func:`.get_aggfunc_by_name` for options
-        (default "mean").
-    agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        See :func:`.get_aggfunc_by_name` for options
-        (default None).
-    conn_method : str, optional
-        The method to perform connectivity measure using.
-        See :class:`.JuniferConnectivityMeasure` for options
-        (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
-        If None, ``{"empirical": True}`` will be used, which would mean
-        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
-        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
-        desired, ``{"empirical": False}`` should be passed
+        The aggregation method to use.
+        See :func:`.get_aggfunc_by_name` for more information
         (default None).
+    agg_method_params : dict, optional
+        The parameters to pass to the aggregation method (default None).
+    cor_method : str, optional
+        The method to perform correlation using. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure` (default "covariance").
+    cor_method_params : dict, optional
+        Parameters to pass to the correlation function. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
     masks : str, dict or list of dict or str, 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
-        ``BOLD_EdgeCentricFCSpheres`` (default None).
+        The name of the marker. By default, it will use
+        KIND_EdgeCentricFCSpheres where KIND is the kind of data it
+        was applied to (default None).
 
     References
     ----------
     .. [1] Jo et al. (2021)
-           Subject identification using edge-centric functional connectivity.
-           https://doi.org/10.1016/j.neuroimage.2021.118204
+            Subject identification using
+            edge-centric functional connectivity
+            doi: https://doi.org/10.1016/j.neuroimage.2021.118204
 
     """
 
@@ -74,8 +65,8 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
         allow_overlap: bool = False,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        conn_method: str = "correlation",
-        conn_method_params: Optional[Dict] = None,
+        cor_method: str = "covariance",
+        cor_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -87,8 +78,8 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
+            cor_method=cor_method,
+            cor_method_params=cor_method_params,
             masks=masks,
             name=name,
         )
@@ -116,14 +107,11 @@ 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:
 
-            * ``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
 
         """
-        # Perform aggregation
-        aggregation = SphereAggregation(
+        sphere_aggregation = SphereAggregation(
             coords=self.coords,
             radius=self.radius,
             allow_overlap=self.allow_overlap,
@@ -131,13 +119,12 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(input, extra_input=extra_input)
-        # Compute edgewise timeseries
+        )
+        bold_aggregated = sphere_aggregation.compute(
+            input, extra_input=extra_input
+        )
         ets, edge_names = _ets(
-            bold_ts=aggregation["aggregation"]["data"],
-            roi_names=aggregation["aggregation"]["col_names"],
+            bold_aggregated["data"], bold_aggregated["col_names"]
         )
 
-        return {
-            "aggregation": {"data": ets, "col_names": edge_names},
-        }
+        return {"data": ets, "col_names": edge_names}