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

junifer/markers/complexity/complexity_base.py

@@ -53,6 +53,12 @@ class ComplexityBase(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "neurokit2"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "complexity": "vector",
+        },
+    }
+
     def __init__(
         self,
         parcellation: Union[str, List[str]],
@@ -78,33 +84,6 @@ class ComplexityBase(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],
@@ -124,29 +103,30 @@ class ComplexityBase(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:
+
+           *  ``complexity`` : dictionary with the following keys:
 
-           * ``data`` : ROI-wise complexity measures as ``numpy.ndarray``
-           * ``col_names`` : ROI labels for the complexity measures as list
+                - ``data`` : ROI-wise complexity measures as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        # Initialize a ParcelAggregation
+        # Extract the 2D time series using ParcelAggregation
         parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Extract the 2D time series using parcel aggregation
-        parcel_aggregation_map = parcel_aggregation.compute(
-            input=input, extra_input=extra_input
-        )
-
+        ).compute(input=input, extra_input=extra_input)
         # Compute complexity measure
-        parcel_aggregation_map["data"] = self.compute_complexity(
-            parcel_aggregation_map["data"]
-        )
-
-        return parcel_aggregation_map
+        return {
+            "complexity": {
+                "data": self.compute_complexity(
+                    parcel_aggregation["aggregation"]["data"]
+                ),
+                "col_names": parcel_aggregation["aggregation"]["col_names"],
+            }
+        }

junifer/markers/complexity/tests/test_hurst_exponent.py

@@ -40,13 +40,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test HurstExponent get_output_type()."""
-    marker = HurstExponent(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == HurstExponent(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_multiscale_entropy_auc.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test MultiscaleEntropyAUC get_output_type()."""
-    marker = MultiscaleEntropyAUC(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == MultiscaleEntropyAUC(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_perm_entropy.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test PermEntropy get_output_type()."""
-    marker = PermEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == PermEntropy(parcellation=PARCELLATION).get_output_type(
+        input_type="BOLD", output_feature="complexity"
+    )
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_range_entropy.py

@@ -40,13 +40,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test RangeEntropy get_output_type()."""
-    marker = RangeEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == RangeEntropy(parcellation=PARCELLATION).get_output_type(
+        input_type="BOLD", output_feature="complexity"
+    )
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_range_entropy_auc.py

@@ -40,13 +40,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test RangeEntropyAUC get_output_type()."""
-    marker = RangeEntropyAUC(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == RangeEntropyAUC(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_sample_entropy.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test SampleEntropy get_output_type()."""
-    marker = SampleEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == SampleEntropy(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/complexity/tests/test_weighted_perm_entropy.py

@@ -39,13 +39,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test WeightedPermEntropy get_output_type()."""
-    marker = WeightedPermEntropy(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == WeightedPermEntropy(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(

junifer/markers/ets_rss.py

@@ -47,6 +47,12 @@ class RSSETSMarker(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "rss_ets": "timeseries",
+        },
+    }
+
     def __init__(
         self,
         parcellation: Union[str, List[str]],
@@ -61,33 +67,6 @@ class RSSETSMarker(BaseMarker):
         self.masks = masks
         super().__init__(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 "timeseries"
-
     def compute(
         self,
         input: Dict[str, Any],
@@ -109,8 +88,9 @@ class RSSETSMarker(BaseMarker):
         Returns
         -------
         dict
-            The computed result as dictionary. The dictionary has the following
-            keys:
+            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:
 
             * ``data`` : the actual computed values as a numpy.ndarray
             * ``col_names`` : the column labels for the computed values as list
@@ -124,20 +104,22 @@ class RSSETSMarker(BaseMarker):
 
         """
         logger.debug("Calculating root sum of squares of edgewise timeseries.")
-        # Initialize a ParcelAggregation
-        parcel_aggregation = ParcelAggregation(
+        # Perform aggregation
+        aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
-        )
-        # Compute the parcel aggregation
-        out = parcel_aggregation.compute(input=input, extra_input=extra_input)
-        edge_ts, _ = _ets(out["data"])
-        # Compute the RSS
-        out["data"] = np.sum(edge_ts**2, 1) ** 0.5
-        # Make it 2D
-        out["data"] = out["data"][:, np.newaxis]
-        # Set correct column label
-        out["col_names"] = ["root_sum_of_squares_ets"]
-        return out
+        ).compute(input=input, extra_input=extra_input)
+        # Compute edgewise timeseries
+        edge_ts, _ = _ets(aggregation["aggregation"]["data"])
+        # Compute the RSS of edgewise timeseries
+        rss = np.sum(edge_ts**2, 1) ** 0.5
+
+        return {
+            "rss_ets": {
+                # Make it 2D
+                "data": rss[:, np.newaxis],
+                "col_names": ["root_sum_of_squares_ets"],
+            }
+        }

junifer/markers/falff/falff_base.py

@@ -37,8 +37,6 @@ class ALFFBase(BaseMarker):
 
     Parameters
     ----------
-    fractional : bool
-        Whether to compute fractional ALFF.
     highpass : positive float
         Highpass cutoff frequency.
     lowpass : positive float
@@ -85,9 +83,15 @@ class ALFFBase(BaseMarker):
         },
     ]
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "alff": "vector",
+            "falff": "vector",
+        },
+    }
+
     def __init__(
         self,
-        fractional: bool,
         highpass: float,
         lowpass: float,
         using: str,
@@ -110,45 +114,12 @@ class ALFFBase(BaseMarker):
             )
         self.using = using
         self.tr = tr
-        self.fractional = fractional
-
-        # Create a name based on the class name if none is provided
-        if name is None:
-            suffix = "_fractional" if fractional else ""
-            name = f"{self.__class__.__name__}{suffix}"
         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 "vector"
-
     def _compute(
         self,
         input_data: Dict[str, Any],
-    ) -> Tuple["Nifti1Image", Path]:
+    ) -> Tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF and fALFF.
 
         Parameters
@@ -161,9 +132,13 @@ class ALFFBase(BaseMarker):
         Returns
         -------
         Niimg-like object
-            The ALFF / fALFF as NIfTI.
+            The ALFF as NIfTI.
+        Niimg-like object
+            The fALFF as NIfTI.
+        pathlib.Path
+            The path to the ALFF as NIfTI.
         pathlib.Path
-            The path to the ALFF / fALFF as NIfTI.
+            The path to the fALFF as NIfTI.
 
         """
         logger.debug("Calculating ALFF and fALFF")
@@ -186,11 +161,7 @@ class ALFFBase(BaseMarker):
         # parcellation / coordinates to native space, else the
         # path should be passed for use later if required.
         # TODO(synchon): will be taken care in #292
-        if input_data["space"] == "native" and self.fractional:
-            return falff, input_data["path"]
-        elif input_data["space"] == "native" and not self.fractional:
-            return alff, input_data["path"]
-        elif input_data["space"] != "native" and self.fractional:
-            return falff, falff_path
+        if input_data["space"] == "native":
+            return alff, falff, input_data["path"], input_data["path"]
         else:
-            return alff, alff_path
+            return alff, falff, alff_path, falff_path

junifer/markers/falff/falff_parcels.py

@@ -26,8 +26,6 @@ class ALFFParcels(ALFFBase):
     parcellation : str or list of str
         The name(s) of the parcellation(s). Check valid options by calling
         :func:`.list_parcellations`.
-    fractional : bool
-        Whether to compute fractional ALFF.
     using : {"junifer", "afni"}
         Implementation to use for computing ALFF:
 
@@ -73,7 +71,6 @@ class ALFFParcels(ALFFBase):
     def __init__(
         self,
         parcellation: Union[str, List[str]],
-        fractional: bool,
         using: str,
         highpass: float = 0.01,
         lowpass: float = 0.1,
@@ -85,7 +82,6 @@ class ALFFParcels(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
-            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -114,33 +110,63 @@ class ALFFParcels(ALFFBase):
         Returns
         -------
         dict
-            The computed result as dictionary. The dictionary has the following
-            keys:
+            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:
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``alff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
+
+            * ``falff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
 
         """
         logger.info("Calculating ALFF / fALFF for parcels")
 
-        # Compute ALFF / fALFF
-        output_data, output_file_path = self._compute(input_data=input)
-
-        # Initialize parcel aggregation
-        parcel_aggregation = ParcelAggregation(
-            parcellation=self.parcellation,
-            method=self.agg_method,
-            method_params=self.agg_method_params,
-            masks=self.masks,
-            on="BOLD",
-        )
-        # Perform aggregation on ALFF / fALFF
-        parcel_aggregation_input = dict(input.items())
-        parcel_aggregation_input["data"] = output_data
-        parcel_aggregation_input["path"] = output_file_path
-        output = parcel_aggregation.compute(
-            input=parcel_aggregation_input,
-            extra_input=extra_input,
+        # Compute ALFF + fALFF
+        alff_output, falff_output, alff_output_path, falff_output_path = (
+            self._compute(input_data=input)
         )
 
-        return output
+        # Perform aggregation on ALFF + fALFF
+        aggregation_alff_input = dict(input.items())
+        aggregation_falff_input = dict(input.items())
+        aggregation_alff_input["data"] = alff_output
+        aggregation_falff_input["data"] = falff_output
+        aggregation_alff_input["path"] = alff_output_path
+        aggregation_falff_input["path"] = falff_output_path
+
+        return {
+            "alff": {
+                **ParcelAggregation(
+                    parcellation=self.parcellation,
+                    method=self.agg_method,
+                    method_params=self.agg_method_params,
+                    masks=self.masks,
+                    on="BOLD",
+                ).compute(
+                    input=aggregation_alff_input,
+                    extra_input=extra_input,
+                )[
+                    "aggregation"
+                ],
+            },
+            "falff": {
+                **ParcelAggregation(
+                    parcellation=self.parcellation,
+                    method=self.agg_method,
+                    method_params=self.agg_method_params,
+                    masks=self.masks,
+                    on="BOLD",
+                ).compute(
+                    input=aggregation_falff_input,
+                    extra_input=extra_input,
+                )[
+                    "aggregation"
+                ],
+            },
+        }

junifer/markers/falff/falff_spheres.py

@@ -26,8 +26,6 @@ class ALFFSpheres(ALFFBase):
     coords : str
         The name of the coordinates list to use. See
         :func:`.list_coordinates` for options.
-    fractional : bool
-        Whether to compute fractional ALFF.
     using : {"junifer", "afni"}
         Implementation to use for computing ALFF:
 
@@ -80,7 +78,6 @@ class ALFFSpheres(ALFFBase):
     def __init__(
         self,
         coords: str,
-        fractional: bool,
         using: str,
         radius: Optional[float] = None,
         allow_overlap: bool = False,
@@ -94,7 +91,6 @@ class ALFFSpheres(ALFFBase):
     ) -> None:
         # Superclass init first to validate `using` parameter
         super().__init__(
-            fractional=fractional,
             highpass=highpass,
             lowpass=lowpass,
             using=using,
@@ -125,35 +121,67 @@ class ALFFSpheres(ALFFBase):
         Returns
         -------
         dict
-            The computed result as dictionary. The dictionary has the following
-            keys:
+            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:
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``alff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
+
+            * ``falff`` : dictionary with the following keys:
+
+              - ``data`` : ROI values as ``numpy.ndarray``
+              - ``col_names`` : ROI labels as list of str
 
         """
         logger.info("Calculating ALFF / fALFF for spheres")
 
-        # Compute ALFF / fALFF
-        output_data, output_file_path = self._compute(input_data=input)
-
-        # Initialize sphere aggregation
-        sphere_aggregation = SphereAggregation(
-            coords=self.coords,
-            radius=self.radius,
-            allow_overlap=self.allow_overlap,
-            method=self.agg_method,
-            method_params=self.agg_method_params,
-            masks=self.masks,
-            on="BOLD",
-        )
-        # Perform aggregation on ALFF / fALFF
-        sphere_aggregation_input = dict(input.items())
-        sphere_aggregation_input["data"] = output_data
-        sphere_aggregation_input["path"] = output_file_path
-        output = sphere_aggregation.compute(
-            input=sphere_aggregation_input,
-            extra_input=extra_input,
+        # Compute ALFF + fALFF
+        alff_output, falff_output, alff_output_path, falff_output_path = (
+            self._compute(input_data=input)
         )
 
-        return output
+        # Perform aggregation on ALFF / fALFF
+        aggregation_alff_input = dict(input.items())
+        aggregation_falff_input = dict(input.items())
+        aggregation_alff_input["data"] = alff_output
+        aggregation_falff_input["data"] = falff_output
+        aggregation_alff_input["path"] = alff_output_path
+        aggregation_falff_input["path"] = falff_output_path
+
+        return {
+            "alff": {
+                **SphereAggregation(
+                    coords=self.coords,
+                    radius=self.radius,
+                    allow_overlap=self.allow_overlap,
+                    method=self.agg_method,
+                    method_params=self.agg_method_params,
+                    masks=self.masks,
+                    on="BOLD",
+                ).compute(
+                    input=aggregation_alff_input,
+                    extra_input=extra_input,
+                )[
+                    "aggregation"
+                ],
+            },
+            "falff": {
+                **SphereAggregation(
+                    coords=self.coords,
+                    radius=self.radius,
+                    allow_overlap=self.allow_overlap,
+                    method=self.agg_method,
+                    method_params=self.agg_method_params,
+                    masks=self.masks,
+                    on="BOLD",
+                ).compute(
+                    input=aggregation_falff_input,
+                    extra_input=extra_input,
+                )[
+                    "aggregation"
+                ],
+            },
+        }