junifer 0.0.5.dev240__py3-none-any.whl → 0.0.6__py3-none-any.whl

junifer/preprocess/confounds/tests/test_fmriprep_confound_remover.py

@@ -5,12 +5,12 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import List
 
 import numpy as np
 import pandas as pd
 import pytest
 from nilearn._utils.exceptions import DimensionError
+from nilearn.interfaces.fmriprep.load_confounds_utils import prepare_output
 from numpy.testing import assert_array_equal, assert_raises
 from pandas.testing import assert_frame_equal
 
@@ -47,7 +47,7 @@ def test_fMRIPrepConfoundRemover_init() -> None:
         ["T1w", "BOLD"],
     ],
 )
-def test_fMRIPrepConfoundRemover_validate_input(input_: List[str]) -> None:
+def test_fMRIPrepConfoundRemover_validate_input(input_: list[str]) -> None:
     """Test fMRIPrepConfoundRemover validate_input.
 
     Parameters
@@ -212,7 +212,7 @@ def test_fMRIPrepConfoundRemover__process_fmriprep_spec() -> None:
     )
 
     msg = r"Missing basic confounds: \['white_matter'\]"
-    with pytest.raises(ValueError, match=msg):
+    with pytest.raises(RuntimeError, match=msg):
         confound_remover._process_fmriprep_spec({"data": confounds_df})
 
     var_names = ["csf", "white_matter"]
@@ -221,7 +221,7 @@ def test_fMRIPrepConfoundRemover__process_fmriprep_spec() -> None:
     )
 
     msg = r"Missing framewise_displacement"
-    with pytest.raises(ValueError, match=msg):
+    with pytest.raises(RuntimeError, match=msg):
         confound_remover._process_fmriprep_spec({"data": confounds_df})
 
 
@@ -321,6 +321,32 @@ def test_fMRIPRepConfoundRemover__pick_confounds_fmriprep_compute() -> None:
     assert_frame_equal(out_junifer, out_fmriprep)
 
 
+@pytest.mark.parametrize(
+    "preprocessor",
+    [
+        fMRIPrepConfoundRemover(
+            std_dvars_threshold=1.5,
+        ),
+        fMRIPrepConfoundRemover(
+            fd_threshold=0.5,
+        ),
+    ],
+)
+def test_fMRIPrepConfoundRemover__get_scrub_regressors_errors(
+    preprocessor: type,
+) -> None:
+    """Test fMRIPrepConfoundRemover scrub regressors errors.
+
+    Parameters
+    ----------
+    preprocessor : object
+        The parametrized preprocessor.
+
+    """
+    with pytest.raises(RuntimeError, match="Invalid confounds file."):
+        preprocessor._get_scrub_regressors(pd.DataFrame({"a": [1, 2]}))
+
+
 def test_fMRIPrepConfoundRemover__validate_data() -> None:
     """Test fMRIPrepConfoundRemover validate data."""
     confound_remover = fMRIPrepConfoundRemover(strategy={"wm_csf": "full"})
@@ -461,22 +487,32 @@ def test_fMRIPrepConfoundRemover_fit_transform() -> None:
 
     with PartlyCloudyTestingDataGrabber(reduce_confounds=False) as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
-        orig_bold = element_data["BOLD"]["data"].get_fdata().copy()
+        # Get original data
+        input_img = element_data["BOLD"]["data"]
+        input_bold = input_img.get_fdata().copy()
+        input_tr = input_img.header.get_zooms()[3]
+        # Fit-transform
         output = confound_remover.fit_transform(element_data)
-        trans_bold = output["BOLD"]["data"].get_fdata()
+        output_img = output["BOLD"]["data"]
+        output_bold = output_img.get_fdata()
+        output_tr = output_img.header.get_zooms()[3]
+
         # Transformation is in place
         assert_array_equal(
-            trans_bold, element_data["BOLD"]["data"].get_fdata()
+            output_bold, element_data["BOLD"]["data"].get_fdata()
         )
 
         # Data should have the same shape
-        assert orig_bold.shape == trans_bold.shape
+        assert input_bold.shape == output_bold.shape
 
         # but be different
         assert_raises(
-            AssertionError, assert_array_equal, orig_bold, trans_bold
+            AssertionError, assert_array_equal, input_bold, output_bold
         )
 
+        # Check t_r
+        assert input_tr == output_tr
+
         assert "meta" in output["BOLD"]
         assert "preprocess" in output["BOLD"]["meta"]
         t_meta = output["BOLD"]["meta"]["preprocess"]
@@ -507,22 +543,32 @@ def test_fMRIPrepConfoundRemover_fit_transform_masks() -> None:
 
     with PartlyCloudyTestingDataGrabber(reduce_confounds=False) as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
-        orig_bold = element_data["BOLD"]["data"].get_fdata().copy()
+        # Get original data
+        input_img = element_data["BOLD"]["data"]
+        input_bold = input_img.get_fdata().copy()
+        input_tr = input_img.header.get_zooms()[3]
+        # Fit-transform
         output = confound_remover.fit_transform(element_data)
-        trans_bold = output["BOLD"]["data"].get_fdata()
+        output_img = output["BOLD"]["data"]
+        output_bold = output_img.get_fdata()
+        output_tr = output_img.header.get_zooms()[3]
+
         # Transformation is in place
         assert_array_equal(
-            trans_bold, element_data["BOLD"]["data"].get_fdata()
+            output_bold, element_data["BOLD"]["data"].get_fdata()
         )
 
         # Data should have the same shape
-        assert orig_bold.shape == trans_bold.shape
+        assert input_bold.shape == output_bold.shape
 
         # but be different
         assert_raises(
-            AssertionError, assert_array_equal, orig_bold, trans_bold
+            AssertionError, assert_array_equal, input_bold, output_bold
         )
 
+        # Check t_r
+        assert input_tr == output_tr
+
         assert "meta" in output["BOLD"]
         assert "preprocess" in output["BOLD"]["meta"]
         t_meta = output["BOLD"]["meta"]["preprocess"]
@@ -548,3 +594,64 @@ def test_fMRIPrepConfoundRemover_fit_transform_masks() -> None:
         assert "dependencies" in output["BOLD"]["meta"]
         dependencies = output["BOLD"]["meta"]["dependencies"]
         assert dependencies == {"numpy", "nilearn"}
+
+
+def test_fMRIPrepConfoundRemover_scrubbing() -> None:
+    """Test fMRIPrepConfoundRemover with scrubbing."""
+    confound_remover = fMRIPrepConfoundRemover(
+        strategy={
+            "motion": "full",
+            "wm_csf": "full",
+            "global_signal": "full",
+            "scrubbing": True,
+        },
+    )
+
+    with PartlyCloudyTestingDataGrabber(reduce_confounds=False) as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        orig_bold = element_data["BOLD"]["data"].get_fdata().copy()
+        orig_confounds = element_data["BOLD"]["confounds"].copy()
+        pre_input = element_data["BOLD"]
+        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
+        assert_array_equal(
+            trans_bold, element_data["BOLD"]["data"].get_fdata()
+        )
+
+        # Data should have different shape
+        assert_raises(
+            AssertionError,
+            assert_array_equal,
+            orig_bold.shape,
+            trans_bold.shape,
+        )
+        # and be different
+        assert_raises(
+            AssertionError, assert_array_equal, orig_bold, trans_bold
+        )
+
+        # Check scrubbing process
+        # Should be at the start
+        confounds_df = confound_remover._pick_confounds(orig_confounds)
+        assert confounds_df.shape == (168, 36)
+        # Should have 4 motion outliers based on threshold
+        motion_outline_regressors = confound_remover._get_scrub_regressors(
+            orig_confounds["data"]
+        )
+        assert motion_outline_regressors.shape == (168, 4)
+        # Add regressors to confounds
+        concat_confounds_df = pd.concat(
+            [confounds_df, motion_outline_regressors], axis=1
+        )
+        assert concat_confounds_df.shape == (168, 40)
+        # Get sample mask and correct confounds
+        sample_mask, final_confounds_df = prepare_output(
+            confounds=concat_confounds_df, demean=False
+        )
+        assert not confounds_df.equals(final_confounds_df)
+        assert sample_mask.shape == (164,)
+        assert not (np.isin([91, 92, 93, 113], sample_mask)).all()

junifer/preprocess/smoothing/__init__.py

@@ -3,7 +3,7 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from .smoothing import Smoothing
+import lazy_loader as lazy
 
 
-__all__ = ["Smoothing"]
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

junifer/preprocess/smoothing/__init__.pyi

@@ -0,0 +1,3 @@
+__all__ = ["Smoothing"]
+
+from .smoothing import Smoothing

junifer/preprocess/smoothing/_afni_smoothing.py

@@ -4,24 +4,18 @@
 # License: AGPL
 
 from typing import (
-    TYPE_CHECKING,
+    Any,
     ClassVar,
-    Dict,
-    List,
-    Set,
     Union,
 )
 
 import nibabel as nib
 
 from ...pipeline import WorkDirManager
+from ...typing import Dependencies, ExternalDependencies
 from ...utils import logger, run_ext_cmd
 
 
-if TYPE_CHECKING:
-    from nibabel import Nifti1Image
-
-
 __all__ = ["AFNISmoothing"]
 
 
@@ -32,34 +26,34 @@ class AFNISmoothing:
 
     """
 
-    _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+    _EXT_DEPENDENCIES: ClassVar[ExternalDependencies] = [
         {
             "name": "afni",
             "commands": ["3dBlurToFWHM"],
         },
     ]
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nibabel"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nibabel"}
 
     def preprocess(
         self,
-        data: "Nifti1Image",
+        input: dict[str, Any],
         fwhm: Union[int, float],
-    ) -> "Nifti1Image":
+    ) -> dict[str, Any]:
         """Preprocess using AFNI.
 
         Parameters
         ----------
-        data : Niimg-like object
-            Image(s) to preprocess.
+        input : dict
+            A single input from the Junifer Data object in which to preprocess.
         fwhm : int or float
             Smooth until the value. AFNI estimates the smoothing and then
             applies smoothing to reach ``fwhm``.
 
         Returns
         -------
-        Niimg-like object
-            The preprocessed image(s).
+        dict
+            The ``input`` dictionary with updated values.
 
         Notes
         -----
@@ -73,18 +67,18 @@ class AFNISmoothing:
         """
         logger.info("Smoothing using AFNI")
 
-        # Create component-scoped tempdir
-        tempdir = WorkDirManager().get_tempdir(prefix="afni_smoothing")
-
-        # Save target data to a component-scoped tempfile
-        nifti_in_file_path = tempdir / "input.nii"  # needs to be .nii
-        nib.save(data, nifti_in_file_path)
+        # Create element-scoped tempdir so that the output is
+        # available later as nibabel stores file path reference for
+        # loading on computation
+        element_tempdir = WorkDirManager().get_element_tempdir(
+            prefix="afni_smoothing"
+        )
 
         # Set 3dBlurToFWHM command
-        blur_out_path_prefix = tempdir / "blur"
+        blur_out_path_prefix = element_tempdir / "blur"
         blur_cmd = [
             "3dBlurToFWHM",
-            f"-input {nifti_in_file_path.resolve()}",
+            f"-input {input['path'].resolve()}",
             f"-prefix {blur_out_path_prefix.resolve()}",
             "-automask",
             f"-FWHM {fwhm}",
@@ -92,28 +86,34 @@ class AFNISmoothing:
         # Call 3dBlurToFWHM
         run_ext_cmd(name="3dBlurToFWHM", cmd=blur_cmd)
 
-        # Create element-scoped tempdir so that the blurred output is
-        # available later as nibabel stores file path reference for
-        # loading on computation
-        element_tempdir = WorkDirManager().get_element_tempdir(
-            prefix="afni_blur"
-        )
+        # Read header to get output suffix
+        header = input["data"].header
+        sform_code = header.get_sform(coded=True)[1]
+        if sform_code == 4:
+            output_suffix = "tlrc"
+        else:
+            output_suffix = "orig"
+
         # Convert afni to nifti
-        blur_afni_to_nifti_out_path = (
-            element_tempdir / "output.nii"  # needs to be .nii
+        blur_nifti_out_path = (
+            element_tempdir / "smoothed_data.nii"  # needs to be .nii
         )
         convert_cmd = [
             "3dAFNItoNIFTI",
-            f"-prefix {blur_afni_to_nifti_out_path.resolve()}",
-            f"{blur_out_path_prefix}+orig.BRIK",
+            f"-prefix {blur_nifti_out_path.resolve()}",
+            f"{blur_out_path_prefix}+{output_suffix}.BRIK",
         ]
         # Call 3dAFNItoNIFTI
         run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_cmd)
 
-        # Load nifti
-        output_data = nib.load(blur_afni_to_nifti_out_path)
-
-        # Delete tempdir
-        WorkDirManager().delete_tempdir(tempdir)
+        logger.debug("Updating smoothed data")
+        input.update(
+            {
+                # Update path to sync with "data"
+                "path": blur_nifti_out_path,
+                # Load nifti
+                "data": nib.load(blur_nifti_out_path),
+            }
+        )
 
-        return output_data  # type: ignore
+        return input

junifer/preprocess/smoothing/_fsl_smoothing.py

@@ -4,24 +4,17 @@
 # License: AGPL
 
 from typing import (
-    TYPE_CHECKING,
+    Any,
     ClassVar,
-    Dict,
-    List,
-    Set,
-    Union,
 )
 
 import nibabel as nib
 
 from ...pipeline import WorkDirManager
+from ...typing import Dependencies, ExternalDependencies
 from ...utils import logger, run_ext_cmd
 
 
-if TYPE_CHECKING:
-    from nibabel import Nifti1Image
-
-
 __all__ = ["FSLSmoothing"]
 
 
@@ -32,27 +25,27 @@ class FSLSmoothing:
 
     """
 
-    _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+    _EXT_DEPENDENCIES: ClassVar[ExternalDependencies] = [
         {
             "name": "fsl",
             "commands": ["susan"],
         },
     ]
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nibabel"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nibabel"}
 
     def preprocess(
         self,
-        data: "Nifti1Image",
+        input: dict[str, Any],
         brightness_threshold: float,
         fwhm: float,
-    ) -> "Nifti1Image":
+    ) -> dict[str, Any]:
         """Preprocess using FSL.
 
         Parameters
         ----------
-        data : Niimg-like object
-            Image(s) to preprocess.
+        input : dict
+            A single input from the Junifer Data object in which to preprocess.
         brightness_threshold : float
             Threshold to discriminate between noise and the underlying image.
             The value should be set greater than the noise level and less than
@@ -62,8 +55,8 @@ class FSLSmoothing:
 
         Returns
         -------
-        Niimg-like object
-            The preprocessed image(s).
+        dict
+            The ``input`` dictionary with updated values.
 
         Notes
         -----
@@ -79,24 +72,17 @@ class FSLSmoothing:
         """
         logger.info("Smoothing using FSL")
 
-        # Create component-scoped tempdir
-        tempdir = WorkDirManager().get_tempdir(prefix="fsl_smoothing")
-
-        # Save target data to a component-scoped tempfile
-        nifti_in_file_path = tempdir / "input.nii.gz"
-        nib.save(data, nifti_in_file_path)
-
         # Create element-scoped tempdir so that the output is
         # available later as nibabel stores file path reference for
         # loading on computation
         element_tempdir = WorkDirManager().get_element_tempdir(
             prefix="fsl_susan"
         )
-        susan_out_path = element_tempdir / "output.nii.gz"
+        susan_out_path = element_tempdir / "smoothed_data.nii.gz"
         # Set susan command
         susan_cmd = [
             "susan",
-            f"{nifti_in_file_path.resolve()}",
+            f"{input['path'].resolve()}",
             f"{brightness_threshold}",
             f"{fwhm}",
             "3",  # dimension
@@ -107,10 +93,14 @@ class FSLSmoothing:
         # Call susan
         run_ext_cmd(name="susan", cmd=susan_cmd)
 
-        # Load nifti
-        output_data = nib.load(susan_out_path)
-
-        # Delete tempdir
-        WorkDirManager().delete_tempdir(tempdir)
+        logger.debug("Updating smoothed data")
+        input.update(
+            {
+                # Update path to sync with "data"
+                "path": susan_out_path,
+                # Load nifti
+                "data": nib.load(susan_out_path),
+            }
+        )
 
-        return output_data  # type: ignore
+        return input

junifer/preprocess/smoothing/_nilearn_smoothing.py

@@ -4,23 +4,21 @@
 # License: AGPL
 
 from typing import (
-    TYPE_CHECKING,
+    Any,
     ClassVar,
     Literal,
-    Set,
     Union,
 )
 
+import nibabel as nib
 from nilearn import image as nimg
 from numpy.typing import ArrayLike
 
+from ...pipeline import WorkDirManager
+from ...typing import Dependencies
 from ...utils import logger
 
 
-if TYPE_CHECKING:
-    from nibabel import Nifti1Image
-
-
 __all__ = ["NilearnSmoothing"]
 
 
@@ -31,19 +29,19 @@ class NilearnSmoothing:
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn"}
 
     def preprocess(
         self,
-        data: "Nifti1Image",
+        input: dict[str, Any],
         fwhm: Union[int, float, ArrayLike, Literal["fast"], None],
-    ) -> "Nifti1Image":
+    ) -> dict[str, Any]:
         """Preprocess using nilearn.
 
         Parameters
         ----------
-        data : Niimg-like object
-            Image(s) to preprocess.
+        input : dict
+            A single input from the Junifer Data object in which to preprocess.
         fwhm : scalar, ``numpy.ndarray``, tuple or list of scalar, "fast" or \
                None
             Smoothing strength, as a full-width at half maximum, in
@@ -61,9 +59,32 @@ class NilearnSmoothing:
 
         Returns
         -------
-        Niimg-like object
-            The preprocessed image(s).
+        dict
+            The ``input`` dictionary with updated values.
 
         """
         logger.info("Smoothing using nilearn")
-        return nimg.smooth_img(imgs=data, fwhm=fwhm)  # type: ignore
+
+        # Create element-scoped tempdir so that the output is
+        # available later as nibabel stores file path reference for
+        # loading on computation
+        element_tempdir = WorkDirManager().get_element_tempdir(
+            prefix="nilearn_smoothing"
+        )
+
+        smoothed_img = nimg.smooth_img(imgs=input["data"], fwhm=fwhm)
+
+        # Save smoothed output
+        smoothed_img_path = element_tempdir / "smoothed_data.nii.gz"
+        nib.save(smoothed_img, smoothed_img_path)
+
+        logger.debug("Updating smoothed data")
+        input.update(
+            {
+                # Update path to sync with "data"
+                "path": smoothed_img_path,
+                "data": smoothed_img,
+            }
+        )
+
+        return input

junifer/preprocess/smoothing/smoothing.py

@@ -3,9 +3,10 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, ClassVar, Optional, Union
 
 from ...api.decorators import register_preprocessor
+from ...typing import ConditionalDependencies
 from ...utils import logger, raise_error
 from ..base import BasePreprocessor
 from ._afni_smoothing import AFNISmoothing
@@ -67,7 +68,7 @@ class Smoothing(BasePreprocessor):
 
     """
 
-    _CONDITIONAL_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, Type]]]] = [
+    _CONDITIONAL_DEPENDENCIES: ClassVar[ConditionalDependencies] = [
         {
             "using": "nilearn",
             "depends_on": NilearnSmoothing,
@@ -85,8 +86,8 @@ class Smoothing(BasePreprocessor):
     def __init__(
         self,
         using: str,
-        on: Union[List[str], str],
-        smoothing_params: Optional[Dict] = None,
+        on: Union[list[str], str],
+        smoothing_params: Optional[dict] = None,
     ) -> None:
         """Initialize the class."""
         # Validate `using` parameter
@@ -101,7 +102,7 @@ class Smoothing(BasePreprocessor):
         )
         super().__init__(on=on)
 
-    def get_valid_inputs(self) -> List[str]:
+    def get_valid_inputs(self) -> list[str]:
         """Get valid data types for input.
 
         Returns
@@ -132,9 +133,9 @@ class Smoothing(BasePreprocessor):
 
     def preprocess(
         self,
-        input: Dict[str, Any],
-        extra_input: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Dict[str, Any]]]]:
+        input: dict[str, Any],
+        extra_input: Optional[dict[str, Any]] = None,
+    ) -> tuple[dict[str, Any], Optional[dict[str, dict[str, Any]]]]:
         """Preprocess.
 
         Parameters
@@ -163,12 +164,9 @@ class Smoothing(BasePreprocessor):
         elif self.using == "fsl":
             preprocessor = FSLSmoothing()
         # Smooth
-        output = preprocessor.preprocess(  # type: ignore
-            data=input["data"],
+        input = preprocessor.preprocess(
+            input=input,
             **self.smoothing_params,
         )
 
-        # Modify target data
-        input["data"] = output
-
         return input, None

junifer/preprocess/warping/__init__.py

@@ -3,7 +3,7 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from .space_warper import SpaceWarper
+import lazy_loader as lazy
 
 
-__all__ = ["SpaceWarper"]
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

junifer/preprocess/warping/__init__.pyi

@@ -0,0 +1,3 @@
+__all__ = ["SpaceWarper"]
+
+from .space_warper import SpaceWarper