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

junifer/preprocess/fsl/tests/test_apply_warper.py

@@ -0,0 +1,45 @@
+"""Provide tests for ApplyWarper."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+import socket
+
+import pytest
+
+from junifer.datagrabber import DataladHCP1200
+from junifer.datareader import DefaultDataReader
+from junifer.pipeline.utils import _check_fsl
+from junifer.preprocess.fsl.apply_warper import _ApplyWarper
+
+
+def test_ApplyWarper_init() -> None:
+    """Test ApplyWarper init."""
+    apply_warper = _ApplyWarper(reference="T1w", on="BOLD")
+    assert apply_warper.ref == "T1w"
+    assert apply_warper.on == "BOLD"
+
+
+@pytest.mark.skipif(_check_fsl() is False, reason="requires FSL to be in PATH")
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+def test_ApplyWarper_preprocess() -> None:
+    """Test ApplyWarper preprocess."""
+    with DataladHCP1200(
+        tasks=["REST1"],
+        phase_encodings=["LR"],
+        ica_fix=True,
+    ) as dg:
+        # Read data
+        element_data = DefaultDataReader().fit_transform(
+            dg[("100206", "REST1", "LR")]
+        )
+        # Preprocess data
+        data_type, data = _ApplyWarper(reference="T1w", on="BOLD").preprocess(
+            input=element_data["BOLD"],
+            extra_input=element_data,
+        )
+        assert isinstance(data_type, str)
+        assert isinstance(data, dict)

junifer/preprocess/tests/test_bold_warper.py

@@ -0,0 +1,159 @@
+"""Provide tests for BOLDWarper."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+import socket
+from typing import TYPE_CHECKING, Tuple
+
+import pytest
+from numpy.testing import assert_array_equal, assert_raises
+
+from junifer.datagrabber import DataladHCP1200, DMCC13Benchmark
+from junifer.datareader import DefaultDataReader
+from junifer.pipeline.utils import _check_ants, _check_fsl
+from junifer.preprocess import BOLDWarper
+
+
+if TYPE_CHECKING:
+    from junifer.datagrabber import BaseDataGrabber
+
+
+def test_BOLDWarper_init() -> None:
+    """Test BOLDWarper init."""
+    bold_warper = BOLDWarper(using="ants", reference="T1w")
+    assert bold_warper._on == ["BOLD"]
+
+
+def test_BOLDWarper_get_valid_inputs() -> None:
+    """Test BOLDWarper get_valid_inputs."""
+    bold_warper = BOLDWarper(using="ants", reference="T1w")
+    assert bold_warper.get_valid_inputs() == ["BOLD"]
+
+
+def test_BOLDWarper_get_output_type() -> None:
+    """Test BOLDWarper get_output_type."""
+    bold_warper = BOLDWarper(using="ants", reference="T1w")
+    assert bold_warper.get_output_type("BOLD") == "BOLD"
+
+
+@pytest.mark.parametrize(
+    "datagrabber, element",
+    [
+        [
+            DMCC13Benchmark(
+                types=["BOLD", "T1w", "Warp"],
+                sessions=["ses-wave1bas"],
+                tasks=["Rest"],
+                phase_encodings=["AP"],
+                runs=["1"],
+                native_t1w=True,
+            ),
+            ("sub-f9057kp", "ses-wave1bas", "Rest", "AP", "1"),
+        ],
+        [
+            DataladHCP1200(
+                tasks=["REST1"],
+                phase_encodings=["LR"],
+                ica_fix=True,
+            ),
+            ("100206", "REST1", "LR"),
+        ],
+    ],
+)
+@pytest.mark.skipif(_check_fsl() is False, reason="requires FSL to be in PATH")
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+def test_BOLDWarper_preprocess_to_native(
+    datagrabber: "BaseDataGrabber", element: Tuple[str, ...]
+) -> None:
+    """Test BOLDWarper preprocess.
+
+    Parameters
+    ----------
+    datagrabber : DataGrabber-like object
+        The parametrized DataGrabber objects.
+    element : tuple of str
+        The parametrized elements.
+
+    """
+    with datagrabber as dg:
+        # Read data
+        element_data = DefaultDataReader().fit_transform(dg[element])
+        # Preprocess data
+        data, _ = BOLDWarper(reference="T1w").preprocess(
+            input=element_data["BOLD"],
+            extra_input=element_data,
+        )
+        assert isinstance(data, dict)
+
+
+@pytest.mark.parametrize(
+    "datagrabber, element, space",
+    [
+        [
+            DMCC13Benchmark(
+                types=["BOLD"],
+                sessions=["ses-wave1bas"],
+                tasks=["Rest"],
+                phase_encodings=["AP"],
+                runs=["1"],
+                native_t1w=False,
+            ),
+            ("sub-f9057kp", "ses-wave1bas", "Rest", "AP", "1"),
+            "MNI152NLin2009aAsym",
+        ],
+        [
+            DMCC13Benchmark(
+                types=["BOLD"],
+                sessions=["ses-wave1bas"],
+                tasks=["Rest"],
+                phase_encodings=["AP"],
+                runs=["1"],
+                native_t1w=False,
+            ),
+            ("sub-f9057kp", "ses-wave1bas", "Rest", "AP", "1"),
+            "MNI152NLin6Asym",
+        ],
+    ],
+)
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+def test_BOLDWarper_preprocess_to_multi_mni(
+    datagrabber: "BaseDataGrabber", element: Tuple[str, ...], space: str
+) -> None:
+    """Test BOLDWarper preprocess.
+
+    Parameters
+    ----------
+    datagrabber : DataGrabber-like object
+        The parametrized DataGrabber objects.
+    element : tuple of str
+        The parametrized elements.
+    space : str
+        The parametrized template space to transform to.
+
+    """
+    with datagrabber as dg:
+        # Read data
+        element_data = DefaultDataReader().fit_transform(dg[element])
+        pre_xfm_data = element_data["BOLD"]["data"].get_fdata().copy()
+        # Preprocess data
+        data, _ = BOLDWarper(reference=space).preprocess(
+            input=element_data["BOLD"],
+            extra_input=element_data,
+        )
+        assert isinstance(data, dict)
+        assert data["space"] == space
+        with assert_raises(AssertionError):
+            assert_array_equal(pre_xfm_data, data["data"])

junifer/preprocess/warping/__init__.py

@@ -4,6 +4,3 @@
 # License: AGPL
 
 from .space_warper import SpaceWarper
-
-
-__all__ = ["SpaceWarper"]

junifer/preprocess/warping/_ants_warper.py

@@ -20,9 +20,6 @@ from ...pipeline import WorkDirManager
 from ...utils import logger, run_ext_cmd
 
 
-__all__ = ["ANTsWarper"]
-
-
 class ANTsWarper:
     """Class for space warping via ANTs antsApplyTransforms.
 

junifer/preprocess/warping/_fsl_warper.py

@@ -19,9 +19,6 @@ from ...pipeline import WorkDirManager
 from ...utils import logger, run_ext_cmd
 
 
-__all__ = ["FSLWarper"]
-
-
 class FSLWarper:
     """Class for space warping via FSL FLIRT.
 

junifer/stats.py

@@ -1,4 +1,4 @@
-"""Statistical functions and helpers."""
+"""Provide functions for statistics."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Synchon Mandal <s.mandal@fz-juelich.de>
@@ -13,9 +13,6 @@ from scipy.stats.mstats import winsorize
 from .utils import logger, raise_error
 
 
-__all__ = ["get_aggfunc_by_name", "count", "winsorized_mean", "select"]
-
-
 def get_aggfunc_by_name(
     name: str, func_params: Optional[Dict[str, Any]] = None
 ) -> Callable:

junifer/storage/__init__.py

@@ -1,4 +1,4 @@
-"""Storages for storing extracted features."""
+"""Provide imports for storage sub-package."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Synchon Mandal <s.mandal@fz-juelich.de>
@@ -8,11 +8,3 @@ from .base import BaseFeatureStorage
 from .pandas_base import PandasBaseFeatureStorage
 from .sqlite import SQLiteFeatureStorage
 from .hdf5 import HDF5FeatureStorage
-
-
-__all__ = [
-    "BaseFeatureStorage",
-    "PandasBaseFeatureStorage",
-    "SQLiteFeatureStorage",
-    "HDF5FeatureStorage",
-]

junifer/storage/base.py

@@ -15,9 +15,6 @@ from ..utils import raise_error
 from .utils import process_meta
 
 
-__all__ = ["BaseFeatureStorage"]
-
-
 class BaseFeatureStorage(ABC):
     """Abstract base class for feature storage.
 
@@ -192,7 +189,7 @@ class BaseFeatureStorage(ABC):
 
         Parameters
         ----------
-        kind : {"matrix", "timeseries", "vector", "scalar_table"}
+        kind : {"matrix", "timeseries", "vector"}
             The storage kind.
         **kwargs
             The keyword arguments.
@@ -221,10 +218,6 @@ class BaseFeatureStorage(ABC):
             )
         elif kind == "vector":
             self.store_vector(meta_md5=meta_md5, element=t_element, **kwargs)
-        elif kind == "scalar_table":
-            self.store_scalar_table(
-                meta_md5=meta_md5, element=t_element, **kwargs
-            )
 
     def store_matrix(
         self,
@@ -320,38 +313,6 @@ class BaseFeatureStorage(ABC):
             klass=NotImplementedError,
         )
 
-    def store_scalar_table(
-        self,
-        meta_md5: str,
-        element: Dict,
-        data: np.ndarray,
-        col_names: Optional[Iterable[str]] = None,
-        row_names: Optional[Iterable[str]] = None,
-        row_header_col_name: Optional[str] = "feature",
-    ) -> None:
-        """Store table with scalar values.
-
-        Parameters
-        ----------
-        meta_md5 : str
-            The metadata MD5 hash.
-        element : dict
-            The element as a dictionary.
-        data : numpy.ndarray
-            The timeseries data to store.
-        col_names : list or tuple of str, optional
-            The column labels (default None).
-        row_names : str, optional
-            The row labels (default None).
-        row_header_col_name : str, optional
-            The column name for the row header column (default "feature").
-
-        """
-        raise_error(
-            msg="Concrete classes need to implement store_scalar_table().",
-            klass=NotImplementedError,
-        )
-
     @abstractmethod
     def collect(self) -> None:
         """Collect data."""

junifer/storage/hdf5.py

@@ -26,9 +26,6 @@ from .base import BaseFeatureStorage
 from .utils import element_to_prefix, matrix_to_vector, store_matrix_checks
 
 
-__all__ = ["HDF5FeatureStorage"]
-
-
 def _create_chunk(
     chunk_data: List[np.ndarray],
     kind: str,
@@ -59,8 +56,7 @@ def _create_chunk(
     Raises
     ------
     ValueError
-        If `kind` is not one of ['vector', 'matrix', 'timeseries',
-        'scalar_table'].
+        If `kind` is not one of ['vector', 'matrix', 'timeseries'].
 
     """
     if kind in ["vector", "matrix"]:
@@ -81,7 +77,7 @@ def _create_chunk(
             chunk_size=tuple(array_chunk_size),
             n_chunk=i_chunk,
         )
-    elif kind in ["timeseries", "scalar_table"]:
+    elif kind == "timeseries":
         out = ChunkedList(
             data=chunk_data,
             size=element_count,
@@ -90,8 +86,7 @@ def _create_chunk(
     else:
         raise_error(
             f"Invalid kind: {kind}. "
-            "Must be one of ['vector', 'matrix', 'timeseries',"
-            "'scalar_table']."
+            "Must be one of ['vector', 'matrix', 'timeseries']."
         )
     return out
 
@@ -151,7 +146,7 @@ class HDF5FeatureStorage(BaseFeatureStorage):
             uri.parent.mkdir(parents=True, exist_ok=True)
 
         # Available storage kinds
-        storage_types = ["vector", "timeseries", "matrix", "scalar_table"]
+        storage_types = ["vector", "timeseries", "matrix"]
 
         super().__init__(
             uri=uri,
@@ -174,7 +169,7 @@ class HDF5FeatureStorage(BaseFeatureStorage):
             storage.
 
         """
-        return ["matrix", "vector", "timeseries", "scalar_table"]
+        return ["matrix", "vector", "timeseries"]
 
     def _fetch_correct_uri_for_io(self, element: Optional[Dict]) -> str:
         """Return proper URI for I/O based on `element`.
@@ -513,26 +508,6 @@ class HDF5FeatureStorage(BaseFeatureStorage):
             columns = hdf_data["column_headers"]
             # Convert data from 3D to 2D
             reshaped_data = np.concatenate(all_data, axis=0)
-        elif hdf_data["kind"] == "scalar_table":
-            # Create dictionary for aggregating index data
-            element_idx = defaultdict(list)
-            all_data = []
-            for idx, element in enumerate(hdf_data["element"]):
-                # Get row count for the element
-                t_data = hdf_data["data"][idx]
-                all_data.append(t_data)
-                n_rows = len(hdf_data["row_headers"])
-                # Set rows for the index
-                for key, val in element.items():
-                    element_idx[key].extend([val] * n_rows)
-                # Add extra column for row header column name
-                element_idx[hdf_data["row_header_column_name"]].extend(
-                    hdf_data["row_headers"]
-                )
-            # Set column headers for dataframe
-            columns = hdf_data["column_headers"]
-            # Convert data from 3D to 2D
-            reshaped_data = np.concatenate(all_data, axis=0)
 
         # Create dataframe for index
         idx_df = pd.DataFrame(data=element_idx)  # type: ignore
@@ -668,7 +643,7 @@ class HDF5FeatureStorage(BaseFeatureStorage):
 
         Parameters
         ----------
-        kind : {"matrix", "vector", "timeseries", "scalar_table"}
+        kind : {"matrix", "vector", "timeseries"}
             The storage kind.
         meta_md5 : str
             The metadata MD5 hash.
@@ -764,8 +739,8 @@ class HDF5FeatureStorage(BaseFeatureStorage):
             )
 
             t_data = stored_data["data"]
-            if kind in ["timeseries", "scalar_table"]:
-                t_data += data
+            if kind == "timeseries":
+                t_data.append(data)
             else:
                 t_data = np.concatenate((t_data, data), axis=-1)
             # Existing entry; append to existing
@@ -946,43 +921,6 @@ class HDF5FeatureStorage(BaseFeatureStorage):
             row_header_column_name="timepoint",
         )
 
-    def store_scalar_table(
-        self,
-        meta_md5: str,
-        element: Dict,
-        data: np.ndarray,
-        col_names: Optional[Iterable[str]] = None,
-        row_names: Optional[Iterable[str]] = None,
-        row_header_col_name: Optional[str] = "feature",
-    ) -> None:
-        """Store table with scalar values.
-
-        Parameters
-        ----------
-        meta_md5 : str
-            The metadata MD5 hash.
-        element : dict
-            The element as a dictionary.
-        data : numpy.ndarray
-            The scalar table data to store.
-        col_names : list or tuple of str, optional
-            The column labels (default None).
-        row_names : str, optional
-            The row labels (default None).
-        row_header_col_name : str, optional
-            The column name for the row header column (default "feature").
-
-        """
-        self._store_data(
-            kind="scalar_table",
-            meta_md5=meta_md5,
-            element=[element],  # convert to list
-            data=[data],  # convert to list
-            column_headers=col_names,
-            row_headers=row_names,
-            row_header_column_name=row_header_col_name,
-        )
-
     def collect(self) -> None:
         """Implement data collection.
 
@@ -1091,7 +1029,7 @@ class HDF5FeatureStorage(BaseFeatureStorage):
                     kind = static_data["kind"]
 
                 # Append the "dynamic" data
-                if kind in ["timeseries", "scalar_table"]:
+                if kind == "timeseries":
                     chunk_data.extend(t_data["data"])
                 else:
                     chunk_data.append(t_data["data"])

junifer/storage/pandas_base.py

@@ -15,9 +15,6 @@ from ..utils import raise_error
 from .base import BaseFeatureStorage
 
 
-__all__ = ["PandasBaseFeatureStorage"]
-
-
 class PandasBaseFeatureStorage(BaseFeatureStorage):
     """Abstract base class for feature storage via pandas.
 

junifer/storage/sqlite.py

@@ -25,9 +25,6 @@ if TYPE_CHECKING:
     from sqlalchemy.engine import Engine
 
 
-__all__ = ["SQLiteFeatureStorage"]
-
-
 @register_storage
 class SQLiteFeatureStorage(PandasBaseFeatureStorage):
     """Concrete implementation for feature storage via SQLite.

junifer/storage/tests/test_hdf5.py

@@ -25,12 +25,7 @@ from junifer.storage.utils import (
 def test_get_valid_inputs() -> None:
     """Test valid inputs."""
     storage = HDF5FeatureStorage(uri="/tmp")
-    assert storage.get_valid_inputs() == [
-        "matrix",
-        "vector",
-        "timeseries",
-        "scalar_table",
-    ]
+    assert storage.get_valid_inputs() == ["matrix", "vector", "timeseries"]
 
 
 def test_single_output(tmp_path: Path) -> None:
@@ -813,7 +808,7 @@ def test_store_timeseries(tmp_path: Path) -> None:
     data = np.array([[10], [20], [30], [40], [50]])
     col_names = ["signal"]
 
-    # Store timeseries
+    # Store vector
     storage.store_timeseries(
         meta_md5=meta_md5,
         element=element_to_store,
@@ -827,53 +822,6 @@ def test_store_timeseries(tmp_path: Path) -> None:
     assert_array_equal(read_df.values, data)
 
 
-def test_store_scalar_table(tmp_path: Path) -> None:
-    """Test scalar table store.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-
-    """
-    uri = tmp_path / "test_store_scalar_table.hdf5"
-    storage = HDF5FeatureStorage(uri=uri)
-    # Metadata to store
-    element = {"subject": "test"}
-    meta = {
-        "element": element,
-        "dependencies": ["numpy"],
-        "marker": {"name": "brainprint"},
-        "type": "FreeSurfer",
-    }
-    # Process the metadata
-    meta_md5, meta_to_store, element_to_store = process_meta(meta)
-    # Store metadata
-    storage.store_metadata(
-        meta_md5=meta_md5, element=element_to_store, meta=meta_to_store
-    )
-
-    # Data to store
-    data = np.array([[10, 20], [30, 40], [50, 60]])
-    col_names = ["roi1", "roi2"]
-    row_names = ["ev1", "ev2", "ev3"]
-
-    # Store timeseries
-    storage.store_scalar_table(
-        meta_md5=meta_md5,
-        element=element_to_store,
-        data=data,
-        col_names=col_names,
-        row_names=row_names,
-        row_header_col_name="eigenvalue",
-    )
-
-    # Read into dataframe
-    read_df = storage.read_df(feature_md5=meta_md5)
-    # Check if data are equal
-    assert_array_equal(read_df.values, data)
-
-
 def _create_data_to_store(n_elements: int, kind: str) -> Tuple[str, Dict]:
     """Create data to store.
 
@@ -906,19 +854,13 @@ def _create_data_to_store(n_elements: int, kind: str) -> Tuple[str, Dict]:
             "col_names": [f"col-{i}" for i in range(10)],
             "matrix_kind": "full",
         }
-    elif kind in "timeseries":
+    elif kind == "timeseries":
         data_to_store = {
             "data": np.arange(20).reshape(2, 10),
             "col_names": [f"col-{i}" for i in range(10)],
         }
-    elif kind in "scalar_table":
-        data_to_store = {
-            "data": np.arange(50).reshape(5, 10),
-            "row_names": [f"row-{i}" for i in range(5)],
-            "col_names": [f"col-{i}" for i in range(10)],
-            "row_header_col_name": "row",
-        }
-
+    else:
+        raise ValueError(f"Unknown kind {kind}.")
     for i in range(n_elements):
         element = {"subject": f"sub-{i // 2}", "session": f"ses-{i % 2}"}
         meta = {
@@ -961,7 +903,6 @@ def _create_data_to_store(n_elements: int, kind: str) -> Tuple[str, Dict]:
         (10, 3, "matrix"),
         (10, 5, "matrix"),
         (10, 5, "timeseries"),
-        (10, 5, "scalar_table"),
     ],
 )
 def test_multi_output_store_and_collect(
@@ -989,20 +930,21 @@ def test_multi_output_store_and_collect(
     meta_md5, all_data = _create_data_to_store(n_elements, kind)
 
     for t_data in all_data:
-        # Store metadata
+        # Store metadata for tables
         storage.store_metadata(
             meta_md5=meta_md5,
             element=t_data["element"],
             meta=t_data["meta"],
         )
-        # Store data
         if kind == "vector":
+            # Store tables
             storage.store_vector(
                 meta_md5=meta_md5,
                 element=t_data["element"],
                 **t_data["data"],
             )
         elif kind == "matrix":
+            # Store tables
             storage.store_matrix(
                 meta_md5=meta_md5,
                 element=t_data["element"],
@@ -1014,17 +956,11 @@ def test_multi_output_store_and_collect(
                 element=t_data["element"],
                 **t_data["data"],
             )
-        elif kind == "scalar_table":
-            storage.store_scalar_table(
-                meta_md5=meta_md5,
-                element=t_data["element"],
-                **t_data["data"],
-            )
     # Check that base URI does not exist yet
     assert not uri.exists()
 
     for t_data in all_data:
-        # Convert element to prefix
+        # Convert element to preifx
         prefix = element_to_prefix(t_data["element"])
         # URIs for data storage
         elem_uri = uri.parent / f"{prefix}{uri.name}"
@@ -1041,7 +977,7 @@ def test_multi_output_store_and_collect(
     # Check that base URI exists now
     assert uri.exists()
 
-    # Read unified metadata
+    # # Read unified metadata
     read_unified_meta = storage.list_features()
     assert meta_md5 in read_unified_meta
 
@@ -1053,10 +989,6 @@ def test_multi_output_store_and_collect(
         data_size = np.sum([x["data"]["data"].shape[0] for x in all_data])
         assert len(all_df) == data_size
         idx_names = [x for x in all_df.index.names if x != "timepoint"]
-    elif kind == "scalar_table":
-        data_size = np.sum([x["data"]["data"].shape[0] for x in all_data])
-        assert len(all_df) == data_size
-        idx_names = [x for x in all_df.index.names if x != "row"]
     else:
         assert len(all_df) == len(all_data)
         idx_names = all_df.index.names
@@ -1081,10 +1013,6 @@ def test_multi_output_store_and_collect(
             assert_array_equal(t_series.values, t_data["data"]["data"])
             series_names = t_series.columns.values.tolist()
             assert series_names == t_data["data"]["col_names"]
-        elif kind == "scalar_table":
-            assert_array_equal(t_series.values, t_data["data"]["data"])
-            series_names = t_series.columns.values.tolist()
-            assert series_names == t_data["data"]["col_names"]
 
 
 def test_collect_error_single_output() -> None: