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

junifer/markers/tests/test_collection.py

@@ -19,7 +19,6 @@ from junifer.pipeline import PipelineStepMixin
 from junifer.preprocess import fMRIPrepConfoundRemover
 from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import (
-    OasisVBMTestingDataGrabber,
     PartlyCloudyTestingDataGrabber,
 )
 
@@ -46,30 +45,30 @@ def test_marker_collection() -> None:
     """Test MarkerCollection."""
     markers = [
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="mean",
-            name="gmd_schaefer100x7_mean",
+            name="tian_mean",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="std",
-            name="gmd_schaefer100x7_std",
+            name="tian_std",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="trim_mean",
             method_params={"proportiontocut": 0.1},
-            name="gmd_schaefer100x7_trim_mean90",
+            name="tian_trim_mean90",
         ),
     ]
     mc = MarkerCollection(markers=markers)  # type: ignore
     assert mc._markers == markers
-    assert mc._preprocessing is None
+    assert mc._preprocessors is None
     assert mc._storage is None
     assert isinstance(mc._datareader, DefaultDataReader)
 
     # Create testing datagrabber
-    dg = OasisVBMTestingDataGrabber()
+    dg = PartlyCloudyTestingDataGrabber()
     mc.validate(dg)
 
     with dg:
@@ -78,17 +77,17 @@ def test_marker_collection() -> None:
         assert out is not None
         assert isinstance(out, dict)
         assert len(out) == 3
-        assert "gmd_schaefer100x7_mean" in out
-        assert "gmd_schaefer100x7_std" in out
-        assert "gmd_schaefer100x7_trim_mean90" in out
+        assert "tian_mean" in out
+        assert "tian_std" in out
+        assert "tian_trim_mean90" in out
 
         for t_marker in markers:
             t_name = t_marker.name
-            assert "VBM_GM" in out[t_name]
-            t_vbm = out[t_name]["VBM_GM"]
-            assert "data" in t_vbm
-            assert "col_names" in t_vbm
-            assert "meta" in t_vbm
+            assert "BOLD" in out[t_name]
+            t_bold = out[t_name]["BOLD"]
+            assert "data" in t_bold
+            assert "col_names" in t_bold
+            assert "meta" in t_bold
 
     # Test preprocessing
     class BypassPreprocessing(PipelineStepMixin):
@@ -97,7 +96,7 @@ def test_marker_collection() -> None:
 
     mc2 = MarkerCollection(
         markers=markers,  # type: ignore
-        preprocessing=BypassPreprocessing(),
+        preprocessors=[BypassPreprocessing()],  # type: ignore
         datareader=DefaultDataReader(),
     )
     assert isinstance(mc2._datareader, DefaultDataReader)
@@ -108,7 +107,7 @@ def test_marker_collection() -> None:
         for t_marker in markers:
             t_name = t_marker.name
             assert_array_equal(
-                out[t_name]["VBM_GM"]["data"], out2[t_name]["VBM_GM"]["data"]
+                out[t_name]["BOLD"]["data"], out2[t_name]["BOLD"]["data"]
             )
 
 
@@ -128,10 +127,10 @@ def test_marker_collection_with_preprocessing() -> None:
     ]
     mc = MarkerCollection(
         markers=markers,  # type: ignore
-        preprocessing=fMRIPrepConfoundRemover(),
+        preprocessors=[fMRIPrepConfoundRemover()],
     )
     assert mc._markers == markers
-    assert mc._preprocessing is not None
+    assert mc._preprocessors is not None
     assert mc._storage is None
     assert isinstance(mc._datareader, DefaultDataReader)
 
@@ -151,27 +150,28 @@ def test_marker_collection_storage(tmp_path: Path) -> None:
     """
     markers = [
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="mean",
-            name="gmd_schaefer100x7_mean",
+            name="tian_mean",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="std",
-            name="gmd_schaefer100x7_std",
+            name="tian_std",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="trim_mean",
             method_params={"proportiontocut": 0.1},
-            name="gmd_schaefer100x7_trim_mean90",
+            name="tian_trim_mean90",
         ),
     ]
-    # Test storage
-    dg = OasisVBMTestingDataGrabber()
-
-    uri = tmp_path / "test_marker_collection_storage.sqlite"
-    storage = SQLiteFeatureStorage(uri=uri)
+    # Setup datagrabber
+    dg = PartlyCloudyTestingDataGrabber()
+    # Setup storage
+    storage = SQLiteFeatureStorage(
+        tmp_path / "test_marker_collection_storage.sqlite"
+    )
     mc = MarkerCollection(
         markers=markers,  # type: ignore
         storage=storage,
@@ -197,23 +197,24 @@ def test_marker_collection_storage(tmp_path: Path) -> None:
 
     features = storage.list_features()
     assert len(features) == 3
-    feature_md5 = list(features.keys())[0]
+
+    feature_md5 = next(iter(features.keys()))
     t_feature = storage.read_df(feature_md5=feature_md5)
-    fname = "gmd_schaefer100x7_mean"
-    t_data = out[fname]["VBM_GM"]["data"]  # type: ignore
-    cols = out[fname]["VBM_GM"]["col_names"]  # type: ignore
+    fname = "tian_mean"
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore
 
     feature_md5 = list(features.keys())[1]
     t_feature = storage.read_df(feature_md5=feature_md5)
-    fname = "gmd_schaefer100x7_std"
-    t_data = out[fname]["VBM_GM"]["data"]  # type: ignore
-    cols = out[fname]["VBM_GM"]["col_names"]  # type: ignore
+    fname = "tian_std"
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore
 
     feature_md5 = list(features.keys())[2]
     t_feature = storage.read_df(feature_md5=feature_md5)
-    fname = "gmd_schaefer100x7_trim_mean90"
-    t_data = out[fname]["VBM_GM"]["data"]  # type: ignore
-    cols = out[fname]["VBM_GM"]["col_names"]  # type: ignore
+    fname = "tian_trim_mean90"
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore

junifer/markers/tests/test_ets_rss.py

@@ -8,48 +8,47 @@
 
 from pathlib import Path
 
-from nilearn import image
 from nilearn.maskers import NiftiLabelsMasker
 
-from junifer.data import load_parcellation
+from junifer.data import get_parcellation
+from junifer.datareader import DefaultDataReader
 from junifer.markers.ets_rss import RSSETSMarker
 from junifer.storage import SQLiteFeatureStorage
-from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
+from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
 # Set parcellation
-PARCELLATION = "Schaefer100x17"
+PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
 def test_compute() -> None:
     """Test RSS ETS compute()."""
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Fetch element
-        out = dg["sub001"]
-        # Load BOLD image
-        niimg = image.load_img(str(out["BOLD"]["path"].absolute()))
-        # Create input data
-        input_dict = {"data": niimg, "path": out["BOLD"]["path"]}
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         # Compute the RSSETSMarker
-        ets_rss_marker = RSSETSMarker(parcellation=PARCELLATION)
-        new_out = ets_rss_marker.compute(input_dict)
-
-        # Load parcellation
-        test_parcellation, _, _ = load_parcellation(PARCELLATION)
-        # Compute the NiftiLabelsMasker
-        test_masker = NiftiLabelsMasker(test_parcellation)
-        test_ts = test_masker.fit_transform(niimg)
+        marker = RSSETSMarker(parcellation=PARCELLATION)
+        rss_ets = marker.compute(element_data["BOLD"])
+
+        # Compare with nilearn
+        # Load testing parcellation
+        test_parcellation, _ = get_parcellation(
+            parcellation=[PARCELLATION],
+            target_data=element_data["BOLD"],
+        )
+        # Extract timeseries
+        nifti_labels_masker = NiftiLabelsMasker(labels_img=test_parcellation)
+        extacted_timeseries = nifti_labels_masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
         # Assert the dimension of timeseries
-        n_time, _ = test_ts.shape
-        assert n_time == len(new_out["data"])
+        assert extacted_timeseries.shape[0] == len(rss_ets["data"])
 
 
 def test_get_output_type() -> None:
     """Test RSS ETS get_output_type()."""
-    ets_rss_marker = RSSETSMarker(parcellation=PARCELLATION)
-    input_ = "BOLD"
-    output = ets_rss_marker.get_output_type(input_)
-    assert output == "timeseries"
+    assert "timeseries" == RSSETSMarker(
+        parcellation=PARCELLATION
+    ).get_output_type("BOLD")
 
 
 def test_store(tmp_path: Path) -> None:
@@ -61,20 +60,13 @@ def test_store(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Fetch element
-        elem = dg["sub001"]
-        # Load BOLD image
-        niimg = image.load_img(str(elem["BOLD"]["path"].absolute()))
-        elem["BOLD"]["data"] = niimg
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         # Compute the RSSETSMarker
-        ets_rss_marker = RSSETSMarker(parcellation=PARCELLATION)
+        marker = RSSETSMarker(parcellation=PARCELLATION)
         # Create storage
-        storage = SQLiteFeatureStorage(
-            uri=str((tmp_path / "test.sqlite").absolute())
-        )
+        storage = SQLiteFeatureStorage(tmp_path / "test_rss_ets.sqlite")
         # Store
-        ets_rss_marker.fit_transform(input=elem, storage=storage)
-
+        marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(x["name"] == "BOLD_RSSETSMarker" for x in features.values())