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

junifer/datagrabber/tests/test_datagrabber_utils.py

@@ -0,0 +1,218 @@
+"""Provide tests for utils."""
+
+# 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 (
+    validate_patterns,
+    validate_replacements,
+    validate_types,
+)
+
+
+@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

@@ -15,13 +15,13 @@ from junifer.datagrabber import DataladDataGrabber
 _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/tests/test_dmcc13_benchmark.py

@@ -93,10 +93,13 @@ def test_DMCC13Benchmark(
         # 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:
@@ -108,6 +111,14 @@ def test_DMCC13Benchmark(
                 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",
@@ -116,12 +127,16 @@ def test_DMCC13Benchmark(
             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.append(
-                "sub-01_space-MNI152NLin2009cAsym_desc-preproc_T1w.nii.gz"
+            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):
@@ -136,48 +151,6 @@ def test_DMCC13Benchmark(
             # Assert metadata
             assert "meta" in out[data_type]
 
-        # Check BOLD nested data types
-        for type_, file_name in zip(
-            ("mask", "confounds"),
-            (
-                (
-                    f"sub-01_{ses}_task-{task}_acq-mb4{phase}_run-{run}_"
-                    "space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz"
-                ),
-                (
-                    f"sub-01_{ses}_task-{task}_acq-mb4{phase}_run-{run}_"
-                    "desc-confounds_regressors.tsv"
-                ),
-            ),
-        ):
-            # Assert data type
-            assert type_ in out["BOLD"]
-            # Assert data file path exists
-            assert out["BOLD"][type_]["path"].exists()
-            # Assert data file path is a file
-            assert out["BOLD"][type_]["path"].is_file()
-            # Assert data file name
-            assert out["BOLD"][type_]["path"].name == file_name
-
-        # Check T1w nested data types
-        # Assert data type
-        assert "mask" in out["T1w"]
-        # Assert data file path exists
-        assert out["T1w"]["mask"]["path"].exists()
-        # Assert data file path is a file
-        assert out["T1w"]["mask"]["path"].is_file()
-        # Assert data file name
-        if native_t1w:
-            assert (
-                out["T1w"]["mask"]["path"].name
-                == "sub-01_desc-brain_mask.nii.gz"
-            )
-        else:
-            assert (
-                out["T1w"]["mask"]["path"].name
-                == "sub-01_space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz"
-            )
-
 
 @pytest.mark.parametrize(
     "types, native_t1w",
@@ -192,8 +165,8 @@ def test_DMCC13Benchmark(
         ("VBM_GM", False),
         ("VBM_WM", True),
         ("VBM_WM", False),
-        (["BOLD", "VBM_CSF"], True),
-        (["BOLD", "VBM_CSF"], False),
+        (["BOLD", "BOLD_confounds"], True),
+        (["BOLD", "BOLD_confounds"], False),
         (["T1w", "VBM_CSF"], True),
         (["T1w", "VBM_CSF"], False),
         (["VBM_GM", "VBM_WM"], True),

junifer/datagrabber/tests/test_multiple.py

@@ -25,26 +25,28 @@ def test_MultipleDataGrabber() -> None:
     repo_uri = _testing_dataset["example_bids_ses"]["uri"]
     rootdir = "example_bids_ses"
     replacements = ["subject", "session"]
-
+    pattern1 = {
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
+    }
+    pattern2 = {
+        "BOLD": {
+            "pattern": (
+                "{subject}/{session}/func/"
+                "{subject}_{session}_task-rest_bold.nii.gz"
+            ),
+            "space": "MNI152NLin6Asym",
+        },
+    }
     dg1 = PatternDataladDataGrabber(
         rootdir=rootdir,
         uri=repo_uri,
         types=["T1w"],
-        patterns={
-            "T1w": {
-                "pattern": (
-                    "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
-                ),
-                "space": "native",
-                "mask": {
-                    "pattern": (
-                        "{subject}/{session}/anat/{subject}_{session}_"
-                        "brain_mask.nii.gz"
-                    ),
-                    "space": "native",
-                },
-            },
-        },
+        patterns=pattern1,
         replacements=replacements,
     )
 
@@ -52,22 +54,7 @@ def test_MultipleDataGrabber() -> None:
         rootdir=rootdir,
         uri=repo_uri,
         types=["BOLD"],
-        patterns={
-            "BOLD": {
-                "pattern": (
-                    "{subject}/{session}/func/"
-                    "{subject}_{session}_task-rest_bold.nii.gz"
-                ),
-                "space": "MNI152NLin6Asym",
-                "mask": {
-                    "pattern": (
-                        "{subject}/{session}/func/"
-                        "{subject}_{session}_task-rest_brain_mask.nii.gz"
-                    ),
-                    "space": "MNI152NLin6Asym",
-                },
-            },
-        },
+        patterns=pattern2,
         replacements=replacements,
     )
 
@@ -86,17 +73,14 @@ def test_MultipleDataGrabber() -> None:
     with dg:
         subs = list(dg)
         assert set(subs) == set(expected_subs)
-        # Check data type
+
         elem = dg[("sub-01", "ses-01")]
-        # Check data types
         assert "T1w" in elem
         assert "BOLD" in elem
-        # Check meta
         assert "meta" in elem["BOLD"]
         meta = elem["BOLD"]["meta"]["datagrabber"]
         assert "class" in meta
         assert meta["class"] == "MultipleDataGrabber"
-        # Check datagrabbers
         assert "datagrabbers" in meta
         assert len(meta["datagrabbers"]) == 2
         assert meta["datagrabbers"][0]["class"] == "PatternDataladDataGrabber"
@@ -105,37 +89,40 @@ def test_MultipleDataGrabber() -> None:
 
 def test_MultipleDataGrabber_no_intersection() -> None:
     """Test MultipleDataGrabber without intersection (0 elements)."""
+    repo_uri1 = _testing_dataset["example_bids"]["uri"]
+    repo_uri2 = _testing_dataset["example_bids_ses"]["uri"]
     rootdir = "example_bids_ses"
     replacements = ["subject", "session"]
-
+    pattern1 = {
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
+    }
+    pattern2 = {
+        "BOLD": {
+            "pattern": (
+                "{subject}/{session}/func/"
+                "{subject}_{session}_task-rest_bold.nii.gz"
+            ),
+            "space": "MNI152NLin6Asym",
+        },
+    }
     dg1 = PatternDataladDataGrabber(
         rootdir=rootdir,
-        uri=_testing_dataset["example_bids"]["uri"],
+        uri=repo_uri1,
         types=["T1w"],
-        patterns={
-            "T1w": {
-                "pattern": (
-                    "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
-                ),
-                "space": "native",
-            },
-        },
+        patterns=pattern1,
         replacements=replacements,
     )
 
     dg2 = PatternDataladDataGrabber(
         rootdir=rootdir,
-        uri=_testing_dataset["example_bids_ses"]["uri"],
+        uri=repo_uri2,
         types=["BOLD"],
-        patterns={
-            "BOLD": {
-                "pattern": (
-                    "{subject}/{session}/func/"
-                    "{subject}_{session}_task-rest_bold.nii.gz"
-                ),
-                "space": "MNI152NLin6Asym",
-            },
-        },
+        patterns=pattern2,
         replacements=replacements,
     )
 
@@ -148,19 +135,23 @@ def test_MultipleDataGrabber_no_intersection() -> None:
 
 def test_MultipleDataGrabber_get_item() -> None:
     """Test MultipleDataGrabber get_item() error."""
+    repo_uri1 = _testing_dataset["example_bids"]["uri"]
+    rootdir = "example_bids_ses"
+    replacements = ["subject", "session"]
+    pattern1 = {
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
+    }
     dg1 = PatternDataladDataGrabber(
-        rootdir="example_bids_ses",
-        uri=_testing_dataset["example_bids"]["uri"],
+        rootdir=rootdir,
+        uri=repo_uri1,
         types=["T1w"],
-        patterns={
-            "T1w": {
-                "pattern": (
-                    "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
-                ),
-                "space": "native",
-            },
-        },
-        replacements=["subject", "session"],
+        patterns=pattern1,
+        replacements=replacements,
     )
 
     dg = MultipleDataGrabber([dg1])
@@ -170,111 +161,43 @@ def test_MultipleDataGrabber_get_item() -> None:
 
 def test_MultipleDataGrabber_validation() -> None:
     """Test MultipleDataGrabber init validation."""
+    repo_uri1 = _testing_dataset["example_bids"]["uri"]
+    repo_uri2 = _testing_dataset["example_bids_ses"]["uri"]
     rootdir = "example_bids_ses"
-
+    replacement1 = ["subject", "session"]
+    replacement2 = ["subject"]
+    pattern1 = {
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "native",
+        },
+    }
+    pattern2 = {
+        "BOLD": {
+            "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz",
+            "space": "MNI152NLin6Asym",
+        },
+    }
     dg1 = PatternDataladDataGrabber(
         rootdir=rootdir,
-        uri=_testing_dataset["example_bids"]["uri"],
+        uri=repo_uri1,
         types=["T1w"],
-        patterns={
-            "T1w": {
-                "pattern": (
-                    "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
-                ),
-                "space": "native",
-            },
-        },
-        replacements=["subject", "session"],
+        patterns=pattern1,
+        replacements=replacement1,
     )
 
     dg2 = PatternDataladDataGrabber(
         rootdir=rootdir,
-        uri=_testing_dataset["example_bids_ses"]["uri"],
+        uri=repo_uri2,
         types=["BOLD"],
-        patterns={
-            "BOLD": {
-                "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz",
-                "space": "MNI152NLin6Asym",
-            },
-        },
-        replacements=["subject"],
+        patterns=pattern2,
+        replacements=replacement2,
     )
 
-    with pytest.raises(RuntimeError, match="have different element keys"):
+    with pytest.raises(ValueError, match="different element key"):
         MultipleDataGrabber([dg1, dg2])
 
-    with pytest.raises(RuntimeError, match="have overlapping mandatory"):
+    with pytest.raises(ValueError, match="overlapping types"):
         MultipleDataGrabber([dg1, dg1])
-
-
-def test_MultipleDataGrabber_partial_pattern() -> None:
-    """Test MultipleDataGrabber partial pattern."""
-    repo_uri = _testing_dataset["example_bids_ses"]["uri"]
-    rootdir = "example_bids_ses"
-    replacements = ["subject", "session"]
-
-    dg1 = PatternDataladDataGrabber(
-        rootdir=rootdir,
-        uri=repo_uri,
-        types=["BOLD"],
-        patterns={
-            "BOLD": {
-                "pattern": (
-                    "{subject}/{session}/func/"
-                    "{subject}_{session}_task-rest_bold.nii.gz"
-                ),
-                "space": "MNI152NLin6Asym",
-            },
-        },
-        replacements=replacements,
-    )
-
-    dg2 = PatternDataladDataGrabber(
-        rootdir=rootdir,
-        uri=repo_uri,
-        types=["BOLD"],
-        patterns={
-            "BOLD": {
-                "confounds": {
-                    "pattern": (
-                        "{subject}/{session}/func/"
-                        "{subject}_{session}_task-rest_"
-                        "confounds_regressors.tsv"
-                    ),
-                    "format": "fmriprep",
-                },
-            },
-        },
-        replacements=["subject", "session"],
-        partial_pattern_ok=True,
-    )
-
-    dg = MultipleDataGrabber([dg1, dg2])
-
-    types = dg.get_types()
-    assert "BOLD" in types
-
-    expected_subs = [
-        (f"sub-{i:02d}", f"ses-{j:02d}")
-        for j in range(1, 3)
-        for i in range(1, 10)
-    ]
-
-    with dg:
-        subs = list(dg)
-        assert set(subs) == set(expected_subs)
-        # Fetch element
-        elem = dg[("sub-01", "ses-01")]
-        # Check data type and nested data type
-        assert "BOLD" in elem
-        assert "confounds" in elem["BOLD"]
-        # Check meta
-        assert "meta" in elem["BOLD"]
-        meta = elem["BOLD"]["meta"]["datagrabber"]
-        assert "class" in meta
-        assert meta["class"] == "MultipleDataGrabber"
-        # Check datagrabbers
-        assert "datagrabbers" in meta
-        assert len(meta["datagrabbers"]) == 2
-        assert meta["datagrabbers"][0]["class"] == "PatternDataladDataGrabber"
-        assert meta["datagrabbers"][1]["class"] == "PatternDataladDataGrabber"