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

junifer/datagrabber/tests/test_multiple.py

@@ -25,28 +25,26 @@ 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=pattern1,
+        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",
+                },
+            },
+        },
         replacements=replacements,
     )
 
@@ -54,7 +52,22 @@ def test_MultipleDataGrabber() -> None:
         rootdir=rootdir,
         uri=repo_uri,
         types=["BOLD"],
-        patterns=pattern2,
+        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",
+                },
+            },
+        },
         replacements=replacements,
     )
 
@@ -73,14 +86,17 @@ 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"
@@ -89,40 +105,37 @@ 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=repo_uri1,
+        uri=_testing_dataset["example_bids"]["uri"],
         types=["T1w"],
-        patterns=pattern1,
+        patterns={
+            "T1w": {
+                "pattern": (
+                    "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+                ),
+                "space": "native",
+            },
+        },
         replacements=replacements,
     )
 
     dg2 = PatternDataladDataGrabber(
         rootdir=rootdir,
-        uri=repo_uri2,
+        uri=_testing_dataset["example_bids_ses"]["uri"],
         types=["BOLD"],
-        patterns=pattern2,
+        patterns={
+            "BOLD": {
+                "pattern": (
+                    "{subject}/{session}/func/"
+                    "{subject}_{session}_task-rest_bold.nii.gz"
+                ),
+                "space": "MNI152NLin6Asym",
+            },
+        },
         replacements=replacements,
     )
 
@@ -135,23 +148,19 @@ 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=rootdir,
-        uri=repo_uri1,
+        rootdir="example_bids_ses",
+        uri=_testing_dataset["example_bids"]["uri"],
         types=["T1w"],
-        patterns=pattern1,
-        replacements=replacements,
+        patterns={
+            "T1w": {
+                "pattern": (
+                    "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+                ),
+                "space": "native",
+            },
+        },
+        replacements=["subject", "session"],
     )
 
     dg = MultipleDataGrabber([dg1])
@@ -161,43 +170,111 @@ 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=repo_uri1,
+        uri=_testing_dataset["example_bids"]["uri"],
         types=["T1w"],
-        patterns=pattern1,
-        replacements=replacement1,
+        patterns={
+            "T1w": {
+                "pattern": (
+                    "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+                ),
+                "space": "native",
+            },
+        },
+        replacements=["subject", "session"],
     )
 
     dg2 = PatternDataladDataGrabber(
         rootdir=rootdir,
-        uri=repo_uri2,
+        uri=_testing_dataset["example_bids_ses"]["uri"],
         types=["BOLD"],
-        patterns=pattern2,
-        replacements=replacement2,
+        patterns={
+            "BOLD": {
+                "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz",
+                "space": "MNI152NLin6Asym",
+            },
+        },
+        replacements=["subject"],
     )
 
-    with pytest.raises(ValueError, match="different element key"):
+    with pytest.raises(RuntimeError, match="have different element keys"):
         MultipleDataGrabber([dg1, dg2])
 
-    with pytest.raises(ValueError, match="overlapping types"):
+    with pytest.raises(RuntimeError, match="have overlapping mandatory"):
         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"

junifer/datagrabber/tests/test_pattern.py

@@ -236,6 +236,51 @@ 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": "522dfb203afcd2cd55799bf347f9b211919a7338",
-        "id": "fec92475-d9c0-4409-92ba-f041b6a12c40",
+        "commit": "b87897cbe51bf0ee5514becaa5c7dd76491db5ad",
+        "id": "8fddff30-6993-420a-9d1e-b5b028c59468",
     },
     "example_bids_ses": {
         "uri": "https://gin.g-node.org/juaml/datalad-example-bids-ses",
-        "commit": "3d08d55d1faad4f12ab64ac9497544a0d924d47a",
-        "id": "c83500d0-532f-45be-baf1-0dab703bdc2a",
+        "commit": "6b163aa98af76a9eac0272273c27e14127850181",
+        "id": "715c17cf-a1b9-42d6-9af8-9f74c1a4a724",
     },
 }
 

junifer/datagrabber/tests/test_pattern_validation_mixin.py

@@ -0,0 +1,249 @@
+"""Provide tests for PatternValidationMixin."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from contextlib import nullcontext
+from typing import ContextManager, Dict, List, Union
+
+import pytest
+
+from junifer.datagrabber.pattern_validation_mixin import PatternValidationMixin
+
+
+@pytest.mark.parametrize(
+    "types, replacements, patterns, expect",
+    [
+        (
+            "wrong",
+            [],
+            {},
+            pytest.raises(TypeError, match="`types` must be a list"),
+        ),
+        (
+            [1],
+            [],
+            {},
+            pytest.raises(
+                TypeError, match="`types` must be a list of strings"
+            ),
+        ),
+        (
+            ["BOLD"],
+            [],
+            "wrong",
+            pytest.raises(TypeError, match="`patterns` 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="`patterns` must contain all `types`"
+            ),
+        ),
+        (
+            ["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"],
+            "",
+            {
+                "BOLD": {
+                    "pattern": (
+                        "{subject}/func/{subject}_task-rest_bold.nii.gz"
+                    ),
+                    "space": "MNINLin6Asym",
+                    "confounds": {
+                        "pattern": "{subject}/func/{subject}_confounds.tsv",
+                        "format": "fmriprep",
+                    },
+                    "zip": "zap",
+                },
+            },
+            pytest.raises(RuntimeError, match="not accepted"),
+        ),
+        (
+            ["T1w"],
+            "",
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/{subject}*.nii",
+                    "space": "native",
+                },
+            },
+            pytest.raises(ValueError, match="following a replacement"),
+        ),
+        (
+            ["T1w"],
+            "wrong",
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/{subject}_T1w.nii",
+                    "space": "native",
+                },
+            },
+            pytest.raises(TypeError, match="`replacements` must be a list"),
+        ),
+        (
+            ["T1w"],
+            [1],
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/{subject}_T1w.nii",
+                    "space": "native",
+                },
+            },
+            pytest.raises(
+                TypeError, match="`replacements` must be a list of strings"
+            ),
+        ),
+        (
+            ["T1w", "BOLD"],
+            ["subject", "session"],
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/{subject}_T1w.nii.gz",
+                    "space": "native",
+                },
+                "BOLD": {
+                    "pattern": (
+                        "{subject}/func/{subject}_task-rest_bold.nii.gz"
+                    ),
+                    "space": "MNI152NLin6Asym",
+                },
+            },
+            pytest.raises(ValueError, match="is not part of any pattern"),
+        ),
+        (
+            ["BOLD"],
+            ["subject", "session"],
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/_T1w.nii.gz",
+                    "space": "native",
+                },
+                "BOLD": {
+                    "pattern": "{session}/func/_task-rest_bold.nii.gz",
+                    "space": "MNI152NLin6Asym",
+                },
+            },
+            pytest.raises(ValueError, match="At least one pattern"),
+        ),
+        (
+            ["T1w", "T2w", "BOLD"],
+            ["subject"],
+            {
+                "T1w": {
+                    "pattern": "{subject}/anat/{subject}_T1w.nii.gz",
+                    "space": "native",
+                },
+                "T2w": {
+                    "pattern": "{subject}/anat/{subject}_T2w.nii.gz",
+                    "space": "native",
+                },
+                "BOLD": {
+                    "pattern": (
+                        "{subject}/func/{session}/{subject}_task-rest_bold.nii.gz"
+                    ),
+                    "space": "MNI152NLin6Asym",
+                    "confounds": {
+                        "pattern": "{subject}/func/{subject}_confounds.tsv",
+                        "format": "fmriprep",
+                    },
+                },
+            },
+            nullcontext(),
+        ),
+    ],
+)
+def test_PatternValidationMixin(
+    types: Union[str, List[str], List[int]],
+    replacements: Union[str, List[str], List[int]],
+    patterns: Union[str, Dict[str, Dict[str, str]]],
+    expect: ContextManager,
+) -> None:
+    """Test validation.
+
+    Parameters
+    ----------
+    types : str, list of int or str
+        The parametrized data types to validate.
+    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.
+
+    """
+
+    class MockDataGrabber(PatternValidationMixin):
+        def __init__(
+            self,
+            types,
+            replacements,
+            patterns,
+        ) -> None:
+            self.types = types
+            self.replacements = replacements
+            self.patterns = patterns
+
+        def validate(self) -> None:
+            self.validate_patterns(
+                types=self.types,
+                replacements=self.replacements,
+                patterns=self.patterns,
+            )
+
+    dg = MockDataGrabber(types, replacements, patterns)
+    with expect:
+        dg.validate()
+
+
+# This test is kept separate as bool doesn't support context manager protocol,
+# used in the earlier test
+def test_PatternValidationMixin_partial_pattern_check() -> None:
+    """Test validation for partial patterns."""
+    with pytest.warns(RuntimeWarning, match="might not work as expected"):
+        PatternValidationMixin().validate_patterns(
+            types=["BOLD"],
+            replacements=["subject"],
+            patterns={
+                "BOLD": {
+                    "mask": {
+                        "pattern": "{subject}/func/{subject}_BOLD.nii.gz",
+                        "space": "MNI152NLin6Asym",
+                    },
+                },
+            },  # type: ignore
+            partial_pattern_ok=True,
+        )

junifer/datareader/__init__.py

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