junifer 0.0.8.dev264__tar.gz → 0.0.8.dev270__tar.gz

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/Dockerfile-ci

@@ -115,11 +115,11 @@ RUN set -eux; \
     echo "${DATA_VERSION}" > "$HOME/junifer-data-version"
 
 # --- nilearn datasets used by junifer.testing (no downloads at test time) ---
-ARG NILEARN_VERSION=0.10.4
+ARG NILEARN_VERSION=0.14.1
 RUN <<'EOF'
 set -eux
 python3 -m venv /tmp/nilearn-venv
-/tmp/nilearn-venv/bin/pip install --no-cache-dir -q "nilearn==${NILEARN_VERSION}" "numpy<2.4"
+/tmp/nilearn-venv/bin/pip install --no-cache-dir -q "nilearn==${NILEARN_VERSION}"
 /tmp/nilearn-venv/bin/python - <<'PY'
 from nilearn import datasets
 datasets.fetch_oasis_vbm(n_subjects=10)

{junifer-0.0.8.dev264/junifer.egg-info → junifer-0.0.8.dev270}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.8.dev264
+Version: 0.0.8.dev270
 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>
@@ -34,7 +34,7 @@ Requires-Dist: scipy<1.17.0,>=1.10.0
 Requires-Dist: datalad<1.3.0,>=1.0.0
 Requires-Dist: pandas<2.4.0,>=2.0.0
 Requires-Dist: nibabel<5.4.0,>=5.2.0
-Requires-Dist: nilearn<=0.10.4,>=0.10.3
+Requires-Dist: nilearn<0.15,>=0.14.0
 Requires-Dist: sqlalchemy<=2.1.0,>=2.0.25
 Requires-Dist: ruamel.yaml<0.19,>=0.17
 Requires-Dist: h5py>=3.10

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/docs/extending/marker.rst

@@ -142,7 +142,7 @@ and the values would be a dictionary of storage type specific key-value pairs.
         # Create a masker
         masker = NiftiLabelsMasker(
             labels_img=t_parcellation,
-            standardize=True,
+            standardize="zscore_sample",
             memory="nilearn_cache",
             verbose=5,
         )
@@ -232,7 +232,7 @@ Finally, we need to register the Marker using the ``@register_marker`` decorator
             # Create a masker
             masker = NiftiLabelsMasker(
                 labels_img=t_parcellation,
-                standardize=True,
+                standardize="zscore_sample",
                 memory="nilearn_cache",
                 verbose=5,
             )

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/docs/understanding/preprocess.rst

@@ -108,8 +108,10 @@ parameters:
      - Apply detrending on timeseries, before confound removal.
      - activated
    * - ``standardize``
-     - Scale signals to unit variance.
-     - activated
+     - | Strategy to standardize the signals: ``zscore_sample`` (zero mean
+       | and unit variance), ``psc`` (percent signal change) or ``null``
+       | (no standardization).
+     - ``zscore_sample``
    * - ``low_pass``
      - Low cutoff frequencies, in Hertz.
      - deactivated

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/docs/using/codeless.rst

@@ -146,7 +146,7 @@ need to specify its name as the ``kind`` key, as well as its parameters.
         global_signal: basic
       spike: 0.2
       detrend: false
-      standardize: true
+      standardize: zscore_sample
 
 
 For the ``UCLA CNP VBM Testing dataset`` example, we will not specify a

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.8.dev264'
-__version_tuple__ = version_tuple = (0, 0, 8, 'dev264')
+__version__ = version = '0.0.8.dev270'
+__version_tuple__ = version_tuple = (0, 0, 8, 'dev270')
 
-__commit_id__ = commit_id = 'gecb1e7f7c'
+__commit_id__ = commit_id = 'gcf60784bf'

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/external/nilearn/junifer_connectivity_measure.py

@@ -18,7 +18,7 @@ from scipy import linalg, stats
 from sklearn.base import clone
 from sklearn.covariance import EmpiricalCovariance
 
-from ...utils import logger, raise_error, warn_with_log
+from ...utils import check_standardize, logger, raise_error, warn_with_log
 
 
 __all__ = ["JuniferConnectivityMeasure"]
@@ -313,9 +313,19 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
     following ways:
 
     * default ``cov_estimator`` is
-      :class:`sklearn.covariance.EmpiricalCovariance`
-    * default ``kind`` is ``"correlation"``
+      :class:`sklearn.covariance.EmpiricalCovariance` instead of
+      :class:`sklearn.covariance.LedoitWolf`, and ``cov_estimator=None`` is
+      not supported
+    * default ``kind`` is ``"correlation"`` instead of ``"covariance"``
     * supports Spearman's correlation via ``kind="spearman correlation"``
+    * supports Chatterjee's xi correlation via ``kind="xi correlation"``
+    * ``kind`` is validated when computing the matrices instead of when
+      fitting
+    * no ``verbose`` parameter, so nothing is logged while fitting
+    * ``inverse_transform()`` only knows the diagonal of
+      ``"correlation"`` and ``"partial correlation"`` matrices, so with
+      ``discard_diagonal=True`` the other kinds (including
+      ``"spearman correlation"``) need the ``diagonal`` to be passed
 
     Parameters
     ----------
@@ -329,7 +339,10 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
         If ``"spearman correlation"`` is used, the data will be ranked before
         estimating the covariance. For ``"xi correlation"``, the coefficient
         is not symmetric and should be interpreted as a measure of dependence
-        [2]_ . For the use of ``"tangent"`` see [1]_ (default "correlation").
+        [2]_ ; ``cov_estimator`` and ``standardize`` are not used, ``mean_``
+        is symmetrized and, if ``vectorize=True``, only the lower triangular
+        part is kept. For the use of ``"tangent"`` see [1]_
+        (default "correlation").
     vectorize : bool, optional
         If True, connectivity matrices are reshaped into 1D arrays and only
         their flattened lower triangular parts are returned (default False).
@@ -337,17 +350,13 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
         If True, vectorized connectivity coefficients do not include the
         matrices diagonal elements. Used only when vectorize is set to True
         (default False).
-    standardize : bool, optional
-        If standardize is True, the data are centered and normed: their mean
-        is put to 0 and their variance is put to 1 in the time dimension
-        (default True).
-
-        .. note::
-
-            Added to control passing value to ``standardize`` of
-            ``signal.clean`` to call new behavior since passing ``"zscore"`` or
-            True (default) is deprecated. This parameter will be deprecated in
-            version 0.13 and removed in version 0.15.
+    standardize : {"zscore_sample", "psc"} or None, optional
+        The strategy to standardize the signals before estimating the
+        covariance. ``"zscore_sample"`` sets them to zero mean and unit
+        variance (using the sample standard deviation), ``"psc"`` converts
+        them to percent signal change and None does not standardize them.
+        Only used for ``"correlation"`` and ``"spearman correlation"``
+        (default "zscore_sample").
 
     Attributes
     ----------
@@ -389,7 +398,7 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
         kind="correlation",
         vectorize=False,
         discard_diagonal=False,
-        standardize=True,
+        standardize="zscore_sample",
     ):
         super().__init__(
             cov_estimator=cov_estimator,
@@ -399,6 +408,59 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
             standardize=standardize,
         )
 
+    def _validate_input(
+        self,
+        X,  # noqa: N803
+        do_transform=False,
+        confounds=None,
+    ):
+        """Validate the input of ``_fit_transform``.
+
+        Parameters
+        ----------
+        X : iterable of numpy.ndarray
+            The time series of each subject.
+        do_transform : bool, optional
+            Whether the input will be transformed (default False).
+        confounds : numpy.ndarray, optional
+            The confounds (default None).
+
+        Returns
+        -------
+        list of numpy.ndarray
+            The time series of each subject.
+
+        Raises
+        ------
+        TypeError
+            If ``X`` is not iterable.
+        ValueError
+            If ``standardize`` is a boolean or
+            if ``X`` is a single subject and ``kind="tangent"``.
+
+        """
+        check_standardize(self.standardize)
+        if not hasattr(X, "__iter__"):
+            raise_error(
+                "Input must be an iterable of numpy arrays. "
+                f"Got {X.__class__.__name__}",
+                klass=TypeError,
+            )
+        # A single subject can be passed as a 2D array
+        if isinstance(X, np.ndarray) and X.ndim == 2:
+            X = [X]
+        self._check_input(X, confounds=confounds)
+        if do_transform and self.kind == "tangent" and len(X) <= 1:
+            # Check that people are applying transform to a group of subjects
+            # We can only impose this in transform,
+            # as it is legit to fit only on a single given reference point
+            raise_error(
+                "Tangent space parametrization can only be applied to a "
+                "group of subjects, as it returns deviations to the mean. "
+                f"You provided {X!r}"
+            )
+        return X
+
     def _fit_transform(
         self,
         X,  # noqa: N803
@@ -407,9 +469,19 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
         confounds=None,
     ):
         """Avoid duplication of computation."""
-        self._check_input(X, confounds=confounds)
+        X = self._validate_input(
+            X, do_transform=do_transform, confounds=confounds
+        )
         if do_fit:
+            if not hasattr(self.cov_estimator, "fit"):
+                raise_error(
+                    "'cov_estimator' must be an estimator with '.fit()' and "
+                    "'.covariance_' (e.g., from `sklearn.covariance` or a "
+                    "custom estimator constructed similarly). Got: "
+                    f"`{type(self.cov_estimator).__name__}`."
+                )
             self.cov_estimator_ = clone(self.cov_estimator)
+            self.n_features_in_ = next(iter(s.shape[1] for s in X))
 
         # Compute all the matrices, stored in "connectivities"
         if self.kind in ["correlation", "spearman correlation"]:
@@ -452,10 +524,12 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
                 ]
             else:
                 allowed_kinds = (
+                    "covariance",
                     "correlation",
+                    "spearman correlation",
                     "partial correlation",
+                    "xi correlation",
                     "tangent",
-                    "covariance",
                     "precision",
                 )
                 raise_error(
@@ -490,15 +564,6 @@ class JuniferConnectivityMeasure(ConnectivityMeasure):
 
             connectivities = np.array(connectivities)
 
-            if confounds is not None and not self.vectorize:
-                error_message = (
-                    "'confounds' are provided but vectorize=False. "
-                    "Confounds are only cleaned on vectorized matrices "
-                    "as second level connectome regression "
-                    "but not on symmetric matrices."
-                )
-                raise_error(error_message)
-
             if self.vectorize:
                 connectivities = sym_matrix_to_vec(
                     connectivities, discard_diagonal=self.discard_diagonal

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/external/nilearn/junifer_nifti_spheres_masker.py

@@ -8,16 +8,12 @@ from typing import TYPE_CHECKING, Union
 
 import numpy as np
 from nilearn import image, masking
-from nilearn._utils.class_inspect import get_params
-from nilearn._utils.niimg import img_data_dtype
-from nilearn._utils.niimg_conversions import (
-    check_niimg_3d,
-    check_niimg_4d,
-    safe_get_data,
-)
+from nilearn._utils.niimg import img_data_dtype, safe_get_data
+from nilearn.image import check_niimg_3d, check_niimg_4d, load_img
 from nilearn.maskers import NiftiSpheresMasker
-from nilearn.maskers.base_masker import _filter_and_extract
+from nilearn.maskers.base_masker import filter_and_extract
 from sklearn import neighbors
+from sklearn.utils.validation import check_is_fitted
 
 from ...utils import raise_error, warn_with_log
 
@@ -366,6 +362,7 @@ class JuniferNiftiSpheresMasker(NiftiSpheresMasker):
             radius=radius,
             mask_img=mask_img,
             allow_overlap=allow_overlap,
+            dtype=dtype,
             **kwargs,
         )
 
@@ -410,16 +407,19 @@ class JuniferNiftiSpheresMasker(NiftiSpheresMasker):
             inputs.
 
         """
-        self._check_fitted()
+        check_is_fitted(self)
 
-        params = get_params(NiftiSpheresMasker, self)
-
-        # New in nilearn 0.10.1
-        if hasattr(self, "clean_kwargs"):
-            params["clean_kwargs"] = self.clean_kwargs
+        # The parameters are taken from NiftiSpheresMasker, as the ones not
+        # in this class' signature are passed as keyword arguments
+        params = {
+            k: getattr(self, k)
+            for k in NiftiSpheresMasker._get_param_names()
+            if k not in {"memory", "memory_level", "verbose", "copy", "n_jobs"}
+        }
+        params["clean_kwargs"] = self.clean_args_
 
         signals, _ = self._cache(
-            _filter_and_extract, ignore=["verbose", "memory", "memory_level"]
+            filter_and_extract, ignore=["verbose", "memory", "memory_level"]
         )(
             imgs,
             _JuniferExtractionFunctor(
@@ -435,12 +435,18 @@ class JuniferNiftiSpheresMasker(NiftiSpheresMasker):
             confounds=confounds,
             sample_mask=sample_mask,
             dtype=self.dtype,
+            sklearn_output_config=getattr(
+                self, "_sklearn_output_config", None
+            ),
             # Caching
-            memory=self.memory,
+            memory=self.memory_,
             memory_level=self.memory_level,
             # kwargs
             verbose=self.verbose,
         )
+        target_dtype = self._get_target_dtype(load_img(imgs))
+        if target_dtype is not None:
+            signals = signals.astype(target_dtype)
         return signals
 
     def inverse_transform(self, region_signals: "ArrayLike") -> "Nifti1Image":

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/external/nilearn/tests/test_junifer_connectivity_measure.py

@@ -12,6 +12,10 @@ from typing import TYPE_CHECKING, Optional
 import numpy as np
 import pytest
 from nilearn.connectome.connectivity_matrices import sym_matrix_to_vec
+
+# Not part of nilearn's public API, so it might move in future versions.
+# Importing it evaluates the markers of nilearn's test module, which need to
+# be registered in the pytest markers (see pyproject.toml).
 from nilearn.tests.test_signal import generate_signals
 from numpy.testing import (
     assert_allclose,
@@ -21,6 +25,7 @@ from numpy.testing import (
 from pandas import DataFrame
 from scipy import linalg
 from sklearn.covariance import EmpiricalCovariance, LedoitWolf
+from sklearn.exceptions import NotFittedError
 
 from junifer.external.nilearn import JuniferConnectivityMeasure
 from junifer.external.nilearn.junifer_connectivity_measure import (
@@ -587,9 +592,7 @@ def test_connectivity_measure_errors():
     # Raising error for input subjects not iterable
     conn_measure = JuniferConnectivityMeasure()
 
-    with pytest.raises(
-        ValueError, match=r"'subjects' input argument must be an iterable"
-    ):
+    with pytest.raises(TypeError, match=r"Input must be an iterable"):
         conn_measure.fit(1.0)
 
     # input subjects not 2D numpy.ndarrays
@@ -605,6 +608,15 @@ def test_connectivity_measure_errors():
     ):
         conn_measure.fit([np.ones((100, 40)), np.ones((100, 41))])
 
+    # invalid kind, listing all the allowed kinds
+    conn_measure = JuniferConnectivityMeasure(kind="foo")
+    with pytest.raises(
+        ValueError,
+        match=r"Allowed connectivity kinds .*'spearman correlation'.*"
+        r"'xi correlation'.* Got kind foo",
+    ):
+        conn_measure.fit([np.ones((100, 40))])
+
     # fit_transform with a single subject and kind=tangent
     conn_measure = JuniferConnectivityMeasure(kind="tangent")
 
@@ -874,7 +886,7 @@ def test_connectivity_measure_check_vectorization_option(
     )
 
     # Check not fitted error
-    with pytest.raises(ValueError, match=r"has not been fitted. "):
+    with pytest.raises(NotFittedError):
         JuniferConnectivityMeasure().inverse_transform(
             vectorized_connectivities
         )
@@ -1053,15 +1065,15 @@ def test_confounds_connectivity_measure_errors() -> None:
     conn_measure = JuniferConnectivityMeasure(vectorize=True)
     msg = r"'confounds' input argument must be an iterable"
 
-    with pytest.raises(ValueError, match=msg):
+    with pytest.raises(TypeError, match=msg):
         conn_measure._check_input(X=signals, confounds=1.0)
 
-    with pytest.raises(ValueError, match=msg):
+    with pytest.raises(TypeError, match=msg):
         conn_measure._fit_transform(
             X=signals, do_fit=True, do_transform=True, confounds=1.0
         )
 
-    with pytest.raises(ValueError, match=msg):
+    with pytest.raises(TypeError, match=msg):
         conn_measure.fit_transform(X=signals, y=None, confounds=1.0)
 
     # Raising error for input confounds are given but not vectorize=True
@@ -1075,7 +1087,7 @@ def test_confounds_connectivity_measure_errors() -> None:
 def test_connectivity_measure_standardize(
     signals: list[np.ndarray],
 ) -> None:
-    """Check warning is raised and then suppressed with setting standardize.
+    """Check standardize strategies and the error for booleans.
 
     Parameters
     ----------
@@ -1083,17 +1095,17 @@ def test_connectivity_measure_standardize(
         The input signals.
 
     """
-    match = r"default strategy for standardize"
-
-    with pytest.warns(DeprecationWarning, match=match):
+    # No warnings about standardize with the default strategy
+    with warnings.catch_warnings(record=True) as record:
+        warnings.simplefilter("always")
         JuniferConnectivityMeasure(kind="correlation").fit_transform(signals)
+    assert not [m for m in record if "standardize" in str(m.message)]
 
-    with warnings.catch_warnings(record=True) as record:
-        JuniferConnectivityMeasure(
-            kind="correlation", standardize="zscore_sample"
-        ).fit_transform(signals)
-        for m in record:
-            assert match not in m.message
+    for standardize in (True, False):
+        with pytest.raises(ValueError, match="does not accept booleans"):
+            JuniferConnectivityMeasure(
+                kind="correlation", standardize=standardize
+            ).fit_transform(signals)
 
 
 @pytest.mark.skipif(

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/external/nilearn/tests/test_junifer_nifti_spheres_masker.py

@@ -3,8 +3,6 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-import warnings
-
 import nibabel
 import numpy as np
 import pytest
@@ -262,13 +260,16 @@ def test_standardization() -> None:
     data = np.random.RandomState(42).random_sample((3, 3, 3, 5))
     img = nibabel.Nifti1Image(data, np.eye(4))
 
-    # test zscore
-    masker = JuniferNiftiSpheresMasker(seeds=[(1, 1, 1)], standardize="zscore")
+    # test zscore_sample
+    masker = JuniferNiftiSpheresMasker(
+        seeds=[(1, 1, 1)], standardize="zscore_sample"
+    )
     # Test the fit
     s = masker.fit_transform(img)
 
     np.testing.assert_almost_equal(s.mean(), 0)
-    np.testing.assert_almost_equal(s.std(), 1)
+    # Uses the sample standard deviation
+    np.testing.assert_almost_equal(s.std(ddof=1), 1)
 
     # test psc
     masker = JuniferNiftiSpheresMasker(seeds=[(1, 1, 1)], standardize="psc")
@@ -294,10 +295,10 @@ def test_nifti_spheres_masker_inverse_transform() -> None:
 
 
 def test_nifti_spheres_masker_io_shapes() -> None:
-    """Ensure that masker handles 1D/2D/3D/4D data appropriately.
+    """Ensure that masker handles 3D/4D data appropriately.
 
-    transform(4D image) --> 2D output, no warning
-    transform(3D image) --> 2D output, DeprecationWarning
+    transform(4D image) --> 2D output
+    transform(3D image) --> 1D output
 
     """
     n_regions, n_volumes = 2, 5
@@ -318,20 +319,11 @@ def test_nifti_spheres_masker_io_shapes() -> None:
     )
     masker.fit()
 
-    # DeprecationWarning *should* be raised for 3D inputs
-    with pytest.warns(DeprecationWarning, match=r"Starting in version 0.12"):
-        test_data = masker.transform(img_3d)
-        assert test_data.shape == (1, n_regions)
-
-    # DeprecationWarning should *not* be raised for 4D inputs
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "error",
-            message="Starting in version 0.12",
-            category=DeprecationWarning,
-        )
-        test_data = masker.transform(img_4d)
-        assert test_data.shape == (n_volumes, n_regions)
+    test_data = masker.transform(img_3d)
+    assert test_data.shape == (n_regions,)
+
+    test_data = masker.transform(img_4d)
+    assert test_data.shape == (n_volumes, n_regions)
 
 
 @pytest.mark.parametrize(

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/markers/maps_aggregation.py

@@ -5,6 +5,7 @@
 
 from typing import Annotated, Any, ClassVar, Literal
 
+import numpy as np
 from nilearn.maskers import NiftiMapsMasker
 from pydantic import BeforeValidator
 
@@ -185,15 +186,17 @@ class MapsAggregation(BaseMarker):
                 extra_input=extra_input,
             )
 
-        # Initialize masker
+        # Initialize masker; the maps (and mask) are already tailored to the
+        # input image, so no resampling is needed
         logger.debug("Masking")
         masker = NiftiMapsMasker(
             maps_img=maps_img,
             mask_img=mask_img,
-            target_affine=t_input_img.affine,
+            resampling_target=None,
         )
         # Mask the input data and extract data
-        data = masker.fit_transform(t_input_img)
+        # nilearn maskers return 1D arrays for 3D images, keep 2D
+        data = np.atleast_2d(masker.fit_transform(t_input_img))
 
         # Apply time dimension aggregation if required
         if self.time_method is not None:

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/markers/parcel_aggregation.py

@@ -222,7 +222,8 @@ class ParcelAggregation(BaseMarker):
         logger.debug("Masking")
         masker = NiftiMasker(parcellation_bin)
         # Mask the input data and the parcellation
-        data = masker.fit_transform(t_input_img)
+        # nilearn maskers return 1D arrays for 3D images, keep 2D
+        data = np.atleast_2d(masker.fit_transform(t_input_img))
         parcellation_values = np.squeeze(
             masker.transform(parcellation_img)
         ).astype(int)

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/markers/sphere_aggregation.py

@@ -6,6 +6,7 @@
 
 from typing import Annotated, Any, ClassVar, Literal
 
+import numpy as np
 from pydantic import BeforeValidator, PositiveFloat
 
 from ..api.decorators import register_marker
@@ -221,7 +222,8 @@ class SphereAggregation(BaseMarker):
             agg_func=agg_func,
         )
         # Fit and transform the marker on the data
-        out_values = masker.fit_transform(t_input_img)
+        # nilearn maskers return 1D arrays for 3D images, keep 2D
+        out_values = np.atleast_2d(masker.fit_transform(t_input_img))
 
         # Apply time dimension aggregation if required
         if self.time_method is not None:

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/markers/tests/test_parcel_aggregation.py

@@ -115,10 +115,7 @@ def test_ParcelAggregation_3D() -> None:
             img=testing_parcellation,
         )
         # Create NiftiMasker
-        masker = NiftiMasker(
-            testing_parcellation_bin,
-            target_affine=element_data["BOLD"]["data"].affine,
-        )
+        masker = NiftiMasker(testing_parcellation_bin)
         data = masker.fit_transform(element_data["BOLD"]["data"])
         parcellation_values = np.squeeze(
             masker.transform(testing_parcellation)
@@ -225,9 +222,10 @@ def test_ParcelAggregation_VBM() -> None:
         assert_array_equal(tailored.get_fdata(), raw.get_fdata())
 
         # Compare with nilearn
-        nifti_labels_masked_vbm = NiftiLabelsMasker(
-            labels_img=raw
-        ).fit_transform(vbm["data"])
+        # nilearn returns a 1D array for 3D images
+        nifti_labels_masked_vbm = np.atleast_2d(
+            NiftiLabelsMasker(labels_img=raw).fit_transform(vbm["data"])
+        )
         assert parcel_agg_vbm_data.shape == (1, 16)
         assert_array_almost_equal(nifti_labels_masked_vbm, parcel_agg_vbm_data)
 

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/markers/tests/test_sphere_aggregation.py

@@ -6,6 +6,7 @@
 
 from pathlib import Path
 
+import numpy as np
 import pytest
 from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_equal
@@ -111,8 +112,9 @@ def test_SphereAggregation_3D() -> None:
         nifti_spheres_masker = NiftiSpheresMasker(
             seeds=testing_coords, radius=RADIUS
         )
-        nifti_spheres_masked_vbm_gm = nifti_spheres_masker.fit_transform(
-            element_data["VBM_GM"]["data"]
+        # nilearn returns a 1D array for 3D images
+        nifti_spheres_masked_vbm_gm = np.atleast_2d(
+            nifti_spheres_masker.fit_transform(element_data["VBM_GM"]["data"])
         )
 
         assert sphere_agg_vbm_gm_data.ndim == 2

{junifer-0.0.8.dev264 → junifer-0.0.8.dev270}/junifer/pipeline/tests/test_data_object_dumper.py

@@ -159,7 +159,7 @@ def test_data_object_dumper(
                     "wm_csf": "full",
                 },
                 detrend=True,
-                standardize=True,
+                standardize="zscore_sample",
             ),
         ],
         markers=[