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

junifer/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.5.dev183'
-__version_tuple__ = version_tuple = (0, 0, 5, 'dev183')
+__version__ = version = '0.0.5.dev202'
+__version_tuple__ = version_tuple = (0, 0, 5, 'dev202')

junifer/datagrabber/tests/test_datalad_base.py

@@ -15,13 +15,13 @@ from junifer.datagrabber import DataladDataGrabber
 _testing_dataset = {
     "example_bids": {
         "uri": "https://gin.g-node.org/juaml/datalad-example-bids",
-        "commit": "522dfb203afcd2cd55799bf347f9b211919a7338",
-        "id": "fec92475-d9c0-4409-92ba-f041b6a12c40",
+        "commit": "b87897cbe51bf0ee5514becaa5c7dd76491db5ad",
+        "id": "8fddff30-6993-420a-9d1e-b5b028c59468",
     },
     "example_bids_ses": {
         "uri": "https://gin.g-node.org/juaml/datalad-example-bids-ses",
-        "commit": "3d08d55d1faad4f12ab64ac9497544a0d924d47a",
-        "id": "c83500d0-532f-45be-baf1-0dab703bdc2a",
+        "commit": "6b163aa98af76a9eac0272273c27e14127850181",
+        "id": "715c17cf-a1b9-42d6-9af8-9f74c1a4a724",
     },
 }
 

junifer/datagrabber/tests/test_pattern_datalad.py

@@ -15,13 +15,13 @@ from junifer.datagrabber import PatternDataladDataGrabber
 _testing_dataset = {
     "example_bids": {
         "uri": "https://gin.g-node.org/juaml/datalad-example-bids",
-        "commit": "522dfb203afcd2cd55799bf347f9b211919a7338",
-        "id": "fec92475-d9c0-4409-92ba-f041b6a12c40",
+        "commit": "b87897cbe51bf0ee5514becaa5c7dd76491db5ad",
+        "id": "8fddff30-6993-420a-9d1e-b5b028c59468",
     },
     "example_bids_ses": {
         "uri": "https://gin.g-node.org/juaml/datalad-example-bids-ses",
-        "commit": "3d08d55d1faad4f12ab64ac9497544a0d924d47a",
-        "id": "c83500d0-532f-45be-baf1-0dab703bdc2a",
+        "commit": "6b163aa98af76a9eac0272273c27e14127850181",
+        "id": "715c17cf-a1b9-42d6-9af8-9f74c1a4a724",
     },
 }
 

junifer/markers/base.py

@@ -5,6 +5,7 @@
 # License: AGPL
 
 from abc import ABC, abstractmethod
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from ..pipeline import PipelineStepMixin, UpdateMetaMixin
@@ -35,6 +36,8 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
 
     Raises
     ------
+    AttributeError
+        If the marker does not have `_MARKER_INOUT_MAPPINGS` attribute.
     ValueError
         If required input data type(s) is(are) not found.
 
@@ -45,6 +48,12 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         on: Optional[Union[List[str], str]] = None,
         name: Optional[str] = None,
     ) -> None:
+        # Check for missing mapping attribute
+        if not hasattr(self, "_MARKER_INOUT_MAPPINGS"):
+            raise_error(
+                msg=("Missing `_MARKER_INOUT_MAPPINGS` for the marker"),
+                klass=AttributeError,
+            )
         # Use all data types if not provided
         if on is None:
             on = self.get_valid_inputs()
@@ -88,7 +97,6 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
             )
         return [x for x in self._on if x in input]
 
-    @abstractmethod
     def get_valid_inputs(self) -> List[str]:
         """Get valid data types for input.
 
@@ -98,30 +106,25 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
             The list of data types that can be used as input for this marker.
 
         """
-        raise_error(
-            msg="Concrete classes need to implement get_valid_inputs().",
-            klass=NotImplementedError,
-        )
+        return list(self._MARKER_INOUT_MAPPINGS.keys())
 
-    @abstractmethod
-    def get_output_type(self, input_type: str) -> str:
+    def get_output_type(self, input_type: str, output_feature: str) -> str:
         """Get output type.
 
         Parameters
         ----------
         input_type : str
             The data type input to the marker.
+        output_feature : str
+            The feature output of the marker.
 
         Returns
         -------
         str
-            The storage type output by the marker.
+            The storage type output of the marker.
 
         """
-        raise_error(
-            msg="Concrete classes need to implement get_output_type().",
-            klass=NotImplementedError,
-        )
+        return self._MARKER_INOUT_MAPPINGS[input_type][output_feature]
 
     @abstractmethod
     def compute(self, input: Dict, extra_input: Optional[Dict] = None) -> Dict:
@@ -154,6 +157,7 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
     def store(
         self,
         type_: str,
+        feature: str,
         out: Dict[str, Any],
         storage: "BaseFeatureStorage",
     ) -> None:
@@ -163,13 +167,15 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         ----------
         type_ : str
             The data type to store.
+        feature : str
+            The feature to store.
         out : dict
             The computed result as a dictionary to store.
         storage : storage-like
             The storage class, for example, SQLiteFeatureStorage.
 
         """
-        output_type_ = self.get_output_type(type_)
+        output_type_ = self.get_output_type(type_, feature)
         logger.debug(f"Storing {output_type_} in {storage}")
         storage.store(kind=output_type_, **out)
 
@@ -213,15 +219,35 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
                 t_meta["type"] = type_
                 # Compute marker
                 t_out = self.compute(input=t_input, extra_input=extra_input)
-                t_out["meta"] = t_meta
-                # Update metadata for step
-                self.update_meta(t_out, "marker")
-                # Check storage
-                if storage is not None:
-                    logger.info(f"Storing in {storage}")
-                    self.store(type_=type_, out=t_out, storage=storage)
-                else:
-                    logger.info("No storage specified, returning dictionary")
-                    out[type_] = t_out
+                # Initialize empty dictionary if no storage object is provided
+                if storage is None:
+                    out[type_] = {}
+                # Store individual features
+                for feature_name, feature_data in t_out.items():
+                    # Make deep copy of the feature data for manipulation
+                    feature_data_copy = deepcopy(feature_data)
+                    # Make deep copy of metadata and add to feature data
+                    feature_data_copy["meta"] = deepcopy(t_meta)
+                    # Update metadata for the feature,
+                    # feature data is not manipulated, only meta
+                    self.update_meta(feature_data_copy, "marker")
+                    # Update marker feature's metadata name
+                    feature_data_copy["meta"]["marker"][
+                        "name"
+                    ] += f"_{feature_name}"
+
+                    if storage is not None:
+                        logger.info(f"Storing in {storage}")
+                        self.store(
+                            type_=type_,
+                            feature=feature_name,
+                            out=feature_data_copy,
+                            storage=storage,
+                        )
+                    else:
+                        logger.info(
+                            "No storage specified, returning dictionary"
+                        )
+                        out[type_][feature_name] = feature_data_copy
 
         return out

junifer/markers/brainprint.py

@@ -3,21 +3,9 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-import sys
-
-
-if sys.version_info < (3, 11):  # pragma: no cover
-    from importlib_metadata import packages_distributions
-else:
-    from importlib.metadata import packages_distributions
-
 import uuid
-from copy import deepcopy
-from importlib.util import find_spec
-from itertools import chain
 from pathlib import Path
 from typing import (
-    TYPE_CHECKING,
     Any,
     ClassVar,
     Dict,
@@ -37,15 +25,10 @@ from ..external.BrainPrint.brainprint.brainprint import (
 )
 from ..external.BrainPrint.brainprint.surfaces import surf_to_vtk
 from ..pipeline import WorkDirManager
-from ..pipeline.utils import check_ext_dependencies
-from ..utils import logger, raise_error, run_ext_cmd
+from ..utils import logger, run_ext_cmd
 from .base import BaseMarker
 
 
-if TYPE_CHECKING:
-    from junifer.storage import BaseFeatureStorage
-
-
 __all__ = ["BrainPrint"]
 
 
@@ -99,6 +82,15 @@ class BrainPrint(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"lapy", "numpy"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "FreeSurfer": {
+            "eigenvalues": "scalar_table",
+            "areas": "vector",
+            "volumes": "vector",
+            "distances": "vector",
+        }
+    }
+
     def __init__(
         self,
         num: int = 50,
@@ -121,117 +113,6 @@ class BrainPrint(BaseMarker):
         self.use_cholmod = use_cholmod
         super().__init__(name=name, on="FreeSurfer")
 
-    def get_valid_inputs(self) -> List[str]:
-        """Get valid data types for input.
-
-        Returns
-        -------
-        list of str
-            The list of data types that can be used as input for this marker.
-
-        """
-        return ["FreeSurfer"]
-
-    # TODO: kept for making this class concrete; should be removed later
-    def get_output_type(self, input_type: str) -> str:
-        """Get output type.
-
-        Parameters
-        ----------
-        input_type : str
-            The data type input to the marker.
-
-        Returns
-        -------
-        str
-            The storage type output by the marker.
-
-        """
-        return "vector"
-
-    # TODO: overridden to allow multiple outputs from single data type; should
-    # be removed later
-    def validate(self, input: List[str]) -> List[str]:
-        """Validate the the pipeline step.
-
-        Parameters
-        ----------
-        input : list of str
-            The input to the pipeline step.
-
-        Returns
-        -------
-        list of str
-            The output of the pipeline step.
-
-        """
-
-        def _check_dependencies(obj) -> None:
-            """Check obj._DEPENDENCIES.
-
-            Parameters
-            ----------
-            obj : object
-                Object to check _DEPENDENCIES of.
-
-            Raises
-            ------
-            ImportError
-                If the pipeline step object is missing dependencies required
-                for its working.
-
-            """
-            # Check if _DEPENDENCIES attribute is found;
-            # (markers and preprocessors will have them but not datareaders
-            # as of now)
-            dependencies_not_found = []
-            if hasattr(obj, "_DEPENDENCIES"):
-                # Check if dependencies are importable
-                for dependency in obj._DEPENDENCIES:
-                    # First perform an easy check
-                    if find_spec(dependency) is None:
-                        # Then check mapped names
-                        if dependency not in list(
-                            chain.from_iterable(
-                                packages_distributions().values()
-                            )
-                        ):
-                            dependencies_not_found.append(dependency)
-            # Raise error if any dependency is not found
-            if dependencies_not_found:
-                raise_error(
-                    msg=(
-                        f"{dependencies_not_found} are not installed but are "
-                        f"required for using {obj.__class__.__name__}."
-                    ),
-                    klass=ImportError,
-                )
-
-        def _check_ext_dependencies(obj) -> None:
-            """Check obj._EXT_DEPENDENCIES.
-
-            Parameters
-            ----------
-            obj : object
-                Object to check _EXT_DEPENDENCIES of.
-
-            """
-            # Check if _EXT_DEPENDENCIES attribute is found;
-            # (some markers and preprocessors might have them)
-            if hasattr(obj, "_EXT_DEPENDENCIES"):
-                for dependency in obj._EXT_DEPENDENCIES:
-                    check_ext_dependencies(**dependency)
-
-        # Check dependencies
-        _check_dependencies(self)
-        # Check external dependencies
-        # _check_ext_dependencies(self)
-        # Validate input
-        _ = self.validate_input(input=input)
-        # Validate output type
-        outputs = ["scalar_table", "vector"]
-        return outputs
-
     def _create_aseg_surface(
         self,
         aseg_path: Path,
@@ -426,6 +307,27 @@ class BrainPrint(BaseMarker):
             ),
         }
 
+    def _fix_nan(
+        self,
+        input_data: List[Union[float, str, npt.ArrayLike]],
+    ) -> np.ndarray:
+        """Convert BrainPrint output with string NaN to ``numpy.nan``.
+
+        Parameters
+        ----------
+        input_data : list of str, float or numpy.ndarray-like
+            The data to convert.
+
+        Returns
+        -------
+        np.ndarray
+            The converted data as ``numpy.ndarray``.
+
+        """
+        arr = np.asarray(input_data)
+        arr[arr == "NaN"] = np.nan
+        return arr.astype(np.float64)
+
     def compute(
         self,
         input: Dict[str, Any],
@@ -443,16 +345,32 @@ class BrainPrint(BaseMarker):
         Returns
         -------
         dict
-            The computed result as dictionary. The dictionary has the following
-            keys:
+            The computed result as dictionary. This will be either returned
+            to the user or stored in the storage by calling the store method
+            with this as a parameter. The dictionary has the following keys:
+
+            * ``eigenvalues`` : dictionary with the following keys:
+
+                - ``data`` : eigenvalues as ``np.ndarray``
+                - ``col_names`` : surface labels as list of str
+                - ``row_names`` : eigenvalue count labels as list of str
+                - ``row_header_col_name`` : "eigenvalue"
+                                ()
+            * ``areas`` : dictionary with the following keys:
+
+                - ``data`` : areas as ``np.ndarray``
+                - ``col_names`` : surface labels as list of str
+
+            * ``volumes`` : dictionary with the following keys:
 
-            * ``eigenvalues`` : dict of surface labels (str) and eigenvalues
-                                (``np.ndarray``)
-            * ``eigenvectors`` : dict of surface labels (str) and eigenvectors
-                                 (``np.ndarray``) if ``keep_eigenvectors=True``
-                                 else None
-            * ``distances`` : dict of ``{left_label}_{right_label}`` (str) and
-                              distance (float) if ``asymmetry=True`` else None
+                - ``data`` : volumes as ``np.ndarray``
+                - ``col_names`` : surface labels as list of str
+
+            * ``distances`` : dictionary with the following keys
+                              if ``asymmetry = True``:
+
+                - ``data`` : distances as ``np.ndarray``
+                - ``col_names`` : surface labels as list of str
 
         References
         ----------
@@ -539,130 +457,3 @@ class BrainPrint(BaseMarker):
                 "col_names": list(distances.keys()),
             }
         return output
-
-    def _fix_nan(
-        self,
-        input_data: List[Union[float, str, npt.ArrayLike]],
-    ) -> np.ndarray:
-        """Convert BrainPrint output with string NaN to ``numpy.nan``.
-
-        Parameters
-        ----------
-        input_data : list of str, float or numpy.ndarray-like
-            The data to convert.
-
-        Returns
-        -------
-        np.ndarray
-            The converted data as ``numpy.ndarray``.
-
-        """
-        arr = np.asarray(input_data)
-        arr[arr == "NaN"] = np.nan
-        return arr.astype(np.float64)
-
-    # TODO: overridden to allow storing multiple outputs from single input;
-    # should be removed later
-    def store(
-        self,
-        type_: str,
-        feature: str,
-        out: Dict[str, Any],
-        storage: "BaseFeatureStorage",
-    ) -> None:
-        """Store.
-
-        Parameters
-        ----------
-        type_ : str
-            The data type to store.
-        feature : {"eigenvalues", "distances", "areas", "volumes"}
-            The feature name to store.
-        out : dict
-            The computed result as a dictionary to store.
-        storage : storage-like
-            The storage class, for example, SQLiteFeatureStorage.
-
-        Raises
-        ------
-        ValueError
-            If ``feature`` is invalid.
-
-        """
-        if feature == "eigenvalues":
-            output_type = "scalar_table"
-        elif feature in ["distances", "areas", "volumes"]:
-            output_type = "vector"
-        else:
-            raise_error(f"Unknown feature: {feature}")
-
-        logger.debug(f"Storing {output_type} in {storage}")
-        storage.store(kind=output_type, **out)
-
-    # TODO: overridden to allow storing multiple outputs from single input;
-    # should be removed later
-    def _fit_transform(
-        self,
-        input: Dict[str, Dict],
-        storage: Optional["BaseFeatureStorage"] = None,
-    ) -> Dict:
-        """Fit and transform.
-
-        Parameters
-        ----------
-        input : dict
-            The Junifer Data object.
-        storage : storage-like, optional
-            The storage class, for example, SQLiteFeatureStorage.
-
-        Returns
-        -------
-        dict
-            The processed output as a dictionary. If `storage` is provided,
-            empty dictionary is returned.
-
-        """
-        out = {}
-        for type_ in self._on:
-            if type_ in input.keys():
-                logger.info(f"Computing {type_}")
-                t_input = input[type_]
-                extra_input = input.copy()
-                extra_input.pop(type_)
-                t_meta = t_input["meta"].copy()
-                t_meta["type"] = type_
-
-                # Returns multiple features
-                t_out = self.compute(input=t_input, extra_input=extra_input)
-
-                if storage is None:
-                    out[type_] = {}
-
-                for feature_name, feature_data in t_out.items():
-                    # Make deep copy of the feature data for manipulation
-                    feature_data_copy = deepcopy(feature_data)
-                    # Make deep copy of metadata and add to feature data
-                    feature_data_copy["meta"] = deepcopy(t_meta)
-                    # Update metadata for the feature,
-                    # feature data is not manipulated, only meta
-                    self.update_meta(feature_data_copy, "marker")
-                    # Update marker feature's metadata name
-                    feature_data_copy["meta"]["marker"][
-                        "name"
-                    ] += f"_{feature_name}"
-
-                    if storage is not None:
-                        logger.info(f"Storing in {storage}")
-                        self.store(
-                            type_=type_,
-                            feature=feature_name,
-                            out=feature_data_copy,
-                            storage=storage,
-                        )
-                    else:
-                        logger.info(
-                            "No storage specified, returning dictionary"
-                        )
-                        out[type_][feature_name] = feature_data_copy
-
-        return out

junifer/markers/complexity/complexity_base.py

@@ -53,6 +53,12 @@ class ComplexityBase(BaseMarker):
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "neurokit2"}
 
+    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+        "BOLD": {
+            "complexity": "vector",
+        },
+    }
+
     def __init__(
         self,
         parcellation: Union[str, List[str]],
@@ -78,33 +84,6 @@ class ComplexityBase(BaseMarker):
             klass=NotImplementedError,
         )
 
-    def get_valid_inputs(self) -> List[str]:
-        """Get valid data types for input.
-
-        Returns
-        -------
-        list of str
-            The list of data types that can be used as input for this marker.
-
-        """
-        return ["BOLD"]
-
-    def get_output_type(self, input_type: str) -> str:
-        """Get output type.
-
-        Parameters
-        ----------
-        input_type : str
-            The data type input to the marker.
-
-        Returns
-        -------
-        str
-            The storage type output by the marker.
-
-        """
-        return "vector"
-
     def compute(
         self,
         input: Dict[str, Any],
@@ -124,29 +103,30 @@ class ComplexityBase(BaseMarker):
         Returns
         -------
         dict
-            The computed result as dictionary. The following keys will be
-            included in the dictionary:
+            The computed result as dictionary. This will be either returned
+            to the user or stored in the storage by calling the store method
+            with this as a parameter. The dictionary has the following keys:
+
+           *  ``complexity`` : dictionary with the following keys:
 
-           * ``data`` : ROI-wise complexity measures as ``numpy.ndarray``
-           * ``col_names`` : ROI labels for the complexity measures as list
+                - ``data`` : ROI-wise complexity measures as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        # Initialize a ParcelAggregation
+        # Extract the 2D time series using ParcelAggregation
         parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Extract the 2D time series using parcel aggregation
-        parcel_aggregation_map = parcel_aggregation.compute(
-            input=input, extra_input=extra_input
-        )
-
+        ).compute(input=input, extra_input=extra_input)
         # Compute complexity measure
-        parcel_aggregation_map["data"] = self.compute_complexity(
-            parcel_aggregation_map["data"]
-        )
-
-        return parcel_aggregation_map
+        return {
+            "complexity": {
+                "data": self.compute_complexity(
+                    parcel_aggregation["aggregation"]["data"]
+                ),
+                "col_names": parcel_aggregation["aggregation"]["col_names"],
+            }
+        }

junifer/markers/complexity/tests/test_hurst_exponent.py

@@ -40,13 +40,14 @@ def test_compute() -> None:
         # Compute the marker
         feature_map = marker.fit_transform(element_data)
         # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["data"].ndim == 2
+        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_get_output_type() -> None:
     """Test HurstExponent get_output_type()."""
-    marker = HurstExponent(parcellation=PARCELLATION)
-    assert marker.get_output_type("BOLD") == "vector"
+    assert "vector" == HurstExponent(
+        parcellation=PARCELLATION
+    ).get_output_type(input_type="BOLD", output_feature="complexity")
 
 
 @pytest.mark.skipif(