junifer 0.0.5__py3-none-any.whl → 0.0.5.dev11__py3-none-any.whl

junifer/datagrabber/tests/test_pattern.py

@@ -236,51 +236,6 @@ def test_PatternDataGrabber(tmp_path: Path) -> None:
     assert out1["VBM_GM"]["path"] != out2["VBM_GM"]["path"]
 
 
-def test_PatternDataGrabber_unix_path_expansion(tmp_path: Path) -> None:
-    """Test PatterDataGrabber for patterns with unix path expansion.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-
-    """
-    # Create test data root dir
-    freesurfer_dir = tmp_path / "derivatives" / "freesurfer"
-    freesurfer_dir.mkdir(parents=True, exist_ok=True)
-    # Create test data sub dirs and files
-    for dir_name in ["fsaverage", "sub-0001"]:
-        mri_dir = freesurfer_dir / dir_name / "mri"
-        mri_dir.mkdir(parents=True, exist_ok=True)
-        # Create files
-        (mri_dir / "T1.mgz").touch(exist_ok=True)
-        (mri_dir / "aseg.mgz").touch(exist_ok=True)
-    # Create datagrabber
-    dg = PatternDataGrabber(
-        datadir=tmp_path,
-        types=["FreeSurfer"],
-        patterns={
-            "FreeSurfer": {
-                "pattern": "derivatives/freesurfer/[!f]{subject}/mri/T1.mg[z]",
-                "aseg": {
-                    "pattern": (
-                        "derivatives/freesurfer/[!f]{subject}/mri/aseg.mg[z]"
-                    )
-                },
-            },
-        },
-        replacements=["subject"],
-    )
-    # Check that "fsaverage" is filtered
-    elements = dg.get_elements()
-    assert elements == ["sub-0001"]
-    # Fetch data
-    out = dg["sub-0001"]
-    # Check paths are found
-    assert set(out["FreeSurfer"].keys()) == {"path", "aseg", "meta"}
-    assert list(out["FreeSurfer"]["aseg"].keys()) == ["path"]
-
-
 def test_PatternDataGrabber_confounds_format_error_on_init() -> None:
     """Test PatterDataGrabber confounds format error on initialisation."""
     with pytest.raises(

junifer/datagrabber/tests/test_pattern_datalad.py

@@ -15,13 +15,13 @@ from junifer.datagrabber import PatternDataladDataGrabber
 _testing_dataset = {
     "example_bids": {
         "uri": "https://gin.g-node.org/juaml/datalad-example-bids",
-        "commit": "b87897cbe51bf0ee5514becaa5c7dd76491db5ad",
-        "id": "8fddff30-6993-420a-9d1e-b5b028c59468",
+        "commit": "522dfb203afcd2cd55799bf347f9b211919a7338",
+        "id": "fec92475-d9c0-4409-92ba-f041b6a12c40",
     },
     "example_bids_ses": {
         "uri": "https://gin.g-node.org/juaml/datalad-example-bids-ses",
-        "commit": "6b163aa98af76a9eac0272273c27e14127850181",
-        "id": "715c17cf-a1b9-42d6-9af8-9f74c1a4a724",
+        "commit": "3d08d55d1faad4f12ab64ac9497544a0d924d47a",
+        "id": "c83500d0-532f-45be-baf1-0dab703bdc2a",
     },
 }
 

junifer/datagrabber/utils.py

@@ -0,0 +1,230 @@
+"""Provide utility functions for the datagrabber sub-package."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from typing import Dict, List
+
+from ..utils import logger, raise_error
+
+
+# Define schema for pattern-based datagrabber's patterns
+PATTERNS_SCHEMA = {
+    "T1w": {
+        "mandatory": ["pattern", "space"],
+        "optional": ["mask_item"],
+    },
+    "T1w_mask": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "T2w": {
+        "mandatory": ["pattern", "space"],
+        "optional": ["mask_item"],
+    },
+    "T2w_mask": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "BOLD": {
+        "mandatory": ["pattern", "space"],
+        "optional": ["mask_item"],
+    },
+    "BOLD_confounds": {
+        "mandatory": ["pattern", "format"],
+        "optional": [],
+    },
+    "BOLD_mask": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "Warp": {
+        "mandatory": ["pattern", "src", "dst"],
+        "optional": [],
+    },
+    "VBM_GM": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "VBM_WM": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "VBM_CSF": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "DWI": {
+        "mandatory": ["pattern"],
+        "optional": [],
+    },
+}
+
+
+def validate_types(types: List[str]) -> None:
+    """Validate the types.
+
+    Parameters
+    ----------
+    types : list of str
+        The object to validate.
+
+    Raises
+    ------
+    TypeError
+        If ``types`` is not a list or if the values are not string.
+
+    """
+    if not isinstance(types, list):
+        raise_error(msg="`types` must be a list", klass=TypeError)
+    if any(not isinstance(x, str) for x in types):
+        raise_error(msg="`types` must be a list of strings", klass=TypeError)
+
+
+def validate_replacements(
+    replacements: List[str], patterns: Dict[str, Dict[str, str]]
+) -> None:
+    """Validate the replacements.
+
+    Parameters
+    ----------
+    replacements : list of str
+        The object to validate.
+    patterns : dict
+        The patterns to validate against.
+
+    Raises
+    ------
+    TypeError
+        If ``replacements`` is not a list or if the values are not string.
+    ValueError
+        If a value in ``replacements`` is not part of a data type pattern or
+        if no data type patterns contain all values in ``replacements``.
+
+    """
+    if not isinstance(replacements, list):
+        raise_error(msg="`replacements` must be a list.", klass=TypeError)
+
+    if any(not isinstance(x, str) for x in replacements):
+        raise_error(
+            msg="`replacements` must be a list of strings.", klass=TypeError
+        )
+
+    for x in replacements:
+        if all(
+            x not in y
+            for y in [
+                data_type_val["pattern"] for data_type_val in patterns.values()
+            ]
+        ):
+            raise_error(msg=f"Replacement: {x} is not part of any pattern.")
+
+    # Check that at least one pattern has all the replacements
+    at_least_one = False
+    for data_type_val in patterns.values():
+        if all(x in data_type_val["pattern"] for x in replacements):
+            at_least_one = True
+    if at_least_one is False:
+        raise_error(msg="At least one pattern must contain all replacements.")
+
+
+def validate_patterns(
+    types: List[str], patterns: Dict[str, Dict[str, str]]
+) -> None:
+    """Validate the patterns.
+
+    Parameters
+    ----------
+    types : list of str
+        The types list.
+    patterns : dict
+        The object to validate.
+
+    Raises
+    ------
+    KeyError
+        If any mandatory key is missing for a data type.
+    RuntimeError
+        If an unknown key is found for a data type.
+    TypeError
+        If ``patterns`` is not a dictionary.
+    ValueError
+        If length of ``types`` and ``patterns`` are different or
+        if ``patterns`` is missing entries from ``types`` or
+        if unknown data type is found in ``patterns`` or
+        if data type pattern key contains '*' as value.
+
+    """
+    # Validate the types
+    validate_types(types)
+    if not isinstance(patterns, dict):
+        raise_error(msg="`patterns` must be a dict.", klass=TypeError)
+    # Unequal length of objects
+    if len(types) > len(patterns):
+        raise_error(
+            msg="Length of `types` more than that of `patterns`.",
+            klass=ValueError,
+        )
+    # Missing type in patterns
+    if any(x not in patterns for x in types):
+        raise_error(
+            msg="`patterns` must contain all `types`", klass=ValueError
+        )
+    # Check against schema
+    for data_type_key, data_type_val in patterns.items():
+        # Check if valid data type is provided
+        if data_type_key not in PATTERNS_SCHEMA:
+            raise_error(
+                f"Unknown data type: {data_type_key}, "
+                f"should be one of: {list(PATTERNS_SCHEMA.keys())}"
+            )
+        # Check mandatory keys for data type
+        for mandatory_key in PATTERNS_SCHEMA[data_type_key]["mandatory"]:
+            if mandatory_key not in data_type_val:
+                raise_error(
+                    msg=(
+                        f"Mandatory key: `{mandatory_key}` missing for "
+                        f"{data_type_key}"
+                    ),
+                    klass=KeyError,
+                )
+            else:
+                logger.debug(
+                    f"Mandatory key: `{mandatory_key}` found for "
+                    f"{data_type_key}"
+                )
+        # Check optional keys for data type
+        for optional_key in PATTERNS_SCHEMA[data_type_key]["optional"]:
+            if optional_key not in data_type_val:
+                logger.debug(
+                    f"Optional key: `{optional_key}` missing for "
+                    f"{data_type_key}"
+                )
+            else:
+                logger.debug(
+                    f"Optional key: `{optional_key}` found for "
+                    f"{data_type_key}"
+                )
+        # Check stray key for data type
+        for key in data_type_val.keys():
+            if key not in (
+                PATTERNS_SCHEMA[data_type_key]["mandatory"]
+                + PATTERNS_SCHEMA[data_type_key]["optional"]
+            ):
+                raise_error(
+                    msg=(
+                        f"Key: {key} not accepted for {data_type_key} "
+                        "pattern, remove it to proceed"
+                    ),
+                    klass=RuntimeError,
+                )
+        # Wildcard check in patterns
+        if "}*" in data_type_val["pattern"]:
+            raise_error(
+                msg=(
+                    f"`{data_type_key}.pattern` must not contain `*` "
+                    "following a replacement"
+                ),
+                klass=ValueError,
+            )

junifer/datareader/__init__.py

@@ -1,4 +1,4 @@
-"""DataReaders for datasets' data loading."""
+"""Provide imports for datareader sub-package."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Leonard Sasse <l.sasse@fz-juelich.de>
@@ -6,6 +6,3 @@
 # License: AGPL
 
 from .default import DefaultDataReader
-
-
-__all__ = ["DefaultDataReader"]

junifer/datareader/default.py

@@ -5,7 +5,7 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 import nibabel as nib
 import pandas as pd
@@ -15,9 +15,6 @@ from ..pipeline import PipelineStepMixin, UpdateMetaMixin
 from ..utils.logging import logger, warn_with_log
 
 
-__all__ = ["DefaultDataReader"]
-
-
 # Map each file extension to a type
 _extensions = {
     ".nii": "NIFTI",
@@ -105,106 +102,57 @@ class DefaultDataReader(PipelineStepMixin, UpdateMetaMixin):
         if params is None:
             params = {}
         # For each type of data, try to read it
-        for type_key, type_val in input.items():
-            # Skip Warp and FreeSurfer data type
-            if type_key in ["Warp", "FreeSurfer"]:
+        for type_ in input.keys():
+            # Skip Warp data type
+            if type_ == "Warp":
                 continue
 
             # Check for malformed datagrabber specification
-            if "path" not in type_val:
+            if "path" not in input[type_]:
                 warn_with_log(
-                    f"Input type {type_key} does not provide a path. Skipping."
+                    f"Input type {type_} does not provide a path. Skipping."
                 )
                 continue
 
-            # Iterate to check for nested "types" like mask;
-            # need to copy to avoid runtime error for changing dict size
-            for k, v in type_val.copy().items():
-                # Read data for base data type
-                if k == "path":
-                    # Convert str to Path
-                    if not isinstance(v, Path):
-                        v = Path(v)
-                    # Update path
-                    out[type_key]["path"] = v
-                    logger.info(f"Reading {type_key} from {v.absolute()!s}")
-                    # Retrieve loading params for the data type
-                    t_params = params.get(type_key, {})
-                    # Read data
-                    out[type_key]["data"] = _read_data(
-                        data_type=type_key, path=v, read_params=t_params
-                    )
-                # Read data for nested data type
-                if isinstance(v, dict) and "path" in v:
-                    # Set path
-                    nested_path = v["path"]
-                    # Convert str to Path
-                    if not isinstance(nested_path, Path):
-                        nested_path = Path(nested_path)
-                    # Update path
-                    out[type_key][k]["path"] = nested_path
-                    # Set nested type key for easier access
-                    nested_type = f"{type_key}.{k}"
-                    logger.info(
-                        f"Reading {nested_type} from "
-                        f"{nested_path.absolute()!s}"
-                    )
-                    # Retrieve loading params for the nested data type
-                    nested_params = params.get(nested_type, {})
+            # Retrieve actual path
+            t_path = input[type_]["path"]
+            # Retrieve loading params for the data type
+            t_params = params.get(type_, {})
+
+            # Convert str to Path
+            if not isinstance(t_path, Path):
+                t_path = Path(t_path)
+                out[type_]["path"] = t_path
+
+            logger.info(f"Reading {type_} from {t_path.as_posix()}")
+            # Initialize variable for file data
+            fread = None
+            # Lowercase path
+            fname = t_path.name.lower()
+            # Loop through extensions to find the correct one
+            for ext, ftype in _extensions.items():
+                if fname.endswith(ext):
+                    logger.info(f"{type_} is type {ftype}")
+                    # Retrieve reader function
+                    reader_func = _readers[ftype]["func"]
+                    # Retrieve reader function params
+                    reader_params = _readers[ftype]["params"]
+                    # Update reader function params
+                    if reader_params is not None:
+                        t_params.update(reader_params)
+                    logger.debug(f"Calling {reader_func} with {t_params}")
                     # Read data
-                    out[type_key][k]["data"] = _read_data(
-                        data_type=nested_type,
-                        path=nested_path,
-                        read_params=nested_params,
-                    )
+                    fread = reader_func(t_path, **t_params)
+                    break
+            # If no file data is found due to unknown extension
+            if fread is None:
+                logger.info(
+                    f"Unknown file type {t_path.as_posix()}, skipping reading"
+                )
 
+            # Set file data for output
+            out[type_]["data"] = fread
             # Update metadata for step
-            self.update_meta(out[type_key], "datareader")
+            self.update_meta(out[type_], "datareader")
 
         return out
-
-
-def _read_data(
-    data_type: str, path: Path, read_params: Dict
-) -> Union[nib.Nifti1Image, pd.DataFrame, None]:
-    """Read data for data type.
-
-    Parameters
-    ----------
-    data_type : str
-        The data type being read.
-    path : pathlib.Path
-        The path to read data from.
-    read_params : dict
-        Parameters for reader function.
-
-    Returns
-    -------
-    nibabel.Nifti1Image or pandas.DataFrame or pandas.TextFileReader or None
-        The data loaded in memory if file type is known else None.
-
-    """
-    # Initialize variable for file data
-    fread = None
-    # Lowercase path
-    fname = path.name.lower()
-    # Loop through extensions to find the correct one
-    for ext, ftype in _extensions.items():
-        if fname.endswith(ext):
-            logger.info(f"{data_type} is of type {ftype}")
-            # Retrieve reader function
-            reader_func = _readers[ftype]["func"]
-            # Retrieve reader function params
-            reader_params = _readers[ftype]["params"]
-            # Update reader function params
-            if reader_params is not None:
-                read_params.update(reader_params)
-            logger.debug(f"Calling {reader_func!s} with {read_params}")
-            # Read data
-            fread = reader_func(path, **read_params)
-            break
-    # If no file data is found due to unknown extension
-    if fread is None:
-        logger.info(f"Unknown file type {path.absolute()!s}, skipping reading")
-
-    return fread

junifer/external/__init__.py

@@ -1,4 +1,4 @@
-"""External tools adapted for junifer."""
+"""Provide imports for external sub-package."""
 
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL

junifer/external/nilearn/__init__.py

@@ -1,10 +1,6 @@
-"""Custom objects adapted from nilearn."""
+"""Provide imports for custom nilearn objects sub-package."""
 
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from .junifer_nifti_spheres_masker import JuniferNiftiSpheresMasker
-from .junifer_connectivity_measure import JuniferConnectivityMeasure
-
-
-__all__ = ["JuniferNiftiSpheresMasker", "JuniferConnectivityMeasure"]

junifer/external/nilearn/junifer_nifti_spheres_masker.py

@@ -10,9 +10,9 @@ 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 (
+    _safe_get_data,
     check_niimg_3d,
     check_niimg_4d,
-    safe_get_data,
 )
 from nilearn.maskers import NiftiSpheresMasker
 from nilearn.maskers.base_masker import _filter_and_extract
@@ -29,12 +29,9 @@ if TYPE_CHECKING:
     from pandas import DataFrame
 
 
-__all__ = ["JuniferNiftiSpheresMasker"]
-
-
 # New BSD License
 
-# Copyright (c) The nilearn developers.
+# Copyright (c) 2007 - 2022 The nilearn developers.
 # All rights reserved.
 
 
@@ -102,23 +99,12 @@ def _apply_mask_and_get_affinity(
         Contains the boolean indices for each sphere.
         shape: (number of seeds, number of voxels)
 
-    Raises
-    ------
-    ValueError
-        If ``niimg`` and ``mask_img`` are both provided or
-        if overlap is detected between spheres.
-
-    Warns
-    -----
-    RuntimeWarning
-        If the provided images contain NaN, they will be converted to zeroes.
-
     """
     seeds = list(seeds)
 
     # Compute world coordinates of all in-mask voxels.
     if niimg is None:
-        mask, affine = masking.load_mask_img(mask_img)
+        mask, affine = masking._load_mask_img(mask_img)
         # Get coordinate for all voxels inside of mask
         mask_coords = np.asarray(np.nonzero(mask)).T.tolist()
         X = None
@@ -132,21 +118,21 @@ def _apply_mask_and_get_affinity(
             target_shape=niimg.shape[:3],
             interpolation="nearest",
         )
-        mask, _ = masking.load_mask_img(mask_img)
+        mask, _ = masking._load_mask_img(mask_img)
         mask_coords = list(zip(*np.where(mask != 0)))
 
-        X = masking.apply_mask_fmri(niimg, mask_img)
+        X = masking._apply_mask_fmri(niimg, mask_img)
 
     elif niimg is not None:
         affine = niimg.affine
-        if np.isnan(np.sum(safe_get_data(niimg))):
+        if np.isnan(np.sum(_safe_get_data(niimg))):
             warn_with_log(
                 "The imgs you have fed into fit_transform() contains NaN "
                 "values which will be converted to zeroes."
             )
-            X = safe_get_data(niimg, True).reshape([-1, niimg.shape[3]]).T
+            X = _safe_get_data(niimg, True).reshape([-1, niimg.shape[3]]).T
         else:
-            X = safe_get_data(niimg).reshape([-1, niimg.shape[3]]).T
+            X = _safe_get_data(niimg).reshape([-1, niimg.shape[3]]).T
 
         mask_coords = list(np.ndindex(niimg.shape[:3]))
 
@@ -224,7 +210,7 @@ def _iter_signals_from_spheres(
     X, A = _apply_mask_and_get_affinity(
         seeds, niimg, radius, allow_overlap, mask_img=mask_img
     )
-    for row in A.rows:
+    for _, row in enumerate(A.rows):
         yield X[:, row]
 
 

junifer/external/nilearn/tests/test_junifer_nifti_spheres_masker.py

@@ -4,14 +4,12 @@
 # License: AGPL
 
 import warnings
-from typing import List, Tuple
 
 import nibabel
 import numpy as np
 import pytest
 from nilearn._utils import data_gen
 from nilearn.image import get_data
-from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_equal
 
 from junifer.external.nilearn import JuniferNiftiSpheresMasker
@@ -19,7 +17,7 @@ from junifer.external.nilearn import JuniferNiftiSpheresMasker
 
 # New BSD License
 
-# Copyright (c) The nilearn developers.
+# Copyright (c) 2007 - 2022 The nilearn developers.
 # All rights reserved.
 
 
@@ -333,76 +331,3 @@ def test_nifti_spheres_masker_io_shapes() -> None:
         )
         test_data = masker.transform(img_4d)
         assert test_data.shape == (n_volumes, n_regions)
-
-
-@pytest.mark.parametrize(
-    "shape",
-    [
-        (10, 11, 12),
-        (10, 11, 12, 5),
-    ],
-)
-@pytest.mark.parametrize(
-    "radius, allow_overlap",
-    [
-        (2.0, True),
-        (2.0, False),
-        (3.0, True),
-        (4.0, True),
-        (5.0, True),
-    ],
-)
-@pytest.mark.parametrize(
-    "coords",
-    [
-        [(1, 1, 1)],
-        [(1, 1, 1), (4, 4, 4)],
-        [(1, 1, 1), (4, 4, 4), (10, 10, 10)],
-    ],
-)
-def test_junifer_and_nilearn_mean_agg_are_equal(
-    shape: Tuple[int, ...],
-    radius: float,
-    allow_overlap: bool,
-    coords: List[Tuple[int, int, int]],
-) -> None:
-    """Test junifer's masker behaves same as nilearn's when agg is mean.
-
-    Parameters
-    ----------
-    shape : tuple of int
-        The parametrized shape of the input image.
-    radius : float
-        The parametrized radius of the spheres.
-    allow_overlap : bool
-        The parametrized option to overlap spheres or not.
-    coords : list of tuple of int, int and int
-        The parametrized seeds.
-
-    """
-    # Set affine
-    affine = np.eye(4)
-    # Generate random image
-    input_img, mask_img = data_gen.generate_random_img(
-        shape=shape,
-        affine=affine,
-    )
-    # Compute junifer's version
-    junifer_masker = JuniferNiftiSpheresMasker(
-        seeds=coords,
-        radius=radius,
-        allow_overlap=allow_overlap,
-        mask_img=mask_img,
-    )
-    junifer_output = junifer_masker.fit_transform(input_img)
-    # Compute nilearn's version
-    nilearn_masker = NiftiSpheresMasker(
-        seeds=coords,
-        radius=radius,
-        allow_overlap=allow_overlap,
-        mask_img=mask_img,
-    )
-    nilearn_output = nilearn_masker.fit_transform(input_img)
-    # Checks
-    assert junifer_output.shape == nilearn_output.shape
-    np.testing.assert_almost_equal(junifer_output, nilearn_output)