junifer 0.0.5.dev180__py3-none-any.whl → 0.0.5.dev202__py3-none-any.whl

junifer/markers/temporal_snr/tests/test_temporal_snr_parcels.py

@@ -20,11 +20,13 @@ def test_TemporalSNRParcels_computation() -> None:
             parcellation="TianxS1x3TxMNInonlinear2009cAsym"
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "vector"
+        assert "vector" == marker.get_output_type(
+            input_type="BOLD", output_feature="tsnr"
+        )
 
         # Fit-transform the data
         tsnr_parcels = marker.fit_transform(element_data)
-        tsnr_parcels_bold = tsnr_parcels["BOLD"]
+        tsnr_parcels_bold = tsnr_parcels["BOLD"]["tsnr"]
 
         assert "data" in tsnr_parcels_bold
         assert "col_names" in tsnr_parcels_bold
@@ -51,5 +53,6 @@ def test_TemporalSNRParcels_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
+            x["name"] == "BOLD_TemporalSNRParcels_tsnr"
+            for x in features.values()
         )

junifer/markers/temporal_snr/tests/test_temporal_snr_spheres.py

@@ -20,11 +20,13 @@ def test_TemporalSNRSpheres_computation() -> None:
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
         marker = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
         # Check correct output
-        assert marker.get_output_type("BOLD") == "vector"
+        assert "vector" == marker.get_output_type(
+            input_type="BOLD", output_feature="tsnr"
+        )
 
         # Fit-transform the data
         tsnr_spheres = marker.fit_transform(element_data)
-        tsnr_spheres_bold = tsnr_spheres["BOLD"]
+        tsnr_spheres_bold = tsnr_spheres["BOLD"]["tsnr"]
 
         assert "data" in tsnr_spheres_bold
         assert "col_names" in tsnr_spheres_bold
@@ -49,7 +51,8 @@ def test_TemporalSNRSpheres_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_TemporalSNRSpheres" for x in features.values()
+            x["name"] == "BOLD_TemporalSNRSpheres_tsnr"
+            for x in features.values()
         )
 
 

junifer/markers/tests/test_brainprint.py

@@ -13,16 +13,29 @@ from junifer.markers import BrainPrint
 from junifer.pipeline.utils import _check_freesurfer
 
 
-def test_get_output_type() -> None:
-    """Test BrainPrint get_output_type()."""
-    marker = BrainPrint()
-    assert marker.get_output_type("FreeSurfer") == "vector"
+@pytest.mark.parametrize(
+    "feature, storage_type",
+    [
+        ("eigenvalues", "scalar_table"),
+        ("areas", "vector"),
+        ("volumes", "vector"),
+        ("distances", "vector"),
+    ],
+)
+def test_get_output_type(feature: str, storage_type: str) -> None:
+    """Test BrainPrint get_output_type().
 
+    Parameters
+    ----------
+    feature : str
+        The parametrized feature name.
+    storage_type : str
+        The parametrized storage type.
 
-def test_validate() -> None:
-    """Test BrainPrint validate()."""
-    marker = BrainPrint()
-    assert set(marker.validate(["FreeSurfer"])) == {"scalar_table", "vector"}
+    """
+    assert storage_type == BrainPrint().get_output_type(
+        input_type="FreeSurfer", output_feature=feature
+    )
 
 
 @pytest.mark.skipif(
@@ -39,9 +52,7 @@ def test_compute() -> None:
         element = dg["sub-0001"]
         # Fetch element data
         element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = BrainPrint()
-        # Compute the marker
-        feature_map = marker.fit_transform(element_data)
+        # Compute marker
+        feature_map = BrainPrint().fit_transform(element_data)
         # Assert the output keys
         assert {"eigenvalues", "areas", "volumes"} == set(feature_map.keys())

junifer/markers/tests/test_collection.py

@@ -84,7 +84,7 @@ def test_marker_collection() -> None:
         for t_marker in markers:
             t_name = t_marker.name
             assert "BOLD" in out[t_name]
-            t_bold = out[t_name]["BOLD"]
+            t_bold = out[t_name]["BOLD"]["aggregation"]
             assert "data" in t_bold
             assert "col_names" in t_bold
             assert "meta" in t_bold
@@ -107,7 +107,8 @@ def test_marker_collection() -> None:
         for t_marker in markers:
             t_name = t_marker.name
             assert_array_equal(
-                out[t_name]["BOLD"]["data"], out2[t_name]["BOLD"]["data"]
+                out[t_name]["BOLD"]["aggregation"]["data"],
+                out2[t_name]["BOLD"]["aggregation"]["data"],
             )
 
 
@@ -201,20 +202,20 @@ def test_marker_collection_storage(tmp_path: Path) -> None:
     feature_md5 = next(iter(features.keys()))
     t_feature = storage.read_df(feature_md5=feature_md5)
     fname = "tian_mean"
-    t_data = out[fname]["BOLD"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["aggregation"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["aggregation"]["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 = "tian_std"
-    t_data = out[fname]["BOLD"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["aggregation"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["aggregation"]["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 = "tian_trim_mean90"
-    t_data = out[fname]["BOLD"]["data"]  # type: ignore
-    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
+    t_data = out[fname]["BOLD"]["aggregation"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["aggregation"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore

junifer/markers/tests/test_ets_rss.py

@@ -26,8 +26,9 @@ def test_compute() -> None:
     with PartlyCloudyTestingDataGrabber() as dg:
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         # Compute the RSSETSMarker
-        marker = RSSETSMarker(parcellation=PARCELLATION)
-        rss_ets = marker.compute(element_data["BOLD"])
+        rss_ets = RSSETSMarker(parcellation=PARCELLATION).compute(
+            element_data["BOLD"]
+        )
 
         # Compare with nilearn
         # Load testing parcellation
@@ -41,14 +42,14 @@ def test_compute() -> None:
             element_data["BOLD"]["data"]
         )
         # Assert the dimension of timeseries
-        assert extacted_timeseries.shape[0] == len(rss_ets["data"])
+        assert extacted_timeseries.shape[0] == len(rss_ets["rss_ets"]["data"])
 
 
 def test_get_output_type() -> None:
     """Test RSS ETS get_output_type()."""
     assert "timeseries" == RSSETSMarker(
         parcellation=PARCELLATION
-    ).get_output_type("BOLD")
+    ).get_output_type(input_type="BOLD", output_feature="rss_ets")
 
 
 def test_store(tmp_path: Path) -> None:
@@ -61,12 +62,17 @@ def test_store(tmp_path: Path) -> None:
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
+        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
-        # Compute the RSSETSMarker
-        marker = RSSETSMarker(parcellation=PARCELLATION)
         # Create storage
         storage = SQLiteFeatureStorage(tmp_path / "test_rss_ets.sqlite")
-        # Store
-        marker.fit_transform(input=element_data, storage=storage)
+        # Compute the RSSETSMarker and store
+        _ = RSSETSMarker(parcellation=PARCELLATION).fit_transform(
+            input=element_data, storage=storage
+        )
+        # Retrieve features
         features = storage.list_features()
-        assert any(x["name"] == "BOLD_RSSETSMarker" for x in features.values())
+        # Check marker name
+        assert any(
+            x["name"] == "BOLD_RSSETSMarker_rss_ets" for x in features.values()
+        )

junifer/markers/tests/test_markers_base.py

@@ -20,27 +20,27 @@ def test_base_marker_subclassing() -> None:
 
     # Create concrete class
     class MyBaseMarker(BaseMarker):
+
+        _MARKER_INOUT_MAPPINGS = {  # noqa: RUF012
+            "BOLD": {
+                "feat_1": "timeseries",
+            },
+        }
+
         def __init__(self, on, name=None) -> None:
             self.parameter = 1
             super().__init__(on, name)
 
-        def get_valid_inputs(self):
-            return ["BOLD", "T1w"]
-
-        def get_output_type(self, input):
-            if input == "BOLD":
-                return "timeseries"
-            raise ValueError(f"Cannot compute output type for {input}")
-
         def compute(self, input, extra_input):
             return {
-                "data": "data",
-                "columns": "columns",
-                "row_names": "row_names",
+                "feat_1": {
+                    "data": "data",
+                    "col_names": ["columns"],
+                },
             }
 
-    with pytest.raises(ValueError, match=r"cannot be computed on \['T2w'\]"):
-        MyBaseMarker(on=["BOLD", "T2w"])
+    with pytest.raises(ValueError, match=r"cannot be computed on \['T1w'\]"):
+        MyBaseMarker(on=["BOLD", "T1w"])
 
     # Create input for marker
     input_ = {
@@ -64,12 +64,11 @@ def test_base_marker_subclassing() -> None:
     output = marker.fit_transform(input=input_)  # process
     # Check output
     assert "BOLD" in output
-    assert "data" in output["BOLD"]
-    assert "columns" in output["BOLD"]
-    assert "row_names" in output["BOLD"]
+    assert "data" in output["BOLD"]["feat_1"]
+    assert "col_names" in output["BOLD"]["feat_1"]
 
-    assert "meta" in output["BOLD"]
-    meta = output["BOLD"]["meta"]
+    assert "meta" in output["BOLD"]["feat_1"]
+    meta = output["BOLD"]["feat_1"]["meta"]
     assert "datagrabber" in meta
     assert "element" in meta
     assert "datareader" in meta

junifer/markers/tests/test_parcel_aggregation.py

@@ -23,16 +23,63 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-def test_ParcelAggregation_input_output() -> None:
-    """Test ParcelAggregation input and output types."""
-    marker = ParcelAggregation(
-        parcellation="Schaefer100x7", method="mean", on="VBM_GM"
-    )
-    for in_, out_ in [("VBM_GM", "vector"), ("BOLD", "timeseries")]:
-        assert marker.get_output_type(in_) == out_
+@pytest.mark.parametrize(
+    "input_type, storage_type",
+    [
+        (
+            "T1w",
+            "vector",
+        ),
+        (
+            "T2w",
+            "vector",
+        ),
+        (
+            "BOLD",
+            "timeseries",
+        ),
+        (
+            "VBM_GM",
+            "vector",
+        ),
+        (
+            "VBM_WM",
+            "vector",
+        ),
+        (
+            "VBM_CSF",
+            "vector",
+        ),
+        (
+            "fALFF",
+            "vector",
+        ),
+        (
+            "GCOR",
+            "vector",
+        ),
+        (
+            "LCOR",
+            "vector",
+        ),
+    ],
+)
+def test_ParcelAggregation_input_output(
+    input_type: str, storage_type: str
+) -> None:
+    """Test ParcelAggregation input and output types.
 
-    with pytest.raises(ValueError, match="Unknown input"):
-        marker.get_output_type("unknown")
+    Parameters
+    ----------
+    input_type : str
+        The parametrized input type.
+    storage_type : str
+        The parametrized storage type.
+
+    """
+    assert storage_type == ParcelAggregation(
+        parcellation="Schaefer100x7", method="mean", on=input_type
+    ).get_output_type(input_type=input_type, output_feature="aggregation")
 
 
 def test_ParcelAggregation_3D() -> None:
@@ -85,8 +132,8 @@ def test_ParcelAggregation_3D() -> None:
         )
 
         parcel_agg_mean_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
         # Check that arrays are almost equal
         assert_array_equal(parcel_agg_mean_bold_data, manual)
         assert_array_almost_equal(nifti_labels_masked_bold, manual)
@@ -113,8 +160,8 @@ def test_ParcelAggregation_3D() -> None:
             on="BOLD",
         )
         parcel_agg_std_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
         assert parcel_agg_std_bold_data.ndim == 2
         assert parcel_agg_std_bold_data.shape[0] == 1
         assert_array_equal(parcel_agg_std_bold_data, manual)
@@ -139,7 +186,7 @@ def test_ParcelAggregation_3D() -> None:
         )
         parcel_agg_trim_mean_bold_data = marker.fit_transform(element_data)[
             "BOLD"
-        ]["data"]
+        ]["aggregation"]["data"]
         assert parcel_agg_trim_mean_bold_data.ndim == 2
         assert parcel_agg_trim_mean_bold_data.shape[0] == 1
         assert_array_equal(parcel_agg_trim_mean_bold_data, manual)
@@ -154,8 +201,8 @@ def test_ParcelAggregation_4D():
             parcellation="TianxS1x3TxMNInonlinear2009cAsym", method="mean"
         )
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing parcellation
@@ -204,7 +251,8 @@ def test_ParcelAggregation_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_ParcelAggregation" for x in features.values()
+            x["name"] == "BOLD_ParcelAggregation_aggregation"
+            for x in features.values()
         )
 
     # Store 4D
@@ -221,7 +269,8 @@ def test_ParcelAggregation_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_ParcelAggregation" for x in features.values()
+            x["name"] == "BOLD_ParcelAggregation_aggregation"
+            for x in features.values()
         )
 
 
@@ -241,8 +290,8 @@ def test_ParcelAggregation_3D_mask() -> None:
             ..., 0:1
         ]
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing parcellation
@@ -316,8 +365,8 @@ def test_ParcelAggregation_3D_mask_computed() -> None:
             on="BOLD",
         )
         parcel_agg_mean_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         assert parcel_agg_mean_bold_data.ndim == 2
         assert parcel_agg_mean_bold_data.shape[0] == 1
@@ -397,7 +446,9 @@ def test_ParcelAggregation_3D_multiple_non_overlapping(tmp_path: Path) -> None:
             name="tian_mean",
             on="BOLD",
         )
-        orig_mean = marker_original.fit_transform(element_data)["BOLD"]
+        orig_mean = marker_original.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]
 
         orig_mean_data = orig_mean["data"]
         assert orig_mean_data.ndim == 2
@@ -417,7 +468,9 @@ def test_ParcelAggregation_3D_multiple_non_overlapping(tmp_path: Path) -> None:
         # No warnings should be raised
         with warnings.catch_warnings():
             warnings.simplefilter("error", category=UserWarning)
-            split_mean = marker_split.fit_transform(element_data)["BOLD"]
+            split_mean = marker_split.fit_transform(element_data)["BOLD"][
+                "aggregation"
+            ]
 
         split_mean_data = split_mean["data"]
 
@@ -497,7 +550,9 @@ def test_ParcelAggregation_3D_multiple_overlapping(tmp_path: Path) -> None:
             name="tian_mean",
             on="BOLD",
         )
-        orig_mean = marker_original.fit_transform(element_data)["BOLD"]
+        orig_mean = marker_original.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]
 
         orig_mean_data = orig_mean["data"]
         assert orig_mean_data.ndim == 2
@@ -515,7 +570,9 @@ def test_ParcelAggregation_3D_multiple_overlapping(tmp_path: Path) -> None:
         )
         # Warning should be raised
         with pytest.warns(RuntimeWarning, match="overlapping voxels"):
-            split_mean = marker_split.fit_transform(element_data)["BOLD"]
+            split_mean = marker_split.fit_transform(element_data)["BOLD"][
+                "aggregation"
+            ]
 
         split_mean_data = split_mean["data"]
 
@@ -602,7 +659,9 @@ def test_ParcelAggregation_3D_multiple_duplicated_labels(
             name="tian_mean",
             on="BOLD",
         )
-        orig_mean = marker_original.fit_transform(element_data)["BOLD"]
+        orig_mean = marker_original.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]
 
         orig_mean_data = orig_mean["data"]
         assert orig_mean_data.ndim == 2
@@ -621,7 +680,9 @@ def test_ParcelAggregation_3D_multiple_duplicated_labels(
 
         # Warning should be raised
         with pytest.warns(RuntimeWarning, match="duplicated labels."):
-            split_mean = marker_split.fit_transform(element_data)["BOLD"]
+            split_mean = marker_split.fit_transform(element_data)["BOLD"][
+                "aggregation"
+            ]
 
         split_mean_data = split_mean["data"]
 
@@ -653,8 +714,8 @@ def test_ParcelAggregation_4D_agg_time():
             on="BOLD",
         )
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Loading testing parcellation
@@ -689,8 +750,8 @@ def test_ParcelAggregation_4D_agg_time():
             on="BOLD",
         )
         parcel_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         assert parcel_agg_bold_data.ndim == 2
         assert_array_equal(

junifer/markers/tests/test_sphere_aggregation.py

@@ -25,14 +25,65 @@ COORDS = "DMNBuckner"
 RADIUS = 8
 
 
-def test_SphereAggregation_input_output() -> None:
-    """Test SphereAggregation input and output types."""
-    marker = SphereAggregation(coords="DMNBuckner", method="mean", on="VBM_GM")
-    for in_, out_ in [("VBM_GM", "vector"), ("BOLD", "timeseries")]:
-        assert marker.get_output_type(in_) == out_
+@pytest.mark.parametrize(
+    "input_type, storage_type",
+    [
+        (
+            "T1w",
+            "vector",
+        ),
+        (
+            "T2w",
+            "vector",
+        ),
+        (
+            "BOLD",
+            "timeseries",
+        ),
+        (
+            "VBM_GM",
+            "vector",
+        ),
+        (
+            "VBM_WM",
+            "vector",
+        ),
+        (
+            "VBM_CSF",
+            "vector",
+        ),
+        (
+            "fALFF",
+            "vector",
+        ),
+        (
+            "GCOR",
+            "vector",
+        ),
+        (
+            "LCOR",
+            "vector",
+        ),
+    ],
+)
+def test_SphereAggregation_input_output(
+    input_type: str, storage_type: str
+) -> None:
+    """Test SphereAggregation input and output types.
 
-    with pytest.raises(ValueError, match="Unknown input"):
-        marker.get_output_type("unknown")
+    Parameters
+    ----------
+    input_type : str
+        The parametrized input type.
+    storage_type : str
+        The parametrized storage type.
+
+    """
+    assert storage_type == SphereAggregation(
+        coords="DMNBuckner",
+        method="mean",
+        on=input_type,
+    ).get_output_type(input_type=input_type, output_feature="aggregation")
 
 
 def test_SphereAggregation_3D() -> None:
@@ -44,8 +95,8 @@ def test_SphereAggregation_3D() -> None:
             coords=COORDS, method="mean", radius=RADIUS, on="VBM_GM"
         )
         sphere_agg_vbm_gm_data = marker.fit_transform(element_data)["VBM_GM"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing coordinates
@@ -76,8 +127,8 @@ def test_SphereAggregation_4D() -> None:
             coords=COORDS, method="mean", radius=RADIUS, on="BOLD"
         )
         sphere_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing coordinates
@@ -120,7 +171,8 @@ def test_SphereAggregation_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "VBM_GM_SphereAggregation" for x in features.values()
+            x["name"] == "VBM_GM_SphereAggregation_aggregation"
+            for x in features.values()
         )
 
     # Store 4D
@@ -135,7 +187,8 @@ def test_SphereAggregation_storage(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_SphereAggregation" for x in features.values()
+            x["name"] == "BOLD_SphereAggregation_aggregation"
+            for x in features.values()
         )
 
 
@@ -152,8 +205,8 @@ def test_SphereAggregation_3D_mask() -> None:
             masks="compute_brain_mask",
         )
         sphere_agg_vbm_gm_data = marker.fit_transform(element_data)["VBM_GM"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing coordinates
@@ -195,8 +248,8 @@ def test_SphereAggregation_4D_agg_time() -> None:
             on="BOLD",
         )
         sphere_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         # Compare with nilearn
         # Load testing coordinates
@@ -231,8 +284,8 @@ def test_SphereAggregation_4D_agg_time() -> None:
             on="BOLD",
         )
         sphere_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
-            "data"
-        ]
+            "aggregation"
+        ]["data"]
 
         assert sphere_agg_bold_data.ndim == 2
         assert_array_equal(

junifer/pipeline/pipeline_step_mixin.py

@@ -210,7 +210,17 @@ class PipelineStepMixin:
         # Validate input
         fit_input = self.validate_input(input=input)
         # Validate output type
-        outputs = [self.get_output_type(t_input) for t_input in fit_input]
+        # Nested output type for marker
+        if hasattr(self, "_MARKER_INOUT_MAPPINGS"):
+            outputs = list(
+                {
+                    val
+                    for t_input in fit_input
+                    for val in self._MARKER_INOUT_MAPPINGS[t_input].values()
+                }
+            )
+        else:
+            outputs = [self.get_output_type(t_input) for t_input in fit_input]
         return outputs
 
     def fit_transform(

junifer/pipeline/tests/test_registry.py

@@ -101,7 +101,7 @@ def test_get_class():
     register(step="datagrabber", name="bar", klass=str)
     # Get class
     obj = get_class(step="datagrabber", name="bar")
-    assert obj == str
+    assert isinstance(obj, type(str))
 
 
 # TODO: possible parametrization?