junifer 0.0.4.dev782__py3-none-any.whl → 0.0.4.dev814__py3-none-any.whl

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,
     )

junifer/datagrabber/tests/test_pattern.py

@@ -5,6 +5,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+from itertools import product
 from pathlib import Path
 
 import pytest
@@ -21,144 +22,88 @@ def test_PatternDataGrabber_errors(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-
-    with pytest.raises(TypeError, match=r"`types` must be a list"):
-        PatternDataGrabber(
-            datadir="/tmp",
-            types="wrong",  # type: ignore
-            patterns={"wrong": "pattern"},
-            replacements="subject",  # type: ignore
-        )
-
-    with pytest.raises(TypeError, match=r"`types` must be a list of strings"):
-        PatternDataGrabber(
-            datadir="/tmp",  # type: ignore
-            types=[1, 2, 3],  # type: ignore
-            patterns={"1": "pattern", "2": "pattern", "3": "pattern"},
-            replacements="subject",  # type: ignore
-        )
-
-    with pytest.raises(
-        ValueError, match=r"`patterns` must contain all `types`"
-    ):
-        PatternDataGrabber(
-            datadir="/tmp",
-            types=["func", "anat"],
-            patterns={"1": "pattern", "2": "pattern", "3": "pattern"},
-            replacements=1,  # type: ignore
-        )
-
-    with pytest.raises(TypeError, match=r"`patterns` must be a dict"):
-        PatternDataGrabber(
-            datadir="/tmp",
-            types=["func", "anat"],
-            patterns="wrong",  # type: ignore
-            replacements="subject",  # type: ignore
-        )
-
-    with pytest.raises(
-        ValueError, match=r"Length of `types` more than that of `patterns`"
-    ):
-        PatternDataGrabber(
-            datadir="/tmp",
-            types=["func", "anat"],
-            patterns={"wrong": "pattern"},
-            replacements="subject",  # type: ignore
-        )
-
-    with pytest.raises(
-        ValueError, match=r"`patterns` must contain all `types`"
-    ):
-        PatternDataGrabber(
-            datadir="/tmp",
-            types=["func", "anat"],
-            patterns={"wrong": "pattern", "func": "pattern"},
-            replacements="subject",  # type: ignore
-        )
-
-    with pytest.raises(TypeError, match=r"must be a list of strings"):
-        PatternDataGrabber(
-            datadir="/tmp",
-            types=["func", "anat"],
-            patterns={"func": "func/test", "anat": "anat/test"},
-            replacements=1,  # type: ignore
-        )
-
-    with pytest.raises(ValueError, match=r"not part of any pattern"):
-        PatternDataGrabber(
-            datadir="/tmp",
-            types=["func", "anat"],
-            patterns={
-                "func": "func/{subject}.nii",
-                "anat": "anat/{subject}.nii",
-            },
-            replacements=["subject", "wrong"],
-        )
-
     tmpdir = tmp_path / "pattern_dg_test_errors"
 
-    datagrabber = PatternDataGrabber(
+    datagrabber_no_access = PatternDataGrabber(
         datadir=tmpdir,
-        types=["func", "anat"],
+        types=["BOLD", "T1w"],
         patterns={
-            "func": "func/{subject}_single.nii",
-            "anat": "anat/{subject}_{session}_ses.nii",
+            "BOLD": {
+                "pattern": "func/{subject}_single.nii",
+                "space": "MNI152NLin6Asym",
+            },
+            "T1w": {
+                "pattern": "anat/{subject}_{session}_ses.nii",
+                "space": "MNI152NLin6Asym",
+            },
         },
         replacements=["subject", "session"],
     )
 
     with pytest.raises(ValueError, match="element keys must be"):
-        datagrabber["sub001"]
+        datagrabber_no_access[("sub001")]
 
     # This should not work, file does not exists
-    with pytest.raises(ValueError, match="Cannot access"):
-        datagrabber["sub001", "ses001"]
+    with pytest.raises(RuntimeError, match="Cannot access"):
+        datagrabber_no_access[("sub001", "ses001")]
 
+    # Create directories and files
     (tmpdir / "func").mkdir(exist_ok=True, parents=True)
     (tmpdir / "anat").mkdir(exist_ok=True, parents=True)
-    for t_subject in range(3):
-        for t_session in range(2):
-            subject = f"sub{t_subject:03d}"
-            session = f"ses{t_session:03d}"
-            (tmpdir / "func" / f"{subject}_single.nii").touch()
-            if t_subject == 2:
-                (tmpdir / "func" / f"{subject}_extra.nii").touch()
-            (tmpdir / "anat" / f"{subject}_{session}_ses.nii").touch()
+    for t_subject, t_session in product(range(3), range(2)):
+        subject = f"sub{t_subject:03d}"
+        session = f"ses{t_session:03d}"
+        (tmpdir / "func" / f"{subject}_single.nii").touch()
+        if t_subject == 2:
+            (tmpdir / "func" / f"{subject}_extra.nii").touch()
+        (tmpdir / "anat" / f"{subject}_{session}_ses.nii").touch()
 
     # This should work, file now exists
-    datagrabber["sub001", "ses001"]
+    datagrabber_no_access[("sub001", "ses001")]
 
-    datagrabber = PatternDataGrabber(
+    datagrabber_multi_access = PatternDataGrabber(
         datadir=tmpdir,
-        types=["func", "anat"],
+        types=["BOLD", "T1w"],
         patterns={
-            "func": "func/{subject}_*.nii",
-            "anat": "anat/{subject}_{session}_*.nii",
+            "BOLD": {
+                "pattern": "func/{subject}_*.nii",
+                "space": "MNI152NLin6Asym",
+            },
+            "T1w": {
+                "pattern": "anat/{subject}_{session}_*.nii",
+                "space": "MNI152NLin6Asym",
+            },
         },
         replacements=["subject", "session"],
     )
 
-    # access a subject with a missing session
-    with pytest.raises(ValueError, match="No file matches"):
-        datagrabber["sub001", "ses004"]
+    # Access a subject with a missing session
+    with pytest.raises(RuntimeError, match="No file matches"):
+        datagrabber_multi_access[("sub001", "ses004")]
 
-    # access a subject with two matching files
-    with pytest.raises(ValueError, match="More than one"):
-        datagrabber["sub002", "ses001"]
+    # Access a subject with two matching files
+    with pytest.raises(RuntimeError, match="More than one"):
+        datagrabber_multi_access[("sub002", "ses001")]
 
-    # access the right one
-    datagrabber["sub001", "ses001"]
+    # Access the right one
+    datagrabber_multi_access[("sub001", "ses001")]
 
-    datagrabber = PatternDataGrabber(
+    datagrabber_fake_access = PatternDataGrabber(
         datadir=tmpdir,
-        types=["func", "anat2"],
+        types=["BOLD", "T1w"],
         patterns={
-            "func": "func/{subject}_single.nii",
-            "anat2": "anat2/{subject}_{session}_ses.nii",
+            "BOLD": {
+                "pattern": "func/{subject}_single.nii",
+                "space": "MNI152NLin6Asym",
+            },
+            "T1w": {
+                "pattern": "anat2/{subject}_{session}_ses.nii",
+                "space": "MNI152NLin6Asym",
+            },
         },
         replacements=["subject", "session"],
     )
-    assert len(datagrabber.get_elements()) == 0
+    assert len(datagrabber_fake_access.get_elements()) == 0
 
 
 def test_PatternDataGrabber(tmp_path: Path) -> None:
@@ -171,43 +116,59 @@ def test_PatternDataGrabber(tmp_path: Path) -> None:
 
     """
 
-    datagrabber = PatternDataGrabber(
+    datagrabber_first = PatternDataGrabber(
         datadir="/tmp/data",
-        types=["func", "anat"],
-        patterns={"func": "func/{subject}.nii", "anat": "anat/{subject}.nii"},
+        types=["BOLD", "T1w"],
+        patterns={
+            "BOLD": {
+                "pattern": "func/{subject}.nii",
+                "space": "MNI152NLin6Asym",
+            },
+            "T1w": {
+                "pattern": "anat/{subject}.nii",
+                "space": "native",
+            },
+        },
         replacements="subject",
     )
-    assert datagrabber.datadir == Path("/tmp/data")
-    assert datagrabber.types == ["func", "anat"]
-    assert datagrabber.replacements == ["subject"]
+    assert datagrabber_first.datadir == Path("/tmp/data")
+    assert set(datagrabber_first.types) == {"T1w", "BOLD"}
+    assert datagrabber_first.replacements == ["subject"]
 
-    datagrabber = PatternDataGrabber(
+    datagrabber_second = PatternDataGrabber(
         datadir=Path("/tmp/data"),
-        types=["func", "anat"],
+        types=["BOLD", "T1w"],
         patterns={
-            "func": "func/{subject}.nii",
-            "anat": "anat/{subject}_{session}.nii",
+            "BOLD": {
+                "pattern": "func/{subject}.nii",
+                "space": "MNI152NLin6Asym",
+            },
+            "T1w": {
+                "pattern": "anat/{subject}_{session}.nii",
+                "space": "native",
+            },
         },
         replacements=["subject", "session"],
     )
-    assert datagrabber.datadir == Path("/tmp/data")
-    assert datagrabber.types == ["func", "anat"]
-    assert datagrabber.replacements == ["subject", "session"]
+    assert datagrabber_second.datadir == Path("/tmp/data")
+    assert set(datagrabber_second.types) == {"T1w", "BOLD"}
+    assert datagrabber_second.replacements == ["subject", "session"]
 
+    # Create directories and files
     tmpdir = tmp_path / "pattern_dg_test"
     (tmpdir / "func").mkdir(exist_ok=True, parents=True)
     (tmpdir / "anat").mkdir(exist_ok=True, parents=True)
     (tmpdir / "vbm").mkdir(exist_ok=True, parents=True)
-    for t_subject in range(3):
-        for t_session in range(2):
-            for t_task in range(2, 4):
-                subject = f"sub{t_subject:03d}"
-                session = f"ses{t_session:03d}"
-                task = f"task{t_task:03d}"
-                if t_subject != 2:
-                    (tmpdir / "func" / f"{subject}.nii").touch()
-                (tmpdir / "anat" / f"{subject}_{session}.nii").touch()
-                (tmpdir / "vbm" / f"{subject}_{task}_{session}.nii").touch()
+    for t_subject, t_session, t_task in product(
+        range(3), range(2), range(2, 4)
+    ):
+        subject = f"sub{t_subject:03d}"
+        session = f"ses{t_session:03d}"
+        task = f"task{t_task:03d}"
+        if t_subject != 2:
+            (tmpdir / "func" / f"{subject}.nii").touch()
+        (tmpdir / "anat" / f"{subject}_{session}.nii").touch()
+        (tmpdir / "vbm" / f"{subject}_{task}_{session}.nii").touch()
 
     expected_elements = [
         ("sub000", "ses000"),
@@ -218,16 +179,19 @@ def test_PatternDataGrabber(tmp_path: Path) -> None:
         ("sub002", "ses001"),
     ]
 
-    datagrabber = PatternDataGrabber(
+    datagrabber_third = PatternDataGrabber(
         datadir=tmpdir,
-        types=["anat"],
+        types=["T1w"],
         patterns={
-            "anat": "anat/{subject}_{session}.nii",
+            "T1w": {
+                "pattern": "anat/{subject}_{session}.nii",
+                "space": "native",
+            },
         },
         replacements=["subject", "session"],
     )
 
-    elements = datagrabber.get_elements()
+    elements = datagrabber_third.get_elements()
     assert set(elements) == set(expected_elements)
 
     expected_elements = [
@@ -241,26 +205,35 @@ def test_PatternDataGrabber(tmp_path: Path) -> None:
         ("sub001", "ses001", "task003"),
     ]
 
-    datagrabber = PatternDataGrabber(
+    datagrabber_fourth = PatternDataGrabber(
         datadir=tmpdir,
-        types=["func", "anat", "vbm"],
+        types=["T1w", "BOLD", "VBM_GM"],
         patterns={
-            "func": "func/{subject}.nii",
-            "anat": "anat/{subject}_{session}.nii",
-            "vbm": "vbm/{subject}_{task}_{session}.nii",
+            "BOLD": {
+                "pattern": "func/{subject}.nii",
+                "space": "MNI152NLin6Asym",
+            },
+            "T1w": {
+                "pattern": "anat/{subject}_{session}.nii",
+                "space": "native",
+            },
+            "VBM_GM": {
+                "pattern": "vbm/{subject}_{task}_{session}.nii",
+                "space": "MNI152NLin6Asym",
+            },
         },
         replacements=["subject", "session", "task"],
     )
 
-    elements = datagrabber.get_elements()
+    elements = datagrabber_fourth.get_elements()
     assert set(elements) == set(expected_elements)
 
-    out1 = datagrabber[("sub000", "ses000", "task002")]
-    out2 = datagrabber[("sub000", "ses000", "task003")]
+    out1 = datagrabber_fourth[("sub000", "ses000", "task002")]
+    out2 = datagrabber_fourth[("sub000", "ses000", "task003")]
 
-    assert out1["func"]["path"] == out2["func"]["path"]
-    assert out1["anat"]["path"] == out2["anat"]["path"]
-    assert out1["vbm"]["path"] != out2["vbm"]["path"]
+    assert out1["BOLD"]["path"] == out2["BOLD"]["path"]
+    assert out1["T1w"]["path"] == out2["T1w"]["path"]
+    assert out1["VBM_GM"]["path"] != out2["VBM_GM"]["path"]
 
 
 def test_PatternDataGrabber_confounds_format_error_on_init() -> None:
@@ -269,40 +242,14 @@ def test_PatternDataGrabber_confounds_format_error_on_init() -> None:
         ValueError, match="Invalid value for `confounds_format`"
     ):
         PatternDataGrabber(
-            types=["func"],
-            patterns={"func": "func/{subject}.nii"},
+            types=["BOLD"],
+            patterns={
+                "BOLD": {
+                    "pattern": "func/{subject}.nii",
+                    "space": "MNI152NLin6Asym",
+                },
+            },
             replacements=["subject"],
             datadir="/tmp",
             confounds_format="foobar",
         )
-
-
-def test_PatternDataGrabber_confounds_format_error_on_fetch(
-    tmp_path: Path,
-) -> None:
-    """Test PatterDataGrabber confounds format error on fetching.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-
-    """
-    # Create test directory path
-    tmpdir = tmp_path / "pattern_dg_test"
-    # Create final test directory
-    (tmpdir / "func" / "confounds").mkdir(exist_ok=True, parents=True)
-    # Create test confound file
-    (tmpdir / "func" / "confounds" / "sub-001.nii").touch()
-    # Initialize datagrabber
-    datagrabber = PatternDataGrabber(
-        types=["BOLD_confounds"],
-        patterns={"BOLD_confounds": "func/confounds/{subject}.nii"},
-        replacements=["subject"],
-        datadir=tmpdir,
-    )
-    # Check error on fetch
-    with pytest.raises(
-        ValueError, match="As the DataGrabber used specifies 'BOLD_confounds'"
-    ):
-        datagrabber.get_item(subject="sub-001")

junifer/datagrabber/tests/test_pattern_datalad.py

@@ -43,8 +43,14 @@ def test_bids_PatternDataladDataGrabber() -> None:
     types = ["T1w", "BOLD"]
     # Define patterns
     patterns = {
-        "T1w": "{subject}/anat/{subject}_T1w.nii.gz",
-        "BOLD": "{subject}/func/{subject}_task-rest_bold.nii.gz",
+        "T1w": {
+            "pattern": "{subject}/anat/{subject}_T1w.nii.gz",
+            "space": "MNI152NLin6Asym",
+        },
+        "BOLD": {
+            "pattern": "{subject}/func/{subject}_task-rest_bold.nii.gz",
+            "space": "MNI152NLin6Asym",
+        },
     }
     # Define replacements
     replacements = ["subject"]
@@ -92,31 +98,28 @@ def test_bids_PatternDataladDataGrabber() -> None:
 
 def test_bids_PatternDataladDataGrabber_datadir() -> None:
     """Test PatternDataladDataGrabber with a datadir set to a relative path."""
-    # Define types
-    types = ["T1w", "BOLD"]
     # Define patterns
     patterns = {
-        "T1w": "{subject}/anat/{subject}_T1w.nii.gz",
-        "BOLD": "{subject}/func/{subject}_task-rest_bold.nii.gz",
+        "T1w": {
+            "pattern": "{subject}/anat/{subject}_T*w.nii.gz",
+            "space": "MNI152NLin6Asym",
+        },
+        "BOLD": {
+            "pattern": "{subject}/func/{subject}_task-rest_*.nii.gz",
+            "space": "MNI152NLin6Asym",
+        },
     }
-    # Define replacements
-    replacements = ["subject"]
-
-    repo_uri = _testing_dataset["example_bids"]["uri"]
-
+    # Define datadir
     datadir = "dataset"  # use string and not absolute path
-    patterns = {
-        "T1w": "example_bids/{subject}/anat/{subject}_T*w.nii.gz",
-        "BOLD": "example_bids/{subject}/func/{subject}_task-rest_*.nii.gz",
-    }
     with PatternDataladDataGrabber(
-        uri=repo_uri,
-        types=types,
+        uri=_testing_dataset["example_bids"]["uri"],
+        types=["T1w", "BOLD"],
         patterns=patterns,
         datadir=datadir,
-        replacements=replacements,
+        rootdir="example_bids",
+        replacements=["subject"],
     ) as dg:
-        assert dg.datadir == Path(datadir)
+        assert dg.datadir == Path(datadir) / "example_bids"
         for elem in dg:
             t_sub = dg[elem]
             assert "path" in t_sub["T1w"]
@@ -133,12 +136,23 @@ def test_bids_PatternDataladDataGrabber_session():
     """Test a subject and session-based BIDS PatternDataladDataGrabber."""
     types = ["T1w", "BOLD"]
     patterns = {
-        "T1w": "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz",
-        "BOLD": "{subject}/{session}/func/"
-        "{subject}_{session}_task-rest_bold.nii.gz",
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "MNI152NLin6Asym",
+        },
+        "BOLD": {
+            "pattern": (
+                "{subject}/{session}/func/"
+                "{subject}_{session}_task-rest_bold.nii.gz"
+            ),
+            "space": "MNI152NLin6Asym",
+        },
     }
     replacements = ["subject", "session"]
 
+    # Check error
     with pytest.raises(ValueError, match=r"`uri` must be provided"):
         PatternDataladDataGrabber(
             datadir=None,
@@ -147,9 +161,9 @@ def test_bids_PatternDataladDataGrabber_session():
             replacements=replacements,
         )
 
+    # Set parameters
     repo_uri = _testing_dataset["example_bids_ses"]["uri"]
     rootdir = "example_bids_ses"
-    # repo_commit =  _testing_dataset['example_bids_ses']['id']
 
     # With T1W and bold, only 2 sessions are available
     with PatternDataladDataGrabber(
@@ -159,7 +173,7 @@ def test_bids_PatternDataladDataGrabber_session():
         patterns=patterns,
         replacements=replacements,
     ) as dg:
-        subs = list(dg)
+        subs = list(dg.get_elements())
         expected_subs = [
             (f"sub-{i:02d}", f"ses-{j:02d}")
             for j in range(1, 3)
@@ -170,7 +184,12 @@ def test_bids_PatternDataladDataGrabber_session():
     # Test with a different T1w only, it should have 3 sessions
     types = ["T1w"]
     patterns = {
-        "T1w": "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz",
+        "T1w": {
+            "pattern": (
+                "{subject}/{session}/anat/{subject}_{session}_T1w.nii.gz"
+            ),
+            "space": "MNI152NLin6Asym",
+        },
     }
     with PatternDataladDataGrabber(
         rootdir=rootdir,