junifer 0.0.5.dev62__py3-none-any.whl → 0.0.5.dev86__py3-none-any.whl

junifer/preprocess/confounds/fmriprep_confound_remover.py

@@ -203,9 +203,7 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
                 "include it in the future",
                 klass=ValueError,
             )
-        super().__init__(
-            on="BOLD", required_data_types=["BOLD", "BOLD_confounds"]
-        )
+        super().__init__(on="BOLD", required_data_types=["BOLD"])
 
     def get_valid_inputs(self) -> List[str]:
         """Get valid data types for input.
@@ -361,7 +359,7 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
         Parameters
         ----------
         input : dict
-            Dictionary containing the ``BOLD_confounds`` value from the
+            Dictionary containing the ``BOLD.confounds`` value from the
             Junifer Data object.
 
         Returns
@@ -370,7 +368,6 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             Dataframe containing the relevant confounds.
 
         """
-
         confounds_format = input["format"]
         if confounds_format == "adhoc":
             self._map_adhoc_to_fmriprep(input)
@@ -416,50 +413,42 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
     def _validate_data(
         self,
         input: Dict[str, Any],
-        extra_input: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Validate input data.
 
         Parameters
         ----------
         input : dict
-            Dictionary containing the ``BOLD`` value from the
+            Dictionary containing the ``BOLD`` data from the
             Junifer Data object.
-        extra_input : dict, optional
-            Dictionary containing the rest of the Junifer Data object. Must
-            include the ``BOLD_confounds`` key.
 
         Raises
         ------
         ValueError
-            If ``extra_input`` is None or
-            if ``"BOLD_confounds"`` is not found in ``extra_input`` or
-            if ``"data"`` key is not found in ``"BOLD_confounds"`` or
-            if ``"data"`` is not pandas.DataFrame or
+            If ``"confounds"`` is not found in ``input`` or
+            if ``"data"`` key is not found in ``"input.confounds"`` or
+            if ``"input.confounds.data"`` is not pandas.DataFrame or
             if image time series and confounds have different lengths or
-            if ``"format"`` is not found in ``"BOLD_confounds"`` or
-            if ``format = "adhoc"`` and ``"mappings"`` key or ``"fmriprep"``
-            key or correct fMRIPrep mappings or required fMRIPrep mappings are
-            not found or if invalid confounds format is found.
+            if ``format = "adhoc"`` and ``"mappings"`` key is not found or
+            ``"fmriprep"`` key is not found in ``"mappings"`` or
+            ``"fmriprep"`` has incorrect fMRIPrep mappings or required
+            fMRIPrep mappings are not found or
+            if invalid confounds format is found.
 
         """
         # BOLD must be 4D niimg
         check_niimg_4d(input["data"])
-        # Check for extra inputs
-        if extra_input is None:
-            raise_error(
-                "No extra input provided, requires `BOLD_confounds` data type "
-                "in particular"
-            )
-        if "BOLD_confounds" not in extra_input:
-            raise_error("`BOLD_confounds` data type not provided")
-        if "data" not in extra_input["BOLD_confounds"]:
-            raise_error("`BOLD_confounds.data` not provided")
-        # Confounds must be a pandas.DataFrame
-        if not isinstance(extra_input["BOLD_confounds"]["data"], pd.DataFrame):
-            raise_error("`BOLD_confounds.data` must be a `pandas.DataFrame`")
-
-        confound_df = extra_input["BOLD_confounds"]["data"]
+        # Check for confound data
+        if "confounds" not in input:
+            raise_error("`BOLD.confounds` data type not provided")
+        if "data" not in input["confounds"]:
+            raise_error("`BOLD.confounds.data` not provided")
+        # Confounds must be a pandas.DataFrame;
+        # if extension is unknown, will not be read, which will give None
+        if not isinstance(input["confounds"]["data"], pd.DataFrame):
+            raise_error("`BOLD.confounds.data` must be a `pandas.DataFrame`")
+
+        confound_df = input["confounds"]["data"]
         bold_img = input["data"]
         if bold_img.get_fdata().shape[3] != len(confound_df):
             raise_error(
@@ -469,23 +458,19 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             )
 
         # Check format
-        if "format" not in extra_input["BOLD_confounds"]:
-            raise_error("`BOLD_confounds.format` not provided")
-        t_format = extra_input["BOLD_confounds"]["format"]
+        t_format = input["confounds"]["format"]
         if t_format == "adhoc":
-            if "mappings" not in extra_input["BOLD_confounds"]:
+            if "mappings" not in input["confounds"]:
                 raise_error(
-                    "`BOLD_confounds.mappings` need to be set when "
-                    "`BOLD_confounds.format == 'adhoc'`"
+                    "`BOLD.confounds.mappings` need to be set when "
+                    "`BOLD.confounds.format == 'adhoc'`"
                 )
-            if "fmriprep" not in extra_input["BOLD_confounds"]["mappings"]:
+            if "fmriprep" not in input["confounds"]["mappings"]:
                 raise_error(
-                    "`BOLD_confounds.mappings.fmriprep` need to be set when "
-                    "`BOLD_confounds.format == 'adhoc'`"
+                    "`BOLD.confounds.mappings.fmriprep` need to be set when "
+                    "`BOLD.confounds.format == 'adhoc'`"
                 )
-            fmriprep_mappings = extra_input["BOLD_confounds"]["mappings"][
-                "fmriprep"
-            ]
+            fmriprep_mappings = input["confounds"]["mappings"]["fmriprep"]
             wrong_names = [
                 x
                 for x in fmriprep_mappings.values()
@@ -525,22 +510,22 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
         input : dict
             A single input from the Junifer Data object to preprocess.
         extra_input : dict, optional
-            The other fields in the Junifer Data object. Must include the
-            ``BOLD_confounds`` key.
+            The other fields in the Junifer Data object.
 
         Returns
         -------
         dict
-            The computed result as dictionary.
-        dict or None
-            If `self.masks` is not None, then the target data computed mask is
-            returned else None.
+            The computed result as dictionary. If `self.masks` is not None,
+            then the target data computed mask is updated for further steps.
+        None
+            Extra "helper" data types as dictionary to add to the Junifer Data
+            object.
 
         """
         # Validate data
-        self._validate_data(input, extra_input)
+        self._validate_data(input)
         # Pick confounds
-        confounds_df = self._pick_confounds(extra_input["BOLD_confounds"])  # type: ignore
+        confounds_df = self._pick_confounds(input["confounds"])  # type: ignore
         # Get BOLD data
         bold_img = input["data"]
         # Set t_r
@@ -553,7 +538,6 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             )
         # Set mask data
         mask_img = None
-        bold_mask_dict = None
         if self.masks is not None:
             logger.debug(f"Masking with {self.masks}")
             mask_img = get_mask(
@@ -561,15 +545,15 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             )
             # Return the BOLD mask and link it to the BOLD data type dict;
             # this allows to use "inherit" down the pipeline
-            if extra_input is not None:
-                logger.debug("Setting `BOLD.mask_item`")
-                input["mask_item"] = "BOLD_mask"
-                bold_mask_dict = {
-                    "BOLD_mask": {
+            logger.debug("Setting `BOLD.mask`")
+            input.update(
+                {
+                    "mask": {
                         "data": mask_img,
                         "space": input["space"],
                     }
                 }
+            )
         # Clean image
         logger.info("Cleaning image using nilearn")
         logger.debug(f"\tdetrend: {self.detrend}")
@@ -587,4 +571,4 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             mask_img=mask_img,
         )
 
-        return input, bold_mask_dict
+        return input, None

junifer/preprocess/confounds/tests/test_fmriprep_confound_remover.py

@@ -20,6 +20,7 @@ from junifer.testing import get_testing_data
 from junifer.testing.datagrabbers import (
     OasisVBMTestingDataGrabber,
     PartlyCloudyTestingDataGrabber,
+    SPMAuditoryTestingDataGrabber,
 )
 
 
@@ -42,35 +43,10 @@ def test_fMRIPrepConfoundRemover_init() -> None:
 @pytest.mark.parametrize(
     "input_",
     [
-        ["T1w"],
         ["BOLD"],
         ["T1w", "BOLD"],
     ],
 )
-def test_fMRIPrepConfoundRemover_validate_input_errors(
-    input_: List[str],
-) -> None:
-    """Test errors for fMRIPrepConfoundRemover validate_input.
-
-    Parameters
-    ----------
-    input_ : list of str
-        The input data types.
-
-    """
-    confound_remover = fMRIPrepConfoundRemover()
-
-    with pytest.raises(ValueError, match="not have the required data"):
-        confound_remover.validate_input(input_)
-
-
-@pytest.mark.parametrize(
-    "input_",
-    [
-        ["BOLD", "BOLD_confounds"],
-        ["T1w", "BOLD", "BOLD_confounds"],
-    ],
-)
 def test_fMRIPrepConfoundRemover_validate_input(input_: List[str]) -> None:
     """Test fMRIPrepConfoundRemover validate_input.
 
@@ -302,13 +278,13 @@ def test_fMRIPRepConfoundRemover__pick_confounds_fmriprep() -> None:
     with PartlyCloudyTestingDataGrabber() as dg:
         input = dg["sub-01"]
         input = reader.fit_transform(input)
-        out1 = confound_remover._pick_confounds(input["BOLD_confounds"])
+        out1 = confound_remover._pick_confounds(input["BOLD"]["confounds"])
         assert set(out1.columns) == {*fmriprep_all_vars, "spike"}
 
     with PartlyCloudyTestingDataGrabber(reduce_confounds=False) as dg:
         input = dg["sub-01"]
         input = reader.fit_transform(input)
-        out2 = confound_remover._pick_confounds(input["BOLD_confounds"])
+        out2 = confound_remover._pick_confounds(input["BOLD"]["confounds"])
         assert set(out2.columns) == {*fmriprep_all_vars, "spike"}
 
     assert_frame_equal(out1, out2)
@@ -348,123 +324,106 @@ def test_fMRIPRepConfoundRemover__pick_confounds_fmriprep_compute() -> None:
 def test_fMRIPrepConfoundRemover__validate_data() -> None:
     """Test fMRIPrepConfoundRemover validate data."""
     confound_remover = fMRIPrepConfoundRemover(strategy={"wm_csf": "full"})
-
+    # Check correct data type
     with OasisVBMTestingDataGrabber() as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         vbm = element_data["VBM_GM"]
         with pytest.raises(
             DimensionError, match="incompatible dimensionality"
         ):
-            confound_remover._validate_data(vbm, None)
-
-    with PartlyCloudyTestingDataGrabber(reduce_confounds=False) as dg:
+            confound_remover._validate_data(vbm)
+    # Check missing nested type in correct data type
+    with SPMAuditoryTestingDataGrabber() as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         bold = element_data["BOLD"]
-
-        with pytest.raises(ValueError, match="No extra input"):
-            confound_remover._validate_data(bold, None)
+        # Test confound type
         with pytest.raises(
-            ValueError, match="`BOLD_confounds` data type not provided"
+            ValueError, match="`BOLD.confounds` data type not provided"
         ):
-            confound_remover._validate_data(bold, {})
+            confound_remover._validate_data(bold)
+        # Test confound data
+        bold["confounds"] = {}
         with pytest.raises(
-            ValueError, match="`BOLD_confounds.data` not provided"
+            ValueError, match="`BOLD.confounds.data` not provided"
         ):
-            confound_remover._validate_data(bold, {"BOLD_confounds": {}})
-
-        extra_input = {
-            "BOLD_confounds": {"data": "wrong"},
-        }
-        msg = "must be a `pandas.DataFrame`"
-        with pytest.raises(ValueError, match=msg):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {"BOLD_confounds": {"data": pd.DataFrame()}}
+            confound_remover._validate_data(bold)
+        # Test confound data is valid type
+        bold["confounds"] = {"data": None}
+        with pytest.raises(ValueError, match="must be a `pandas.DataFrame`"):
+            confound_remover._validate_data(bold)
+        # Test confound data dimension mismatch with BOLD
+        bold["confounds"] = {"data": pd.DataFrame()}
         with pytest.raises(ValueError, match="Image time series and"):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {
-            "BOLD_confounds": {"data": element_data["BOLD_confounds"]["data"]}
+            confound_remover._validate_data(bold)
+    # Check nested type variations
+    with PartlyCloudyTestingDataGrabber(reduce_confounds=False) as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        # Test format
+        modified_bold = {
+            "data": element_data["BOLD"]["data"],
+            "confounds": {
+                "data": element_data["BOLD"]["confounds"]["data"],
+                "format": "adhoc",
+            },
         }
+        # Test incorrect format
+        modified_bold["confounds"].update({"format": "wrong"})
+        with pytest.raises(ValueError, match="Invalid confounds format"):
+            confound_remover._validate_data(modified_bold)
+        # Test missing mappings for adhoc
+        modified_bold["confounds"].update({"format": "adhoc"})
         with pytest.raises(
-            ValueError, match="`BOLD_confounds.format` not provided"
+            ValueError, match="`BOLD.confounds.mappings` need to be set"
         ):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {
-            "BOLD_confounds": {
-                "data": element_data["BOLD_confounds"]["data"],
-                "format": "wrong",
-            }
-        }
-        with pytest.raises(ValueError, match="Invalid confounds format"):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {
-            "BOLD_confounds": {
-                "data": element_data["BOLD_confounds"]["data"],
-                "format": "adhoc",
-            }
-        }
-        with pytest.raises(ValueError, match="need to be set"):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {
-            "BOLD_confounds": {
-                "data": element_data["BOLD_confounds"]["data"],
-                "format": "adhoc",
-                "mappings": {},
-            }
-        }
-        with pytest.raises(ValueError, match="need to be set"):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {
-            "BOLD_confounds": {
-                "data": element_data["BOLD_confounds"]["data"],
-                "format": "adhoc",
+            confound_remover._validate_data(modified_bold)
+        # Test missing fmriprep mappings for adhoc
+        modified_bold["confounds"].update({"mappings": {}})
+        with pytest.raises(
+            ValueError,
+            match="`BOLD.confounds.mappings.fmriprep` need to be set",
+        ):
+            confound_remover._validate_data(modified_bold)
+        # Test incorrect fmriprep mappings for adhoc
+        modified_bold["confounds"].update(
+            {
                 "mappings": {
                     "fmriprep": {
                         "rot_x": "wrong",
                         "rot_y": "rot_z",
                         "rot_z": "rot_y",
-                    }
-                },
+                    },
+                }
             }
-        }
+        )
         with pytest.raises(ValueError, match=r"names: \['wrong'\]"):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {
-            "BOLD_confounds": {
-                "data": element_data["BOLD_confounds"]["data"],
-                "format": "adhoc",
+            confound_remover._validate_data(modified_bold)
+        # Test missing fmriprep mappings for adhoc
+        modified_bold["confounds"].update(
+            {
                 "mappings": {
                     "fmriprep": {
                         "wrong": "rot_x",
                         "rot_y": "rot_z",
                         "rot_z": "rot_y",
-                    }
-                },
+                    },
+                }
             }
-        }
+        )
         with pytest.raises(ValueError, match=r"Missing columns: \['wrong'\]"):
-            confound_remover._validate_data(bold, extra_input)
-
-        extra_input = {
-            "BOLD_confounds": {
-                "data": element_data["BOLD_confounds"]["data"],
-                "format": "adhoc",
+            confound_remover._validate_data(modified_bold)
+        # Test correct adhoc format
+        modified_bold["confounds"].update(
+            {
                 "mappings": {
                     "fmriprep": {
                         "rot_x": "rot_x",
                         "rot_y": "rot_z",
                         "rot_z": "rot_y",
-                    }
-                },
+                    },
+                }
             }
-        }
-        confound_remover._validate_data(bold, extra_input)
+        )
+        confound_remover._validate_data(modified_bold)
 
 
 def test_fMRIPrepConfoundRemover_preprocess() -> None:
@@ -476,7 +435,9 @@ def test_fMRIPrepConfoundRemover_preprocess() -> None:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         orig_bold = element_data["BOLD"]["data"].get_fdata().copy()
         pre_input = element_data["BOLD"]
-        pre_extra_input = {"BOLD_confounds": element_data["BOLD_confounds"]}
+        pre_extra_input = {
+            "BOLD": {"confounds": element_data["BOLD"]["confounds"]}
+        }
         output, _ = confound_remover.preprocess(pre_input, pre_extra_input)
         trans_bold = output["data"].get_fdata()
         # Transformation is in place
@@ -530,7 +491,7 @@ def test_fMRIPrepConfoundRemover_fit_transform() -> None:
         assert t_meta["t_r"] is None
         assert t_meta["masks"] is None
 
-        assert "BOLD_mask" not in output
+        assert "mask" not in output["BOLD"]
 
         assert "dependencies" in output["BOLD"]["meta"]
         dependencies = output["BOLD"]["meta"]["dependencies"]
@@ -582,9 +543,7 @@ def test_fMRIPrepConfoundRemover_fit_transform_masks() -> None:
         assert "threshold" in t_meta["masks"]["compute_brain_mask"]
         assert t_meta["masks"]["compute_brain_mask"]["threshold"] == 0.2
 
-        assert "BOLD_mask" in output
-        assert "mask_item" in output["BOLD"]
-        assert output["BOLD"]["mask_item"] == "BOLD_mask"
+        assert "mask" in output["BOLD"]
 
         assert "dependencies" in output["BOLD"]["meta"]
         dependencies = output["BOLD"]["meta"]["dependencies"]

junifer/testing/datagrabbers.py

@@ -181,7 +181,7 @@ class PartlyCloudyTestingDataGrabber(BaseDataGrabber):
         """Initialize the class."""
         datadir = tempfile.mkdtemp()
         # Define types
-        types = ["BOLD", "BOLD_confounds"]
+        types = ["BOLD"]
         self.reduce_confounds = reduce_confounds
         self.age_group = age_group
         super().__init__(types=types, datadir=datadir)
@@ -242,10 +242,10 @@ class PartlyCloudyTestingDataGrabber(BaseDataGrabber):
         out["BOLD"] = {
             "path": Path(self._dataset["func"][i_sub]),
             "space": "MNI152NLin2009cAsym",
-        }
-        out["BOLD_confounds"] = {
-            "path": Path(self._dataset["confounds"][i_sub]),
-            "format": "fmriprep",
+            "confounds": {
+                "path": Path(self._dataset["confounds"][i_sub]),
+                "format": "fmriprep",
+            },
         }
 
         return out

junifer/testing/tests/test_partlycloudytesting_datagrabber.py

@@ -28,13 +28,13 @@ def test_PartlyCloudyTestingDataGrabber() -> None:
         assert out["BOLD"]["path"].exists()
         assert out["BOLD"]["path"].is_file()
 
-        assert "BOLD_confounds" in out
-        assert out["BOLD_confounds"]["path"].exists()
-        assert out["BOLD_confounds"]["path"].is_file()
-        assert "format" in out["BOLD_confounds"]
-        assert "fmriprep" == out["BOLD_confounds"]["format"]
+        assert "confounds" in out["BOLD"]
+        assert out["BOLD"]["confounds"]["path"].exists()
+        assert out["BOLD"]["confounds"]["path"].is_file()
+        assert "format" in out["BOLD"]["confounds"]
+        assert "fmriprep" == out["BOLD"]["confounds"]["format"]
 
     with PartlyCloudyTestingDataGrabber(reduce_confounds=False) as dg:
         out = dg["sub-01"]
-        assert "format" in out["BOLD_confounds"]
-        assert "fmriprep" == out["BOLD_confounds"]["format"]
+        assert "format" in out["BOLD"]["confounds"]
+        assert "fmriprep" == out["BOLD"]["confounds"]["format"]

{junifer-0.0.5.dev62.dist-info → junifer-0.0.5.dev86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: junifer
-Version: 0.0.5.dev62
+Version: 0.0.5.dev86
 Summary: JUelich NeuroImaging FEature extractoR
 Author-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>
 Maintainer-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>