junifer 0.0.3.dev186__py3-none-any.whl → 0.0.4__py3-none-any.whl

junifer/markers/tests/test_sphere_aggregation.py

@@ -1,22 +1,23 @@
 """Provide tests for sphere aggregation."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-import typing
 from pathlib import Path
-from typing import Dict
 
-import nibabel as nib
 import pytest
-from nilearn import datasets
-from nilearn.image import concat_imgs
 from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_equal
 
-from junifer.data import load_coordinates, load_mask
+from junifer.data import get_coordinates, get_mask
+from junifer.datareader import DefaultDataReader
 from junifer.markers.sphere_aggregation import SphereAggregation
 from junifer.storage import SQLiteFeatureStorage
+from junifer.testing.datagrabbers import (
+    OasisVBMTestingDataGrabber,
+    SPMAuditoryTestingDataGrabber,
+)
 
 
 # Define common variables
@@ -36,51 +37,66 @@ def test_SphereAggregation_input_output() -> None:
 
 def test_SphereAggregation_3D() -> None:
     """Test SphereAggregation object on 3D images."""
-    # Get the testing coordinates (for nilearn)
-    coordinates, labels = load_coordinates(COORDS)
-
-    # Get the oasis VBM data
-    oasis_dataset = datasets.fetch_oasis_vbm(n_subjects=1)
-    vbm = oasis_dataset.gray_matter_maps[0]
-    img = nib.load(vbm)
-
-    # Create NiftSpheresMasker
-    nifti_masker = NiftiSpheresMasker(seeds=coordinates, radius=RADIUS)
-    auto4d = nifti_masker.fit_transform(img)
-
-    # Create SphereAggregation object
-    marker = SphereAggregation(
-        coords=COORDS, method="mean", radius=RADIUS, on="VBM_GM"
-    )
-    input = {"VBM_GM": {"data": img, "meta": {}}}
-    jun_values4d = marker.fit_transform(input)["VBM_GM"]["data"]
+    with OasisVBMTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        # Create SphereAggregation object
+        marker = SphereAggregation(
+            coords=COORDS, method="mean", radius=RADIUS, on="VBM_GM"
+        )
+        sphere_agg_vbm_gm_data = marker.fit_transform(element_data)["VBM_GM"][
+            "data"
+        ]
+
+        # Compare with nilearn
+        # Load testing coordinates
+        testing_coords, _ = get_coordinates(
+            coords=COORDS, target_data=element_data["VBM_GM"]
+        )
+        # Extract data
+        nifti_spheres_masker = NiftiSpheresMasker(
+            seeds=testing_coords, radius=RADIUS
+        )
+        nifti_spheres_masked_vbm_gm = nifti_spheres_masker.fit_transform(
+            element_data["VBM_GM"]["data"]
+        )
 
-    assert jun_values4d.ndim == 2
-    assert_array_equal(auto4d.shape, jun_values4d.shape)
-    assert_array_equal(auto4d, jun_values4d)
+        assert sphere_agg_vbm_gm_data.ndim == 2
+        assert_array_equal(
+            nifti_spheres_masked_vbm_gm.shape, sphere_agg_vbm_gm_data.shape
+        )
+        assert_array_equal(nifti_spheres_masked_vbm_gm, sphere_agg_vbm_gm_data)
 
 
 def test_SphereAggregation_4D() -> None:
     """Test SphereAggregation object on 4D images."""
-    # Get the testing coordinates (for nilearn)
-    coordinates, _ = load_coordinates(COORDS)
-
-    # Get the SPM auditory data
-    subject_data = datasets.fetch_spm_auditory()
-    fmri_img = concat_imgs(subject_data.func)  # type: ignore
-
-    # Create NiftSpheresMasker
-    nifti_masker = NiftiSpheresMasker(seeds=coordinates, radius=RADIUS)
-    auto4d = nifti_masker.fit_transform(fmri_img)
-
-    # Create SphereAggregation object
-    marker = SphereAggregation(coords=COORDS, method="mean", radius=RADIUS)
-    input = {"BOLD": {"data": fmri_img, "meta": {}}}
-    jun_values4d = marker.fit_transform(input)["BOLD"]["data"]
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        # Create SphereAggregation object
+        marker = SphereAggregation(
+            coords=COORDS, method="mean", radius=RADIUS, on="BOLD"
+        )
+        sphere_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "data"
+        ]
+
+        # Compare with nilearn
+        # Load testing coordinates
+        testing_coords, _ = get_coordinates(
+            coords=COORDS, target_data=element_data["BOLD"]
+        )
+        # Extract data
+        nifti_spheres_masker = NiftiSpheresMasker(
+            seeds=testing_coords, radius=RADIUS
+        )
+        nifti_spheres_masked_bold = nifti_spheres_masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
 
-    assert jun_values4d.ndim == 2
-    assert_array_equal(auto4d.shape, jun_values4d.shape)
-    assert_array_equal(auto4d, jun_values4d)
+        assert sphere_agg_bold_data.ndim == 2
+        assert_array_equal(
+            nifti_spheres_masked_bold.shape, sphere_agg_bold_data.shape
+        )
+        assert_array_equal(nifti_spheres_masked_bold, sphere_agg_bold_data)
 
 
 def test_SphereAggregation_storage(tmp_path: Path) -> None:
@@ -92,124 +108,143 @@ def test_SphereAggregation_storage(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # Get the oasis VBM data
-    oasis_dataset = datasets.fetch_oasis_vbm(n_subjects=1)
-    vbm = oasis_dataset.gray_matter_maps[0]
-    img = nib.load(vbm)
-    uri = tmp_path / "test_sphere_storage_3D.sqlite"
-
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {
-        "element": {"subject": "sub-01", "session": "ses-01"},
-        "dependencies": {"nilearn", "nibabel"},
-    }
-    input = {"VBM_GM": {"data": img, "meta": meta}}
-    marker = SphereAggregation(
-        coords=COORDS, method="mean", radius=RADIUS, on="VBM_GM"
-    )
-
-    marker.fit_transform(input, storage=storage)
-
-    features: Dict = typing.cast(Dict, storage.list_features())
-    assert any(
-        x["name"] == "VBM_GM_SphereAggregation" for x in features.values()
-    )
-
-    meta = {
-        "element": {"subject": "sub-01", "session": "ses-01"},
-        "dependencies": {"nilearn", "nibabel"},
-    }
-    # Get the SPM auditory data
-    subject_data = datasets.fetch_spm_auditory()
-    fmri_img = concat_imgs(subject_data.func)  # type: ignore
-    input = {"BOLD": {"data": fmri_img, "meta": meta}}
-    marker = SphereAggregation(
-        coords=COORDS, method="mean", radius=RADIUS, on="BOLD"
-    )
-
-    marker.fit_transform(input, storage=storage)
-    features: Dict = typing.cast(Dict, storage.list_features())
-    assert any(
-        x["name"] == "BOLD_SphereAggregation" for x in features.values()
-    )
+    # Store 3D
+    with OasisVBMTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_sphere_storage_3D.sqlite", upsert="ignore"
+        )
+        marker = SphereAggregation(
+            coords=COORDS, method="mean", radius=RADIUS, on="VBM_GM"
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "VBM_GM_SphereAggregation" for x in features.values()
+        )
+
+    # Store 4D
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_sphere_storage_4D.sqlite", upsert="ignore"
+        )
+        marker = SphereAggregation(
+            coords=COORDS, method="mean", radius=RADIUS, on="BOLD"
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_SphereAggregation" for x in features.values()
+        )
 
 
 def test_SphereAggregation_3D_mask() -> None:
     """Test SphereAggregation object on 3D images using mask."""
-    # Get the testing coordinates (for nilearn)
-    coordinates, _ = load_coordinates(COORDS)
-
-    # Get one mask
-    mask_img, _ = load_mask("GM_prob0.2")
-
-    # Get the oasis VBM data
-    oasis_dataset = datasets.fetch_oasis_vbm(n_subjects=1)
-    vbm = oasis_dataset.gray_matter_maps[0]
-    img = nib.load(vbm)
-
-    # Create NiftSpheresMasker
-    nifti_masker = NiftiSpheresMasker(
-        seeds=coordinates, radius=RADIUS, mask_img=mask_img
-    )
-    auto4d = nifti_masker.fit_transform(img)
-
-    # Create SphereAggregation object
-    marker = SphereAggregation(
-        coords=COORDS,
-        method="mean",
-        radius=RADIUS,
-        on="VBM_GM",
-        masks="GM_prob0.2",
-    )
-    input = {"VBM_GM": {"data": img, "meta": {}}}
-    jun_values4d = marker.fit_transform(input)["VBM_GM"]["data"]
-
-    assert jun_values4d.ndim == 2
-    assert_array_equal(auto4d.shape, jun_values4d.shape)
-    assert_array_equal(auto4d, jun_values4d)
+    with OasisVBMTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        # Create SphereAggregation object
+        marker = SphereAggregation(
+            coords=COORDS,
+            method="mean",
+            radius=RADIUS,
+            on="VBM_GM",
+            masks="compute_brain_mask",
+        )
+        sphere_agg_vbm_gm_data = marker.fit_transform(element_data)["VBM_GM"][
+            "data"
+        ]
+
+        # Compare with nilearn
+        # Load testing coordinates
+        testing_coords, _ = get_coordinates(
+            coords=COORDS, target_data=element_data["VBM_GM"]
+        )
+        # Load mask
+        mask_img = get_mask(
+            "compute_brain_mask", target_data=element_data["VBM_GM"]
+        )
+        # Extract data
+        nifti_spheres_masker = NiftiSpheresMasker(
+            seeds=testing_coords, radius=RADIUS, mask_img=mask_img
+        )
+        nifti_spheres_masked_vbm_agg = nifti_spheres_masker.fit_transform(
+            element_data["VBM_GM"]["data"]
+        )
+
+        assert sphere_agg_vbm_gm_data.ndim == 2
+        assert_array_equal(
+            nifti_spheres_masked_vbm_agg.shape,
+            nifti_spheres_masked_vbm_agg.shape,
+        )
+        assert_array_equal(
+            nifti_spheres_masked_vbm_agg, nifti_spheres_masked_vbm_agg
+        )
 
 
 def test_SphereAggregation_4D_agg_time() -> None:
     """Test SphereAggregation object on 4D images, aggregating time."""
-    # Get the testing coordinates (for nilearn)
-    coordinates, _ = load_coordinates(COORDS)
-
-    # Get the SPM auditory data
-    subject_data = datasets.fetch_spm_auditory()
-    fmri_img = concat_imgs(subject_data.func)  # type: ignore
-
-    # Create NiftSpheresMasker
-    nifti_masker = NiftiSpheresMasker(seeds=coordinates, radius=RADIUS)
-    auto4d = nifti_masker.fit_transform(fmri_img)
-    auto_mean = auto4d.mean(axis=0)
-
-    # Create SphereAggregation object
-    marker = SphereAggregation(
-        coords=COORDS, method="mean", radius=RADIUS, time_method="mean"
-    )
-    input = {"BOLD": {"data": fmri_img, "meta": {}}}
-    jun_values4d = marker.fit_transform(input)["BOLD"]["data"]
-
-    assert jun_values4d.ndim == 1
-    assert_array_equal(auto_mean.shape, jun_values4d.shape)
-    assert_array_equal(auto_mean, jun_values4d)
-
-    auto_pick_0 = auto4d[:1, :]
-    marker = SphereAggregation(
-        coords=COORDS,
-        method="mean",
-        radius=RADIUS,
-        time_method="select",
-        time_method_params={"pick": [0]},
-    )
-
-    input = {"BOLD": {"data": fmri_img, "meta": {}}}
-    jun_values4d = marker.fit_transform(input)["BOLD"]["data"]
-
-    assert jun_values4d.ndim == 2
-    assert_array_equal(auto_pick_0.shape, jun_values4d.shape)
-    assert_array_equal(auto_pick_0, jun_values4d)
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        # Create SphereAggregation object
+        marker = SphereAggregation(
+            coords=COORDS,
+            method="mean",
+            radius=RADIUS,
+            time_method="mean",
+            on="BOLD",
+        )
+        sphere_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "data"
+        ]
+
+        # Compare with nilearn
+        # Load testing coordinates
+        testing_coords, _ = get_coordinates(
+            coords=COORDS, target_data=element_data["BOLD"]
+        )
+        # Extract data
+        nifti_spheres_masker = NiftiSpheresMasker(
+            seeds=testing_coords, radius=RADIUS
+        )
+        nifti_spheres_masked_bold = nifti_spheres_masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
+        nifti_spheres_masked_bold_mean = nifti_spheres_masked_bold.mean(axis=0)
 
+        assert sphere_agg_bold_data.ndim == 1
+        assert_array_equal(
+            nifti_spheres_masked_bold_mean.shape, sphere_agg_bold_data.shape
+        )
+        assert_array_equal(
+            nifti_spheres_masked_bold_mean, sphere_agg_bold_data
+        )
+
+        # Test picking first time point
+        nifti_spheres_masked_bold_pick_0 = nifti_spheres_masked_bold[:1, :]
+        marker = SphereAggregation(
+            coords=COORDS,
+            method="mean",
+            radius=RADIUS,
+            time_method="select",
+            time_method_params={"pick": [0]},
+            on="BOLD",
+        )
+        sphere_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "data"
+        ]
+
+        assert sphere_agg_bold_data.ndim == 2
+        assert_array_equal(
+            nifti_spheres_masked_bold_pick_0.shape, sphere_agg_bold_data.shape
+        )
+        assert_array_equal(
+            nifti_spheres_masked_bold_pick_0, sphere_agg_bold_data
+        )
+
+
+def test_SphereAggregation_errors() -> None:
+    """Test errors for SphereAggregation."""
     with pytest.raises(ValueError, match="can only be used with BOLD data"):
         SphereAggregation(
             coords=COORDS,
@@ -231,6 +266,23 @@ def test_SphereAggregation_4D_agg_time() -> None:
             on="VBM_GM",
         )
 
-    with pytest.warns(RuntimeWarning, match="No time dimension to aggregate"):
-        input = {"BOLD": {"data": fmri_img.slicer[..., 0:1], "meta": {}}}
-        marker.fit_transform(input)
+
+def test_SphereAggregation_warning() -> None:
+    """Test warning for SphereAggregation."""
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        with pytest.warns(
+            RuntimeWarning, match="No time dimension to aggregate"
+        ):
+            marker = SphereAggregation(
+                coords=COORDS,
+                method="mean",
+                radius=RADIUS,
+                time_method="select",
+                time_method_params={"pick": [0]},
+                on="BOLD",
+            )
+            element_data["BOLD"]["data"] = element_data["BOLD"]["data"].slicer[
+                ..., 0:1
+            ]
+            marker.fit_transform(element_data)

junifer/markers/utils.py

@@ -5,9 +5,10 @@
 #          Sami Hamdan <s.hamdan@fz-juelich.de>
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 #          Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Amir Omidvarnia <a.omidvarnia@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from typing import Callable, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
@@ -16,45 +17,6 @@ from scipy.stats import zscore
 from ..utils import raise_error
 
 
-def singleton(cls: Type) -> Type:
-    """Make a class singleton.
-
-    Parameters
-    ----------
-    cls : class
-        The class to designate as singleton.
-
-    Returns
-    -------
-    class
-        The only instance of the class.
-
-    """
-    instances: Dict = {}
-
-    def get_instance(*args: Any, **kwargs: Any) -> Type:
-        """Get the only instance for a class.
-
-        Parameters
-        ----------
-        *args : tuple
-            The positional arguments to pass to the class.
-        **kwargs : dict
-            The keyword arguments to pass to the class.
-
-        Returns
-        -------
-        class
-            The only instance of the class.
-
-        """
-        if cls not in instances:
-            instances[cls] = cls(*args, **kwargs)
-        return instances[cls]
-
-    return get_instance
-
-
 def _ets(
     bold_ts: np.ndarray,
     roi_names: Union[None, List[str]] = None,

junifer/onthefly/read_transform.py

@@ -17,8 +17,9 @@ if TYPE_CHECKING:
 
 def read_transform(
     storage: Type["BaseFeatureStorage"],
-    feature_name: str,
     transform: str,
+    feature_name: Optional[str] = None,
+    feature_md5: Optional[str] = None,
     transform_args: Optional[Tuple] = None,
     transform_kw_args: Optional[Dict] = None,
 ) -> pd.DataFrame:
@@ -28,11 +29,13 @@ def read_transform(
     ----------
     storage : storage-like
         The storage class, for example, SQLiteFeatureStorage.
-    feature_name : str
-        Name of the feature to read.
     transform : str
         The kind of transform formatted as ``<package>_<function>``,
         for example, ``bctpy_degrees_und``.
+    feature_name : str, optional
+        Name of the feature to read (default None).
+    feature_md5 : str, optional
+        MD5 hash of the feature to read (default None).
     transform_args : tuple, optional
         The positional arguments for the callable of ``transform``
         (default None).
@@ -62,7 +65,9 @@ def read_transform(
     transform_kw_args = transform_kw_args or {}
 
     # Read storage
-    stored_data = storage.read(feature_name=feature_name)  # type: ignore
+    stored_data = storage.read(
+        feature_name=feature_name, feature_md5=feature_md5
+    )  # type: ignore
     # Retrieve package and function
     package, func_str = transform.split("_", 1)
     # Condition for package
@@ -105,7 +110,8 @@ def read_transform(
         # Apply function and store subject-wise
         output_list = []
         logger.debug(
-            f"Computing '{package}.{func_str}' for feature {feature_name} ..."
+            f"Computing '{package}.{func_str}' for feature "
+            f"{feature_name or feature_md5} ..."
         )
         for subject in range(stored_data["data"].shape[2]):
             output = func(
@@ -119,7 +125,8 @@ def read_transform(
         idx_df = pd.DataFrame(data=stored_data["element"])
         # Create multiindex from dataframe
         logger.debug(
-            f"Generating pandas.MultiIndex for feature {feature_name} ..."
+            "Generating pandas.MultiIndex for feature "
+            f"{feature_name or feature_md5} ..."
         )
         data_idx = pd.MultiIndex.from_frame(df=idx_df)
 

junifer/pipeline/__init__.py

@@ -6,3 +6,4 @@
 from . import registry
 from .pipeline_step_mixin import PipelineStepMixin
 from .update_meta_mixin import UpdateMetaMixin
+from .workdir_manager import WorkDirManager