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

junifer/datagrabber/tests/test_datagrabber_utils.py

@@ -3,6 +3,9 @@
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 # License: AGPL
 
+from contextlib import nullcontext
+from typing import ContextManager, Dict, List, Union
+
 import pytest
 
 from junifer.datagrabber.utils import (
@@ -12,79 +15,204 @@ from junifer.datagrabber.utils import (
 )
 
 
-def test_validate_types() -> None:
-    """Test validation of types."""
-    with pytest.raises(TypeError, match="must be a list"):
-        validate_types("wrong")  # type: ignore
-    with pytest.raises(TypeError, match="must be a list of strings"):
-        validate_types([1])  # type: ignore
-
-    validate_types(["T1w", "BOLD"])
-
-
-def test_validate_replacements() -> None:
-    """Test validation of replacements."""
-    with pytest.raises(TypeError, match="must be a list"):
-        validate_replacements("wrong", "also wrong")  # type: ignore
-    with pytest.raises(TypeError, match="must be a dict"):
-        validate_replacements(["correct"], "wrong")  # type: ignore
-
-    patterns = {
-        "T1w": "{subject}/anat/{subject}_T1w.nii.gz",
-        "BOLD": "{subject}/func/{subject}_task-rest_bold.nii.gz",
-    }
-
-    with pytest.raises(TypeError, match="must be a list of strings"):
-        validate_replacements([1], patterns)  # type: ignore
-
-    with pytest.raises(ValueError, match="is not part of"):
-        validate_replacements(["session"], patterns)
-
-    wrong_patterns = {
-        "T1w": "{subject}/anat/_T1w.nii.gz",
-        "BOLD": "{session}/func/_task-rest_bold.nii.gz",
-    }
-
-    with pytest.raises(ValueError, match="At least one pattern"):
-        validate_replacements(["subject", "session"], wrong_patterns)
-
-    validate_replacements(["subject"], patterns)
-
-
-def test_validate_patterns() -> None:
-    """Test validation of patterns."""
-    types = ["T1w", "BOLD"]
-    with pytest.raises(TypeError, match="must be a dict"):
-        validate_patterns(types, "wrong")  # type: ignore
-
-    wrongpatterns = {
-        "T1w": "{subject}/anat/{subject}_T1w.nii.gz",
-    }
-
-    with pytest.raises(
-        ValueError, match="Length of `types` more than that of `patterns`."
-    ):
-        validate_patterns(types, wrongpatterns)  # type: ignore
-
-    wrongpatterns = {
-        "T1w": "{subject}/anat/{subject}_T1w.nii.gz",
-        "T2": "{subject}/anat/{subject}_T2.nii.gz",
-    }
-
-    with pytest.raises(ValueError, match="contain all"):
-        validate_patterns(types, wrongpatterns)  # type: ignore
-
-    patterns = {
-        "T1w": "{subject}/anat/{subject}_T1w.nii.gz",
-        "BOLD": "{subject}/func/{subject}_task-rest_bold.nii.gz",
-    }
-
-    wrongpatterns = {
-        "T1w": "{subject}/anat/{subject}*.nii",
-        "BOLD": "{subject}/func/{subject}_task-rest_bold.nii.gz",
-    }
-
-    with pytest.raises(ValueError, match="following a replacement"):
-        validate_patterns(types, wrongpatterns)
-
-    validate_patterns(types, patterns)
+@pytest.mark.parametrize(
+    "types, expect",
+    [
+        ("wrong", pytest.raises(TypeError, match="must be a list")),
+        ([1], pytest.raises(TypeError, match="must be a list of strings")),
+        (["T1w", "BOLD"], nullcontext()),
+    ],
+)
+def test_validate_types(
+    types: Union[str, List[str], List[int]],
+    expect: ContextManager,
+) -> None:
+    """Test validation of types.
+
+    Parameters
+    ----------
+    types : str, list of int or str
+        The parametrized data types to validate.
+    expect : typing.ContextManager
+        The parametrized ContextManager object.
+
+    """
+    with expect:
+        validate_types(types)  # type: ignore
+
+
+@pytest.mark.parametrize(
+    "replacements, patterns, expect",
+    [
+        (
+            "wrong",
+            "also wrong",
+            pytest.raises(TypeError, match="must be a list"),
+        ),
+        (
+            [1],
+            {
+                "T1w": {"pattern": "{subject}/anat/{subject}_T1w.nii.gz"},
+                "BOLD": {
+                    "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz"
+                },
+            },
+            pytest.raises(TypeError, match="must be a list of strings"),
+        ),
+        (
+            ["session"],
+            {
+                "T1w": {"pattern": "{subject}/anat/{subject}_T1w.nii.gz"},
+                "BOLD": {
+                    "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz"
+                },
+            },
+            pytest.raises(ValueError, match="is not part of"),
+        ),
+        (
+            ["subject", "session"],
+            {
+                "T1w": {"pattern": "{subject}/anat/_T1w.nii.gz"},
+                "BOLD": {"pattern": "{session}/func/_task-rest_bold.nii.gz"},
+            },
+            pytest.raises(ValueError, match="At least one pattern"),
+        ),
+        (
+            ["subject"],
+            {
+                "T1w": {"pattern": "{subject}/anat/{subject}_T1w.nii.gz"},
+                "BOLD": {
+                    "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz"
+                },
+            },
+            nullcontext(),
+        ),
+    ],
+)
+def test_validate_replacements(
+    replacements: Union[str, List[str], List[int]],
+    patterns: Union[str, Dict[str, Dict[str, str]]],
+    expect: ContextManager,
+) -> None:
+    """Test validation of replacements.
+
+    Parameters
+    ----------
+    replacements : str, list of str or int
+        The parametrized pattern replacements to validate.
+    patterns : str, dict
+        The parametrized patterns to validate against.
+    expect : typing.ContextManager
+        The parametrized ContextManager object.
+
+    """
+    with expect:
+        validate_replacements(replacements=replacements, patterns=patterns)  # type: ignore
+
+
+@pytest.mark.parametrize(
+    "types, patterns, expect",
+    [
+        (
+            ["T1w", "BOLD"],
+            "wrong",
+            pytest.raises(TypeError, match="must be a dict"),
+        ),
+        (
+            ["T1w", "BOLD"],
+            {
+                "T1w": {"pattern": "{subject}/anat/{subject}_T1w.nii.gz"},
+            },
+            pytest.raises(
+                ValueError,
+                match="Length of `types` more than that of `patterns`.",
+            ),
+        ),
+        (
+            ["T1w", "BOLD"],
+            {
+                "T1w": {"pattern": "{subject}/anat/{subject}_T1w.nii.gz"},
+                "T2w": {"pattern": "{subject}/anat/{subject}_T2w.nii.gz"},
+            },
+            pytest.raises(ValueError, match="contain all"),
+        ),
+        (
+            ["T3w"],
+            {
+                "T3w": {"pattern": "{subject}/anat/{subject}_T3w.nii.gz"},
+            },
+            pytest.raises(ValueError, match="Unknown data type"),
+        ),
+        (
+            ["BOLD"],
+            {
+                "BOLD": {"patterns": "{subject}/func/{subject}_BOLD.nii.gz"},
+            },
+            pytest.raises(KeyError, match="Mandatory key"),
+        ),
+        (
+            ["BOLD_confounds"],
+            {
+                "BOLD_confounds": {
+                    "pattern": "{subject}/func/{subject}_confounds.tsv",
+                    "format": "fmriprep",
+                    "space": "MNINLin6Asym",
+                },
+            },
+            pytest.raises(RuntimeError, match="not accepted"),
+        ),
+        (
+            ["T1w"],
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/{subject}*.nii",
+                    "space": "native",
+                },
+            },
+            pytest.raises(ValueError, match="following a replacement"),
+        ),
+        (
+            ["T1w", "T2w", "BOLD", "BOLD_confounds"],
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/{subject}_T1w.nii.gz",
+                    "space": "native",
+                },
+                "T2w": {
+                    "pattern": "{subject}/anat/{subject}_T2w.nii.gz",
+                    "space": "native",
+                },
+                "BOLD": {
+                    "pattern": (
+                        "{subject}/func/{subject}_task-rest_bold.nii.gz"
+                    ),
+                    "space": "MNI152NLin6Asym",
+                },
+                "BOLD_confounds": {
+                    "pattern": "{subject}/func/{subject}_confounds.tsv",
+                    "format": "fmriprep",
+                },
+            },
+            nullcontext(),
+        ),
+    ],
+)
+def test_validate_patterns(
+    types: List[str],
+    patterns: Union[str, Dict[str, Dict[str, str]]],
+    expect: ContextManager,
+) -> None:
+    """Test validation of patterns.
+
+    Parameters
+    ----------
+    types : list of str
+        The parametrized data types.
+    patterns : str, dict
+        The patterns to validate.
+    expect : typing.ContextManager
+        The parametrized ContextManager object.
+
+    """
+    with expect:
+        validate_patterns(types=types, patterns=patterns)  # type: ignore

junifer/datagrabber/tests/test_datalad_base.py

@@ -26,12 +26,6 @@ _testing_dataset = {
 }
 
 
-def test_DataladDataGrabber_abstractness() -> None:
-    """Test DataladDataGrabber is abstract base class."""
-    with pytest.raises(TypeError, match=r"abstract"):
-        DataladDataGrabber()  # type: ignore
-
-
 @pytest.fixture
 def concrete_datagrabber() -> Type[DataladDataGrabber]:
     """Return a concrete datalad-based DataGrabber.

junifer/datagrabber/tests/test_dmcc13_benchmark.py

@@ -0,0 +1,256 @@
+"""Provide tests for DMCC13Benchmark DataGrabber."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from typing import List, Optional, Union
+
+import pytest
+
+from junifer.datagrabber import DMCC13Benchmark
+
+
+URI = "https://gin.g-node.org/synchon/datalad-example-dmcc13-benchmark"
+
+
+@pytest.mark.parametrize(
+    "sessions, tasks, phase_encodings, runs, native_t1w",
+    [
+        (None, None, None, None, False),
+        ("ses-wave1bas", "Rest", "AP", "1", False),
+        ("ses-wave1bas", "Axcpt", "AP", "1", False),
+        ("ses-wave1bas", "Cuedts", "AP", "1", False),
+        ("ses-wave1bas", "Stern", "AP", "1", False),
+        ("ses-wave1bas", "Stroop", "AP", "1", False),
+        ("ses-wave1bas", "Rest", "PA", "2", False),
+        ("ses-wave1bas", "Axcpt", "PA", "2", False),
+        ("ses-wave1bas", "Cuedts", "PA", "2", False),
+        ("ses-wave1bas", "Stern", "PA", "2", False),
+        ("ses-wave1bas", "Stroop", "PA", "2", False),
+        ("ses-wave1bas", "Rest", "AP", "1", True),
+        ("ses-wave1bas", "Axcpt", "AP", "1", True),
+        ("ses-wave1bas", "Cuedts", "AP", "1", True),
+        ("ses-wave1bas", "Stern", "AP", "1", True),
+        ("ses-wave1bas", "Stroop", "AP", "1", True),
+        ("ses-wave1bas", "Rest", "PA", "2", True),
+        ("ses-wave1bas", "Axcpt", "PA", "2", True),
+        ("ses-wave1bas", "Cuedts", "PA", "2", True),
+        ("ses-wave1bas", "Stern", "PA", "2", True),
+        ("ses-wave1bas", "Stroop", "PA", "2", True),
+        ("ses-wave1pro", "Rest", "AP", "1", False),
+        ("ses-wave1pro", "Rest", "PA", "2", False),
+        ("ses-wave1pro", "Rest", "AP", "1", True),
+        ("ses-wave1pro", "Rest", "PA", "2", True),
+        ("ses-wave1rea", "Rest", "AP", "1", False),
+        ("ses-wave1rea", "Rest", "PA", "2", False),
+        ("ses-wave1rea", "Rest", "AP", "1", True),
+        ("ses-wave1rea", "Rest", "PA", "2", True),
+    ],
+)
+def test_DMCC13Benchmark(
+    sessions: Optional[str],
+    tasks: Optional[str],
+    phase_encodings: Optional[str],
+    runs: Optional[str],
+    native_t1w: bool,
+) -> None:
+    """Test DMCC13Benchmark DataGrabber.
+
+    Parameters
+    ----------
+    sessions : str or None
+        The parametrized session values.
+    tasks : str or None
+        The parametrized task values.
+    phase_encodings : str or None
+        The parametrized phase encoding values.
+    runs : str or None
+        The parametrized run values.
+    native_t1w : bool
+        The parametrized values for fetching native T1w.
+
+    """
+    dg = DMCC13Benchmark(
+        sessions=sessions,
+        tasks=tasks,
+        phase_encodings=phase_encodings,
+        runs=runs,
+        native_t1w=native_t1w,
+    )
+    # Set URI to Gin
+    dg.uri = URI
+
+    with dg:
+        # Get all elements
+        all_elements = dg.get_elements()
+        # Get test element
+        test_element = all_elements[0]
+        # Get test element's access values
+        _, ses, task, phase, run = test_element
+        # Access data
+        out = dg[("sub-01", ses, task, phase, run)]
+
+        # Available data types
+        data_types = [
+            "BOLD",
+            "BOLD_confounds",
+            "BOLD_mask",
+            "VBM_CSF",
+            "VBM_GM",
+            "VBM_WM",
+            "T1w",
+            "T1w_mask",
+        ]
+        # Add Warp if native T1w is accessed
+        if native_t1w:
+            data_types.append("Warp")
+
+        # Data type file name formats
+        data_file_names = [
+            (
+                f"sub-01_{ses}_task-{task}_acq-mb4{phase}_run-{run}_"
+                "space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz"
+            ),
+            (
+                f"sub-01_{ses}_task-{task}_acq-mb4{phase}_run-{run}_"
+                "desc-confounds_regressors.tsv"
+            ),
+            (
+                f"sub-01_{ses}_task-{task}_acq-mb4{phase}_run-{run}_"
+                "space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz"
+            ),
+            "sub-01_space-MNI152NLin2009cAsym_label-CSF_probseg.nii.gz",
+            "sub-01_space-MNI152NLin2009cAsym_label-GM_probseg.nii.gz",
+            "sub-01_space-MNI152NLin2009cAsym_label-WM_probseg.nii.gz",
+        ]
+        if native_t1w:
+            data_file_names.extend(
+                [
+                    "sub-01_desc-preproc_T1w.nii.gz",
+                    "sub-01_desc-brain_mask.nii.gz",
+                    "sub-01_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5",
+                ]
+            )
+        else:
+            data_file_names.extend(
+                [
+                    "sub-01_space-MNI152NLin2009cAsym_desc-preproc_T1w.nii.gz",
+                    "sub-01_space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz",
+                ]
+            )
+
+        for data_type, data_file_name in zip(data_types, data_file_names):
+            # Assert data type
+            assert data_type in out
+            # Assert data file path exists
+            assert out[data_type]["path"].exists()
+            # Assert data file path is a file
+            assert out[data_type]["path"].is_file()
+            # Assert data file name
+            assert out[data_type]["path"].name == data_file_name
+            # Assert metadata
+            assert "meta" in out[data_type]
+
+
+@pytest.mark.parametrize(
+    "types, native_t1w",
+    [
+        ("BOLD", True),
+        ("BOLD", False),
+        ("T1w", True),
+        ("T1w", False),
+        ("VBM_CSF", True),
+        ("VBM_CSF", False),
+        ("VBM_GM", True),
+        ("VBM_GM", False),
+        ("VBM_WM", True),
+        ("VBM_WM", False),
+        (["BOLD", "BOLD_confounds"], True),
+        (["BOLD", "BOLD_confounds"], False),
+        (["T1w", "VBM_CSF"], True),
+        (["T1w", "VBM_CSF"], False),
+        (["VBM_GM", "VBM_WM"], True),
+        (["VBM_GM", "VBM_WM"], False),
+    ],
+)
+def test_DMCC13Benchmark_partial_data_access(
+    types: Union[str, List[str]],
+    native_t1w: bool,
+) -> None:
+    """Test DMCC13Benchmark DataGrabber partial data access.
+
+    Parameters
+    ----------
+    types : str or list of str
+        The parametrized types.
+    native_t1w : bool
+        The parametrized values for fetching native T1w.
+
+    """
+    dg = DMCC13Benchmark(types=types, native_t1w=native_t1w)
+    # Set URI to Gin
+    dg.uri = URI
+
+    with dg:
+        # Get all elements
+        all_elements = dg.get_elements()
+        # Get test element
+        test_element = all_elements[0]
+        # Get test element's access values
+        _, ses, task, phase, run = test_element
+        # Access data
+        out = dg[("sub-01", ses, task, phase, run)]
+        # Assert data type
+        if isinstance(types, list):
+            for type_ in types:
+                assert type_ in out
+        else:
+            assert types in out
+
+
+def test_DMCC13Benchmark_incorrect_data_type() -> None:
+    """Test DMCC13Benchmark DataGrabber incorrect data type."""
+    with pytest.raises(
+        ValueError, match="`patterns` must contain all `types`"
+    ):
+        _ = DMCC13Benchmark(types="Orcus")
+
+
+def test_DMCC13Benchmark_invalid_sessions():
+    """Test DMCC13Benchmark DataGrabber invalid sessions."""
+    with pytest.raises(
+        ValueError,
+        match=("phonyses is not a valid session in " "the DMCC dataset"),
+    ):
+        DMCC13Benchmark(sessions="phonyses")
+
+
+def test_DMCC13Benchmark_invalid_tasks():
+    """Test DMCC13Benchmark DataGrabber invalid tasks."""
+    with pytest.raises(
+        ValueError,
+        match=(
+            "thisisnotarealtask is not a valid task in " "the DMCC dataset"
+        ),
+    ):
+        DMCC13Benchmark(tasks="thisisnotarealtask")
+
+
+def test_DMCC13Benchmark_phase_encodings():
+    """Test DMCC13Benchmark DataGrabber invalid phase encodings."""
+    with pytest.raises(
+        ValueError,
+        match=(
+            "moonphase is not a valid phase encoding in " "the DMCC dataset"
+        ),
+    ):
+        DMCC13Benchmark(phase_encodings="moonphase")
+
+
+def test_DMCC13Benchmark_runs():
+    """Test DMCC13Benchmark DataGrabber invalid runs."""
+    with pytest.raises(
+        ValueError,
+        match=("cerebralrun is not a valid run in " "the DMCC dataset"),
+    ):
+        DMCC13Benchmark(runs="cerebralrun")

junifer/datagrabber/tests/test_multiple.py

@@ -26,11 +26,21 @@ def test_MultipleDataGrabber() -> None:
     rootdir = "example_bids_ses"
     replacements = ["subject", "session"]
     pattern1 = {
-        "T1w": "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz",
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
     }
     pattern2 = {
-        "BOLD": "{subject}/{session}/func/"
-        "{subject}_{session}_task-rest_bold.nii.gz",
+        "BOLD": {
+            "pattern": (
+                "{subject}/{session}/func/"
+                "{subject}_{session}_task-rest_bold.nii.gz"
+            ),
+            "space": "MNI152NLin6Asym",
+        },
     }
     dg1 = PatternDataladDataGrabber(
         rootdir=rootdir,
@@ -84,11 +94,21 @@ def test_MultipleDataGrabber_no_intersection() -> None:
     rootdir = "example_bids_ses"
     replacements = ["subject", "session"]
     pattern1 = {
-        "T1w": "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz",
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
     }
     pattern2 = {
-        "BOLD": "{subject}/{session}/func/"
-        "{subject}_{session}_task-rest_bold.nii.gz",
+        "BOLD": {
+            "pattern": (
+                "{subject}/{session}/func/"
+                "{subject}_{session}_task-rest_bold.nii.gz"
+            ),
+            "space": "MNI152NLin6Asym",
+        },
     }
     dg1 = PatternDataladDataGrabber(
         rootdir=rootdir,
@@ -119,7 +139,12 @@ def test_MultipleDataGrabber_get_item() -> None:
     rootdir = "example_bids_ses"
     replacements = ["subject", "session"]
     pattern1 = {
-        "T1w": "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz",
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
     }
     dg1 = PatternDataladDataGrabber(
         rootdir=rootdir,
@@ -142,10 +167,18 @@ def test_MultipleDataGrabber_validation() -> None:
     replacement1 = ["subject", "session"]
     replacement2 = ["subject"]
     pattern1 = {
-        "T1w": "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz",
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
     }
     pattern2 = {
-        "bold": "{subject}/func/{subject}_task-rest_bold.nii.gz",
+        "BOLD": {
+            "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz",
+            "space": "MNI152NLin6Asym",
+        },
     }
     dg1 = PatternDataladDataGrabber(
         rootdir=rootdir,
@@ -158,7 +191,7 @@ def test_MultipleDataGrabber_validation() -> None:
     dg2 = PatternDataladDataGrabber(
         rootdir=rootdir,
         uri=repo_uri2,
-        types=["bold"],
+        types=["BOLD"],
         patterns=pattern2,
         replacements=replacement2,
     )