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

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/onthefly/__init__.py

@@ -1,6 +1,9 @@
-"""Provide imports for onthefly sub-package."""
+"""Utilities for on-the-fly analyses."""
 
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from .read_transform import read_transform
+
+
+__all__ = ["read_transform"]

junifer/onthefly/read_transform.py

@@ -15,6 +15,9 @@ if TYPE_CHECKING:
     from junifer.storage import BaseFeatureStorage
 
 
+__all__ = ["read_transform"]
+
+
 def read_transform(
     storage: Type["BaseFeatureStorage"],
     transform: str,

junifer/pipeline/__init__.py

@@ -1,4 +1,4 @@
-"""Provide imports for pipeline sub-package."""
+"""Pipeline components."""
 
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
@@ -7,3 +7,11 @@ from . import registry
 from .pipeline_step_mixin import PipelineStepMixin
 from .update_meta_mixin import UpdateMetaMixin
 from .workdir_manager import WorkDirManager
+
+
+__all__ = [
+    "registry",
+    "PipelineStepMixin",
+    "UpdateMetaMixin",
+    "WorkDirManager",
+]

junifer/pipeline/pipeline_step_mixin.py

@@ -4,10 +4,14 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-try:
-    from importlib.metadata import packages_distributions
-except ImportError:  # pragma: no cover
+import sys
+
+
+if sys.version_info < (3, 11):  # pragma: no cover
     from importlib_metadata import packages_distributions
+else:
+    from importlib.metadata import packages_distributions
+
 
 from importlib.util import find_spec
 from itertools import chain
@@ -17,6 +21,9 @@ from ..utils import raise_error
 from .utils import check_ext_dependencies
 
 
+__all__ = ["PipelineStepMixin"]
+
+
 class PipelineStepMixin:
     """Mixin class for a pipeline step."""
 
@@ -203,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/registry.py

@@ -16,6 +16,9 @@ if TYPE_CHECKING:
     from .pipeline_step_mixin import PipelineStepMixin
 
 
+__all__ = ["register", "get_step_names", "get_class", "build"]
+
+
 # Define valid steps for operation
 _VALID_STEPS: List[str] = [
     "datagrabber",

junifer/pipeline/singleton.py

@@ -6,6 +6,9 @@
 from typing import Any, Dict, Type
 
 
+__all__ = ["singleton"]
+
+
 def singleton(cls: Type) -> Type:
     """Make a class singleton.
 

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?

junifer/pipeline/update_meta_mixin.py

@@ -7,6 +7,9 @@
 from typing import Dict
 
 
+__all__ = ["UpdateMetaMixin"]
+
+
 class UpdateMetaMixin:
     """Mixin class for updating meta."""
 

junifer/pipeline/utils.py

@@ -10,6 +10,9 @@ from typing import Any, List, Optional
 from junifer.utils.logging import raise_error, warn_with_log
 
 
+__all__ = ["check_ext_dependencies"]
+
+
 def check_ext_dependencies(
     name: str, optional: bool = False, **kwargs: Any
 ) -> bool:
@@ -37,7 +40,7 @@ def check_ext_dependencies(
         If ``name`` is mandatory and is not found.
 
     """
-    valid_ext_dependencies = ("afni", "fsl", "ants")
+    valid_ext_dependencies = ("afni", "fsl", "ants", "freesurfer")
     if name not in valid_ext_dependencies:
         raise_error(
             "Invalid value for `name`, should be one of: "
@@ -52,6 +55,9 @@ def check_ext_dependencies(
     # Check for ants
     elif name == "ants":
         found = _check_ants(**kwargs)
+    # Check for freesurfer
+    elif name == "freesurfer":
+        found = _check_freesurfer(**kwargs)
 
     # Check if the dependency is mandatory in case it's not found
     if not found and not optional:
@@ -245,3 +251,63 @@ def _check_ants(commands: Optional[List[str]] = None) -> bool:
                 f"{commands_found_results}"
             )
     return ants_found
+
+
+def _check_freesurfer(commands: Optional[List[str]] = None) -> bool:
+    """Check if FreeSurfer is present in the system.
+
+    Parameters
+    ----------
+    commands : list of str, optional
+        The commands to specifically check for from FreeSurfer. If None, only
+        the basic FreeSurfer help would be looked up, else, would also
+        check for specific commands (default None).
+
+    Returns
+    -------
+    bool
+        Whether FreeSurfer is found or not.
+
+    """
+    completed_process = subprocess.run(
+        "recon-all -help",
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.STDOUT,
+        shell=True,  # is unsafe but kept for resolution via PATH
+        check=False,
+    )
+    fs_found = completed_process.returncode == 0
+
+    # Check for specific commands
+    if fs_found and commands is not None:
+        if not isinstance(commands, list):
+            commands = [commands]
+        # Store command found results
+        commands_found_results = {}
+        # Set all commands found flag to True
+        all_commands_found = True
+        # Check commands' existence
+        for command in commands:
+            command_process = subprocess.run(
+                [command],
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.STDOUT,
+                shell=True,  # is unsafe but kept for resolution via PATH
+                check=False,
+            )
+            command_found = command_process.returncode == 0
+            commands_found_results[command] = (
+                "found" if command_found else "not found"
+            )
+            # Set flag to trigger warning
+            all_commands_found = all_commands_found and command_found
+        # One or more commands were missing
+        if not all_commands_found:
+            warn_with_log(
+                "FreeSurfer is installed but some of the required commands "
+                "were not found. These are the results: "
+                f"{commands_found_results}"
+            )
+    return fs_found

junifer/pipeline/workdir_manager.py

@@ -13,6 +13,9 @@ from ..utils import logger
 from .singleton import singleton
 
 
+__all__ = ["WorkDirManager"]
+
+
 @singleton
 class WorkDirManager:
     """Class for working directory manager.

junifer/preprocess/__init__.py

@@ -1,4 +1,4 @@
-"""Provide imports for preprocess sub-package."""
+"""Preprocessors for preprocessing data before feature extraction."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Leonard Sasse <l.sasse@fz-juelich.de>
@@ -7,5 +7,13 @@
 
 from .base import BasePreprocessor
 from .confounds import fMRIPrepConfoundRemover
-from .bold_warper import BOLDWarper
 from .warping import SpaceWarper
+from .smoothing import Smoothing
+
+
+__all__ = [
+    "BasePreprocessor",
+    "fMRIPrepConfoundRemover",
+    "SpaceWarper",
+    "Smoothing",
+]

junifer/preprocess/base.py

@@ -11,6 +11,9 @@ from ..pipeline import PipelineStepMixin, UpdateMetaMixin
 from ..utils import logger, raise_error
 
 
+__all__ = ["BasePreprocessor"]
+
+
 class BasePreprocessor(ABC, PipelineStepMixin, UpdateMetaMixin):
     """Abstract base class for all preprocessors.
 
@@ -136,7 +139,7 @@ class BasePreprocessor(ABC, PipelineStepMixin, UpdateMetaMixin):
             A single input from the Junifer Data object to preprocess.
         extra_input : dict, optional
             The other fields in the Junifer Data object. Useful for accessing
-            other data kind that needs to be used in the computation. For
+            other data type that needs to be used in the computation. For
             example, the confound removers can make use of the
             confounds if available (default None).
 
@@ -146,8 +149,8 @@ class BasePreprocessor(ABC, PipelineStepMixin, UpdateMetaMixin):
             The computed result as dictionary.
         dict or None
             Extra "helper" data types as dictionary to add to the Junifer Data
-            object. For example, computed BOLD mask can be passed via this.
-            If no new "helper" data types is created, None is to be passed.
+            object. If no new "helper" data type(s) is(are) created, None is to
+            be passed.
 
         """
         raise_error(

junifer/preprocess/confounds/__init__.py

@@ -5,3 +5,6 @@
 # License: AGPL
 
 from .fmriprep_confound_remover import fMRIPrepConfoundRemover
+
+
+__all__ = ["fMRIPrepConfoundRemover"]

junifer/preprocess/confounds/fmriprep_confound_remover.py

@@ -27,6 +27,9 @@ from ...utils import logger, raise_error
 from ..base import BasePreprocessor
 
 
+__all__ = ["fMRIPrepConfoundRemover"]
+
+
 FMRIPREP_BASICS = {
     "motion": [
         "trans_x",
@@ -203,9 +206,7 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
                 "include it in the future",
                 klass=ValueError,
             )
-        super().__init__(
-            on="BOLD", required_data_types=["BOLD", "BOLD_confounds"]
-        )
+        super().__init__(on="BOLD", required_data_types=["BOLD"])
 
     def get_valid_inputs(self) -> List[str]:
         """Get valid data types for input.
@@ -361,7 +362,7 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
         Parameters
         ----------
         input : dict
-            Dictionary containing the ``BOLD_confounds`` value from the
+            Dictionary containing the ``BOLD.confounds`` value from the
             Junifer Data object.
 
         Returns
@@ -370,7 +371,6 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             Dataframe containing the relevant confounds.
 
         """
-
         confounds_format = input["format"]
         if confounds_format == "adhoc":
             self._map_adhoc_to_fmriprep(input)
@@ -416,50 +416,42 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
     def _validate_data(
         self,
         input: Dict[str, Any],
-        extra_input: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Validate input data.
 
         Parameters
         ----------
         input : dict
-            Dictionary containing the ``BOLD`` value from the
+            Dictionary containing the ``BOLD`` data from the
             Junifer Data object.
-        extra_input : dict, optional
-            Dictionary containing the rest of the Junifer Data object. Must
-            include the ``BOLD_confounds`` key.
 
         Raises
         ------
         ValueError
-            If ``extra_input`` is None or
-            if ``"BOLD_confounds"`` is not found in ``extra_input`` or
-            if ``"data"`` key is not found in ``"BOLD_confounds"`` or
-            if ``"data"`` is not pandas.DataFrame or
+            If ``"confounds"`` is not found in ``input`` or
+            if ``"data"`` key is not found in ``"input.confounds"`` or
+            if ``"input.confounds.data"`` is not pandas.DataFrame or
             if image time series and confounds have different lengths or
-            if ``"format"`` is not found in ``"BOLD_confounds"`` or
-            if ``format = "adhoc"`` and ``"mappings"`` key or ``"fmriprep"``
-            key or correct fMRIPrep mappings or required fMRIPrep mappings are
-            not found or if invalid confounds format is found.
+            if ``format = "adhoc"`` and ``"mappings"`` key is not found or
+            ``"fmriprep"`` key is not found in ``"mappings"`` or
+            ``"fmriprep"`` has incorrect fMRIPrep mappings or required
+            fMRIPrep mappings are not found or
+            if invalid confounds format is found.
 
         """
         # BOLD must be 4D niimg
         check_niimg_4d(input["data"])
-        # Check for extra inputs
-        if extra_input is None:
-            raise_error(
-                "No extra input provided, requires `BOLD_confounds` data type "
-                "in particular"
-            )
-        if "BOLD_confounds" not in extra_input:
-            raise_error("`BOLD_confounds` data type not provided")
-        if "data" not in extra_input["BOLD_confounds"]:
-            raise_error("`BOLD_confounds.data` not provided")
-        # Confounds must be a pandas.DataFrame
-        if not isinstance(extra_input["BOLD_confounds"]["data"], pd.DataFrame):
-            raise_error("`BOLD_confounds.data` must be a `pandas.DataFrame`")
-
-        confound_df = extra_input["BOLD_confounds"]["data"]
+        # Check for confound data
+        if "confounds" not in input:
+            raise_error("`BOLD.confounds` data type not provided")
+        if "data" not in input["confounds"]:
+            raise_error("`BOLD.confounds.data` not provided")
+        # Confounds must be a pandas.DataFrame;
+        # if extension is unknown, will not be read, which will give None
+        if not isinstance(input["confounds"]["data"], pd.DataFrame):
+            raise_error("`BOLD.confounds.data` must be a `pandas.DataFrame`")
+
+        confound_df = input["confounds"]["data"]
         bold_img = input["data"]
         if bold_img.get_fdata().shape[3] != len(confound_df):
             raise_error(
@@ -469,23 +461,19 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             )
 
         # Check format
-        if "format" not in extra_input["BOLD_confounds"]:
-            raise_error("`BOLD_confounds.format` not provided")
-        t_format = extra_input["BOLD_confounds"]["format"]
+        t_format = input["confounds"]["format"]
         if t_format == "adhoc":
-            if "mappings" not in extra_input["BOLD_confounds"]:
+            if "mappings" not in input["confounds"]:
                 raise_error(
-                    "`BOLD_confounds.mappings` need to be set when "
-                    "`BOLD_confounds.format == 'adhoc'`"
+                    "`BOLD.confounds.mappings` need to be set when "
+                    "`BOLD.confounds.format == 'adhoc'`"
                 )
-            if "fmriprep" not in extra_input["BOLD_confounds"]["mappings"]:
+            if "fmriprep" not in input["confounds"]["mappings"]:
                 raise_error(
-                    "`BOLD_confounds.mappings.fmriprep` need to be set when "
-                    "`BOLD_confounds.format == 'adhoc'`"
+                    "`BOLD.confounds.mappings.fmriprep` need to be set when "
+                    "`BOLD.confounds.format == 'adhoc'`"
                 )
-            fmriprep_mappings = extra_input["BOLD_confounds"]["mappings"][
-                "fmriprep"
-            ]
+            fmriprep_mappings = input["confounds"]["mappings"]["fmriprep"]
             wrong_names = [
                 x
                 for x in fmriprep_mappings.values()
@@ -525,22 +513,22 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
         input : dict
             A single input from the Junifer Data object to preprocess.
         extra_input : dict, optional
-            The other fields in the Junifer Data object. Must include the
-            ``BOLD_confounds`` key.
+            The other fields in the Junifer Data object.
 
         Returns
         -------
         dict
-            The computed result as dictionary.
-        dict or None
-            If `self.masks` is not None, then the target data computed mask is
-            returned else None.
+            The computed result as dictionary. If `self.masks` is not None,
+            then the target data computed mask is updated for further steps.
+        None
+            Extra "helper" data types as dictionary to add to the Junifer Data
+            object.
 
         """
         # Validate data
-        self._validate_data(input, extra_input)
+        self._validate_data(input)
         # Pick confounds
-        confounds_df = self._pick_confounds(extra_input["BOLD_confounds"])  # type: ignore
+        confounds_df = self._pick_confounds(input["confounds"])  # type: ignore
         # Get BOLD data
         bold_img = input["data"]
         # Set t_r
@@ -553,7 +541,6 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             )
         # Set mask data
         mask_img = None
-        bold_mask_dict = None
         if self.masks is not None:
             logger.debug(f"Masking with {self.masks}")
             mask_img = get_mask(
@@ -561,15 +548,15 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             )
             # Return the BOLD mask and link it to the BOLD data type dict;
             # this allows to use "inherit" down the pipeline
-            if extra_input is not None:
-                logger.debug("Setting `BOLD.mask_item`")
-                input["mask_item"] = "BOLD_mask"
-                bold_mask_dict = {
-                    "BOLD_mask": {
+            logger.debug("Setting `BOLD.mask`")
+            input.update(
+                {
+                    "mask": {
                         "data": mask_img,
                         "space": input["space"],
                     }
                 }
+            )
         # Clean image
         logger.info("Cleaning image using nilearn")
         logger.debug(f"\tdetrend: {self.detrend}")
@@ -587,4 +574,4 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
             mask_img=mask_img,
         )
 
-        return input, bold_mask_dict
+        return input, None