junifer 0.0.4.dev829__py3-none-any.whl → 0.0.5__py3-none-any.whl

junifer/datagrabber/utils.py

@@ -1,230 +0,0 @@
-"""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/preprocess/ants/__init__.py

@@ -1,4 +0,0 @@
-"""Provide imports for ants sub-package."""
-
-# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
-# License: AGPL

junifer/preprocess/ants/ants_apply_transforms_warper.py

@@ -1,185 +0,0 @@
-"""Provide class for warping via ANTs antsApplyTransforms."""
-
-# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
-# License: AGPL
-
-from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    ClassVar,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Union,
-)
-
-import nibabel as nib
-import numpy as np
-
-from ...pipeline import WorkDirManager
-from ...utils import logger, raise_error, run_ext_cmd
-
-
-if TYPE_CHECKING:
-    from nibabel import Nifti1Image
-
-
-class _AntsApplyTransformsWarper:
-    """Class for warping NIfTI images via ANTs antsApplyTransforms.
-
-    Warps ANTs ``antsApplyTransforms``.
-
-    Parameters
-    ----------
-    reference : str
-        The data type to use as reference for warping.
-    on : str
-        The data type to use for warping.
-
-    Raises
-    ------
-    ValueError
-        If a list was passed for ``on``.
-
-    """
-
-    _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
-        {
-            "name": "ants",
-            "commands": ["ResampleImage", "antsApplyTransforms"],
-        },
-    ]
-
-    def __init__(self, reference: str, on: str) -> None:
-        """Initialize the class."""
-        self.ref = reference
-        # Check only single data type is passed
-        if isinstance(on, list):
-            raise_error("Can only work on single data type, list was passed.")
-        self.on = on
-
-    def _run_apply_transforms(
-        self,
-        input_data: Dict,
-        ref_path: Path,
-        warp_path: Path,
-    ) -> Tuple["Nifti1Image", Path]:
-        """Run ``antsApplyTransforms``.
-
-        Parameters
-        ----------
-        input_data : dict
-            The input data.
-        ref_path : pathlib.Path
-            The path to the reference file.
-        warp_path : pathlib.Path
-            The path to the warp file.
-
-        Returns
-        -------
-        Niimg-like object
-            The warped input image.
-        pathlib.Path
-            The path to the resampled reference image.
-
-        """
-        # Get the min of the voxel sizes from input and use it as the
-        # resolution
-        resolution = np.min(input_data["data"].header.get_zooms()[:3])
-
-        # Create element-specific tempdir for storing post-warping assets
-        tempdir = WorkDirManager().get_element_tempdir(
-            prefix="applytransforms"
-        )
-
-        # Create a tempfile for resampled reference output
-        resample_image_out_path = tempdir / "reference_resampled.nii.gz"
-        # Set ResampleImage command
-        resample_image_cmd = [
-            "ResampleImage",
-            "3",  # image dimension
-            f"{ref_path.resolve()}",
-            f"{resample_image_out_path.resolve()}",
-            f"{resolution}x{resolution}x{resolution}",
-            "0",  # option for spacing and not size
-            "3 3",  # Lanczos windowed sinc
-        ]
-        # Call ResampleImage
-        run_ext_cmd(name="ResampleImage", cmd=resample_image_cmd)
-
-        # Create a tempfile for warped output
-        apply_transforms_out_path = tempdir / "input_warped.nii.gz"
-        # Set antsApplyTransforms command
-        apply_transforms_cmd = [
-            "antsApplyTransforms",
-            "-d 3",
-            "-e 3",
-            "-n LanczosWindowedSinc",
-            f"-i {input_data['path'].resolve()}",
-            # use resampled reference
-            f"-r {resample_image_out_path.resolve()}",
-            f"-t {warp_path.resolve()}",
-            f"-o {apply_transforms_out_path.resolve()}",
-        ]
-        # Call antsApplyTransforms
-        run_ext_cmd(name="antsApplyTransforms", cmd=apply_transforms_cmd)
-
-        # Load nifti
-        output_img = nib.load(apply_transforms_out_path)
-
-        return output_img, resample_image_out_path  # type: ignore
-
-    def preprocess(
-        self,
-        input: Dict[str, Any],
-        extra_input: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[str, Dict[str, Any]]:
-        """Preprocess.
-
-        Parameters
-        ----------
-        input : dict
-            A single input from the Junifer Data object in which to preprocess.
-        extra_input : dict, optional
-            The other fields in the Junifer Data object. Must include the
-            ``Warp`` and ``ref`` value's keys.
-
-        Returns
-        -------
-        str
-            The key to store the output in the Junifer Data object.
-        dict
-            The computed result as dictionary. This will be stored in the
-            Junifer Data object under the key ``data`` of the data type.
-
-        Raises
-        ------
-        ValueError
-            If ``extra_input`` is None.
-
-        """
-        logger.debug("Warping via ANTs using antsApplyTransforms")
-        # Check for extra inputs
-        if extra_input is None:
-            raise_error(
-                f"No extra input provided, requires `Warp` and `{self.ref}` "
-                "data types in particular."
-            )
-        # Retrieve data type info to warp
-        to_warp_input = input
-        # Retrieve data type info to use as reference
-        ref_input = extra_input[self.ref]
-        # Retrieve Warp data
-        warp = extra_input["Warp"]
-        # Replace original data with warped data and add resampled reference
-        # path
-        input["data"], input["reference_path"] = self._run_apply_transforms(
-            input_data=to_warp_input,
-            ref_path=ref_input["path"],
-            warp_path=warp["path"],
-        )
-        # Use reference input's space as warped input's space
-        input["space"] = ref_input["space"]
-        return self.on, input

junifer/preprocess/ants/tests/test_ants_apply_transforms_warper.py

@@ -1,56 +0,0 @@
-"""Provide tests for AntsApplyTransformsWarper."""
-
-# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
-# License: AGPL
-
-import socket
-
-import pytest
-
-from junifer.datagrabber import DMCC13Benchmark
-from junifer.datareader import DefaultDataReader
-from junifer.pipeline.utils import _check_ants
-from junifer.preprocess.ants.ants_apply_transforms_warper import (
-    _AntsApplyTransformsWarper,
-)
-
-
-def test_AntsApplyTransformsWarper_init() -> None:
-    """Test AntsApplyTransformsWarper init."""
-    ants_apply_transforms_warper = _AntsApplyTransformsWarper(
-        reference="T1w", on="BOLD"
-    )
-    assert ants_apply_transforms_warper.ref == "T1w"
-    assert ants_apply_transforms_warper.on == "BOLD"
-
-
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-@pytest.mark.skipif(
-    socket.gethostname() != "juseless",
-    reason="only for juseless",
-)
-def test_AntsApplyTransformsWarper_preprocess() -> None:
-    """Test AntsApplyTransformsWarper preprocess."""
-    with DMCC13Benchmark(
-        types=["BOLD", "T1w", "Warp"],
-        sessions=["ses-wave1bas"],
-        tasks=["Rest"],
-        phase_encodings=["AP"],
-        runs=["1"],
-        native_t1w=True,
-    ) as dg:
-        # Read data
-        element_data = DefaultDataReader().fit_transform(
-            dg[("sub-f9057kp", "ses-wave1bas", "Rest", "AP", "1")]
-        )
-        # Preprocess data
-        data_type, data = _AntsApplyTransformsWarper(
-            reference="T1w", on="BOLD"
-        ).preprocess(
-            input=element_data["BOLD"],
-            extra_input=element_data,
-        )
-        assert isinstance(data_type, str)
-        assert isinstance(data, dict)