junifer 0.0.7.dev332__py3-none-any.whl → 0.0.8__py3-none-any.whl

junifer/preprocess/smoothing/_nilearn_smoothing.py

@@ -7,7 +7,6 @@ from typing import (
     Any,
     ClassVar,
     Literal,
-    Union,
 )
 
 import nibabel as nib
@@ -16,7 +15,7 @@ from numpy.typing import ArrayLike
 
 from ...pipeline import WorkDirManager
 from ...typing import Dependencies
-from ...utils import logger
+from ..base import logger
 
 
 __all__ = ["NilearnSmoothing"]
@@ -34,7 +33,7 @@ class NilearnSmoothing:
     def preprocess(
         self,
         input: dict[str, Any],
-        fwhm: Union[int, float, ArrayLike, Literal["fast"], None],
+        fwhm: int | float | ArrayLike | Literal["fast"] | None,
     ) -> dict[str, Any]:
         """Preprocess using nilearn.
 
@@ -75,7 +74,7 @@ class NilearnSmoothing:
         smoothed_img = nimg.smooth_img(imgs=input["data"], fwhm=fwhm)
 
         # Save smoothed output
-        smoothed_img_path = element_tempdir / "smoothed_data.nii.gz"
+        smoothed_img_path = element_tempdir / "smoothed_data.nii"
         nib.save(smoothed_img, smoothed_img_path)
 
         logger.debug("Updating smoothed data")
@@ -83,7 +82,10 @@ class NilearnSmoothing:
             {
                 # Update path to sync with "data"
                 "path": smoothed_img_path,
-                "data": smoothed_img,
+                # Update data, loaded from the file to not keep the
+                # in-memory image (memory-mapped, as the file is not
+                # compressed)
+                "data": nib.load(smoothed_img_path),
             }
         )
 

junifer/preprocess/smoothing/smoothing.py

@@ -4,18 +4,44 @@
 # License: AGPL
 
 from collections.abc import Sequence
-from typing import Any, ClassVar, Optional, Union
+from enum import StrEnum
+from typing import (
+    Annotated,
+    Any,
+    ClassVar,
+    Literal,
+)
+
+from pydantic import BeforeValidator
 
 from ...api.decorators import register_preprocessor
+from ...datagrabber import DataType
 from ...typing import ConditionalDependencies
-from ...utils import logger, raise_error
-from ..base import BasePreprocessor
+from ...utils import ensure_list_or_none
+from ..base import BasePreprocessor, logger
 from ._afni_smoothing import AFNISmoothing
 from ._fsl_smoothing import FSLSmoothing
 from ._nilearn_smoothing import NilearnSmoothing
 
 
-__all__ = ["Smoothing"]
+__all__ = ["Smoothing", "SmoothingImpl"]
+
+
+class SmoothingImpl(StrEnum):
+    """Accepted smoothing implementations.
+
+    * ``nilearn`` : :func:`nilearn.image.smooth_img`
+    * ``afni`` : AFNI's ``3dBlurToFWHM``
+    * ``fsl`` : FSL SUSAN's ``susan``
+
+    """
+
+    nilearn = "nilearn"
+    afni = "afni"
+    fsl = "fsl"
+
+
+_on = Literal[DataType.T1w, DataType.T2w, DataType.BOLD]
 
 
 @register_preprocessor
@@ -24,18 +50,13 @@ class Smoothing(BasePreprocessor):
 
     Parameters
     ----------
-    using : {"nilearn", "afni", "fsl"}
-        Implementation to use for smoothing:
-
-        * "nilearn" : Use :func:`nilearn.image.smooth_img`
-        * "afni" : Use AFNI's ``3dBlurToFWHM``
-        * "fsl" : Use FSL SUSAN's ``susan``
-
-    on : {"T1w", "T2w", "BOLD"} or list of the options
-        The data type to apply smoothing to.
+    using : :enum:`.SmoothingImpl`
+    on : {``DataType.T1w``, ``DataType.T2w``, ``DataType.BOLD``} or \
+         list of them
+        The data type(s) to apply smoothing to.
     smoothing_params : dict, optional
         Extra parameters for smoothing as a dictionary (default None).
-        If ``using="nilearn"``, then the valid keys are:
+        If ``using=SmoothingImpl.nilearn``, then the valid keys are:
 
         * ``fmhw`` : scalar, ``numpy.ndarray``, tuple or list of scalar, \
                      "fast" or None
@@ -52,13 +73,13 @@ class Smoothing(BasePreprocessor):
             - If None, no filtering is performed (useful when just removal of
               non-finite values is needed).
 
-        else if ``using="afni"``, then the valid keys are:
+        else if ``using=SmoothingImpl.afni``, then the valid keys are:
 
         * ``fwhm`` : int or float
             Smooth until the value. AFNI estimates the smoothing and then
             applies smoothing to reach ``fwhm``.
 
-        else if ``using="fsl"``, then the valid keys are:
+        else if ``using=SmoothingImpl.fsl``, then the valid keys are:
 
         * ``brightness_threshold`` : float
             Threshold to discriminate between noise and the underlying image.
@@ -71,43 +92,41 @@ class Smoothing(BasePreprocessor):
 
     _CONDITIONAL_DEPENDENCIES: ClassVar[ConditionalDependencies] = [
         {
-            "using": "nilearn",
-            "depends_on": NilearnSmoothing,
+            "using": SmoothingImpl.nilearn,
+            "depends_on": [NilearnSmoothing],
         },
         {
-            "using": "afni",
-            "depends_on": AFNISmoothing,
+            "using": SmoothingImpl.afni,
+            "depends_on": [AFNISmoothing],
         },
         {
-            "using": "fsl",
-            "depends_on": FSLSmoothing,
+            "using": SmoothingImpl.fsl,
+            "depends_on": [FSLSmoothing],
         },
     ]
-    _VALID_DATA_TYPES: ClassVar[Sequence[str]] = ["T1w", "T2w", "BOLD"]
+    _VALID_DATA_TYPES: ClassVar[Sequence[DataType]] = [
+        DataType.T1w,
+        DataType.T2w,
+        DataType.BOLD,
+    ]
 
-    def __init__(
-        self,
-        using: str,
-        on: Union[list[str], str],
-        smoothing_params: Optional[dict] = None,
-    ) -> None:
-        """Initialize the class."""
-        # Validate `using` parameter
-        valid_using = [dep["using"] for dep in self._CONDITIONAL_DEPENDENCIES]
-        if using not in valid_using:
-            raise_error(
-                f"Invalid value for `using`, should be one of: {valid_using}"
-            )
-        self.using = using
+    using: SmoothingImpl
+    on: Annotated[
+        _on | list[_on],
+        BeforeValidator(ensure_list_or_none),
+    ]
+    smoothing_params: dict | None = None
+
+    def validate_preprocessor_params(self) -> None:
+        """Run extra logical validation for preprocessor."""
         self.smoothing_params = (
-            smoothing_params if smoothing_params is not None else {}
+            self.smoothing_params if self.smoothing_params is not None else {}
         )
-        super().__init__(on=on)
 
     def preprocess(
         self,
         input: dict[str, Any],
-        extra_input: Optional[dict[str, Any]] = None,
+        extra_input: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Preprocess.
 

junifer/preprocess/smoothing/tests/test_smoothing.py

@@ -3,14 +3,20 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+from pathlib import Path
+
+import nibabel as nib
 import pytest
 
 from junifer.datareader import DefaultDataReader
 from junifer.pipeline.utils import _check_afni, _check_fsl
-from junifer.preprocess import Smoothing
+from junifer.preprocess import Smoothing, SmoothingImpl
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
+pytestmark = pytest.mark.external
+
+
 @pytest.mark.parametrize(
     "data_type",
     ["T1w", "BOLD"],
@@ -24,17 +30,22 @@ def test_Smoothing_nilearn(data_type: str) -> None:
         The parametrized data type.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
+    with SPMAuditoryTestingDataGrabber(n_timepoints=10) as dg:
         # Read data
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
         # Preprocess data
         output = Smoothing(
-            using="nilearn",
+            using=SmoothingImpl.nilearn,
             on=data_type,
             smoothing_params={"fwhm": "fast"},
         ).fit_transform(element_data)
 
         assert isinstance(output, dict)
+        # The data is loaded from the saved file, not kept in memory
+        assert nib.is_proxy(output[data_type]["data"].dataobj)
+        assert output[data_type]["data"].get_filename() == str(
+            output[data_type]["path"]
+        )
 
 
 @pytest.mark.parametrize(
@@ -44,26 +55,35 @@ def test_Smoothing_nilearn(data_type: str) -> None:
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_Smoothing_afni(data_type: str) -> None:
+def test_Smoothing_afni(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, data_type: str
+) -> None:
     """Test Smoothing using AFNI.
 
     Parameters
     ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    monkeypatch : pytest.MonkeyPatch
+        The pytest.MonkeyPatch object.
     data_type : str
         The parametrized data type.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
+    # Run in an empty directory, to check that no files are written in it
+    monkeypatch.chdir(tmp_path)
+    with SPMAuditoryTestingDataGrabber(n_timepoints=10) as dg:
         # Read data
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
         # Preprocess data
         output = Smoothing(
-            using="afni",
+            using=SmoothingImpl.afni,
             on=data_type,
             smoothing_params={"fwhm": 3},
         ).fit_transform(element_data)
 
         assert isinstance(output, dict)
+    assert list(tmp_path.iterdir()) == []
 
 
 @pytest.mark.parametrize(
@@ -80,12 +100,12 @@ def test_Smoothing_fsl(data_type: str) -> None:
         The parametrized data type.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
+    with SPMAuditoryTestingDataGrabber(n_timepoints=10) as dg:
         # Read data
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
         # Preprocess data
         output = Smoothing(
-            using="fsl",
+            using=SmoothingImpl.fsl,
             on=data_type,
             smoothing_params={"brightness_threshold": 10.0, "fwhm": 3.0},
         ).fit_transform(element_data)

junifer/preprocess/tests/test_preprocess_base.py

@@ -15,7 +15,7 @@ from junifer.preprocess.base import BasePreprocessor
 def test_base_preprocessor_abstractness() -> None:
     """Test BasePreprocessor is abstract base class."""
     with pytest.raises(TypeError, match=r"abstract"):
-        BasePreprocessor(on=["BOLD"])  # type: ignore
+        BasePreprocessor(on="BOLD")
 
 
 def test_base_preprocessor_subclassing() -> None:
@@ -25,9 +25,7 @@ def test_base_preprocessor_subclassing() -> None:
     class MyBasePreprocessor(BasePreprocessor):
         _VALID_DATA_TYPES: ClassVar[Sequence[str]] = ["BOLD", "T1w"]
 
-        def __init__(self, on):
-            self.parameter = 1
-            super().__init__(on=on)
+        parameter: int = 1
 
         def preprocess(self, input, extra_input=None):
             input["data"] = f"modified_{input['data']}"
@@ -60,7 +58,7 @@ def test_base_preprocessor_subclassing() -> None:
             },
         },
     }
-    prep = MyBasePreprocessor(on=["BOLD"])
+    prep = MyBasePreprocessor(on="BOLD")
 
     with pytest.raises(ValueError, match="not have the required data"):
         prep.validate_input(["T1w"])
@@ -75,10 +73,20 @@ def test_base_preprocessor_subclassing() -> None:
 
     meta = output["BOLD"]["meta"]
     assert "preprocess" in meta
-    assert "class" in meta["preprocess"]
-    assert "MyBasePreprocessor" == meta["preprocess"]["class"]
-    assert "parameter" in meta["preprocess"]
-    assert 1 == meta["preprocess"]["parameter"]
+    assert len(meta["preprocess"]) == 1
+    assert "class" in meta["preprocess"][0]
+    assert "MyBasePreprocessor" == meta["preprocess"][0]["class"]
+    assert "parameter" in meta["preprocess"][0]
+    assert 1 == meta["preprocess"][0]["parameter"]
+
+    # A second preprocessor is recorded after the first one
+    output = MyBasePreprocessor(on="BOLD", parameter=2).fit_transform(
+        input=output
+    )
+    assert [x["parameter"] for x in output["BOLD"]["meta"]["preprocess"]] == [
+        1,
+        2,
+    ]
 
     assert "T1w" in output
     assert "data" in output["T1w"]

junifer/preprocess/tests/test_temporal_filter.py

@@ -3,8 +3,7 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Optional
-
+import nibabel as nib
 import pytest
 
 from junifer.datareader import DefaultDataReader
@@ -12,12 +11,15 @@ from junifer.preprocess import TemporalFilter
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
+pytestmark = pytest.mark.external
+
+
 @pytest.mark.parametrize(
     "detrend, standardize, low_pass, high_pass, t_r, masks",
     (
         [
             True,
-            True,
+            "zscore_sample",
             None,
             None,
             None,
@@ -25,7 +27,7 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
         ],
         [
             False,
-            True,
+            "zscore_sample",
             0.1,
             None,
             None,
@@ -33,15 +35,15 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
         ],
         [
             True,
-            False,
+            None,
             None,
             0.08,
             None,
-            "compute_background_mask",
+            ["compute_background_mask"],
         ],
         [
             False,
-            False,
+            "psc",
             None,
             None,
             2,
@@ -49,7 +51,7 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
         ],
         [
             True,
-            True,
+            "zscore_sample",
             0.1,
             0.08,
             2,
@@ -59,11 +61,11 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 )
 def test_TemporalFilter(
     detrend: bool,
-    standardize: bool,
-    low_pass: Optional[float],
-    high_pass: Optional[float],
-    t_r: Optional[float],
-    masks: Optional[str],
+    standardize: str | None,
+    low_pass: float | None,
+    high_pass: float | None,
+    t_r: float | None,
+    masks: str | list[str] | None,
 ) -> None:
     """Test TemporalFilter.
 
@@ -71,15 +73,15 @@ def test_TemporalFilter(
     ----------
     detrend : bool
         The parametrized detrending flag.
-    standardize : bool
-        The parametrized standardization flag.
+    standardize : str or None
+        The parametrized standardization strategy.
     low_pass : float or None
         The parametrized low pass value.
     high_pass : float or None
         The parametrized high pass value.
     t_r : float or None
         The parametrized repetition time.
-    masks : str or None
+    masks : str, list of str or None
         The parametrized mask.
 
     """
@@ -97,3 +99,22 @@ def test_TemporalFilter(
         ).fit_transform(element_data)
 
         assert isinstance(output, dict)
+        # The data is loaded from the saved file, not kept in memory
+        assert nib.is_proxy(output["BOLD"]["data"].dataobj)
+        assert output["BOLD"]["data"].get_filename() == str(
+            output["BOLD"]["path"]
+        )
+
+
+@pytest.mark.parametrize("standardize", [True, False])
+def test_TemporalFilter_standardize_bool(standardize: bool) -> None:
+    """Test TemporalFilter error for boolean standardize.
+
+    Parameters
+    ----------
+    standardize : bool
+        The parametrized standardization flag.
+
+    """
+    with pytest.raises(ValueError, match="does not accept booleans"):
+        TemporalFilter(standardize=standardize)

junifer/preprocess/tests/test_temporal_slicer.py

@@ -4,8 +4,8 @@
 # License: AGPL
 
 from contextlib import AbstractContextManager, nullcontext
-from typing import Optional
 
+import nibabel as nib
 import pytest
 
 from junifer.datareader import DefaultDataReader
@@ -13,6 +13,9 @@ from junifer.preprocess import TemporalSlicer
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
+pytestmark = pytest.mark.external
+
+
 @pytest.mark.parametrize(
     "start, stop, duration, t_r, expected_dim, expect",
     (
@@ -75,14 +78,6 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
             pytest.raises(RuntimeError, match="`stop` should be None"),
         ],
         [10.0, None, 30.0, None, 30, nullcontext()],
-        [
-            -1.0,
-            None,
-            None,
-            None,
-            84,
-            pytest.raises(ValueError, match="`start` cannot be negative"),
-        ],
         [
             0.0,
             500.0,
@@ -95,9 +90,9 @@ from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 )
 def test_TemporalSlicer(
     start: float,
-    stop: Optional[float],
-    duration: Optional[float],
-    t_r: Optional[float],
+    stop: float | None,
+    duration: float | None,
+    t_r: float | None,
     expected_dim: int,
     expect: AbstractContextManager,
 ) -> None:
@@ -134,5 +129,10 @@ def test_TemporalSlicer(
 
             # Check image data dim
             assert output["BOLD"]["data"].shape[3] == expected_dim
+            # The data is loaded from the saved file, not kept in memory
+            assert nib.is_proxy(output["BOLD"]["data"].dataobj)
+            assert output["BOLD"]["data"].get_filename() == str(
+                output["BOLD"]["path"]
+            )
             # Check confounds dim
             assert output["BOLD"]["confounds"]["data"].shape[0] == expected_dim

junifer/preprocess/warping/__init__.pyi

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