junifer 0.0.5.dev183__tar.gz → 0.0.5.dev202__tar.gz

{junifer-0.0.5.dev183 → junifer-0.0.5.dev202}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: junifer
-Version: 0.0.5.dev183
+Version: 0.0.5.dev202
 Summary: JUelich NeuroImaging FEature extractoR
 Author-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>
 Maintainer-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>

junifer-0.0.5.dev202/docs/changes/newsfragments/349.change

@@ -0,0 +1 @@
+``fractional`` parameter for ``ALFFBase``, :class:`.ALFFParcels` and :class:`.ALFFSpheres` have been removed in favour of returning both ALFF and fALFF by `Synchon Mandal`_

junifer-0.0.5.dev202/docs/changes/newsfragments/349.enh

@@ -0,0 +1 @@
+Enable Markers to output multiple features by `Synchon Mandal`_

{junifer-0.0.5.dev183 → junifer-0.0.5.dev202}/docs/extending/marker.rst

@@ -5,24 +5,17 @@
 Creating Markers
 ================
 
-Computing a marker (a.k.a. *feature*) is the main goal of ``junifer``. While we
-aim to provide as many Markers as possible, it might be the case that the Marker
-you are looking for is not available. In this case, you can create your own Marker
-by following this tutorial.
+Computing a marker (a.k.a. *feature(s)*) is the main goal of ``junifer``. While
+we aim to provide as many Markers as possible, it might be the case that the
+Marker you are looking for is not available. In this case, you can create your
+own Marker by following this tutorial.
 
 Most of the functionality of a ``junifer`` Marker has been taken care by the
-:class:`.BaseMarker` class. Thus, only a few methods are required:
-
-#. ``get_valid_inputs``: The method to obtain the list of valid inputs for the
-   Marker. This is used to check that the inputs provided by the user are
-   valid. This method should return a list of strings, representing
-   :ref:`data types <data_types>`.
-#. ``get_output_type``: The method to obtain the output type of the Marker.
-   This is used to check that the output of the Marker is compatible with the
-   storage. This method should return a string, representing
-   :ref:`storage types <storage_types>`.
-#. ``compute``: The method that given the data, computes the Marker.
+:class:`.BaseMarker` class. Thus, only a few methods and class attributes are
+required:
+
 #. ``__init__``: The initialisation method, where the Marker is configured.
+#. ``compute``: The method that given the data, computes the Marker.
 
 As an example, we will develop a ``ParcelMean`` Marker, a Marker that first
 applies a parcellation and then computes the mean of the data in each parcel.
@@ -35,24 +28,26 @@ Step 1: Configure input and output
 
 This step is quite simple: we need to define the input and output of the Marker.
 Based on the current :ref:`data types <data_types>`, we can have ``BOLD``,
-``VBM_WM`` and ``VBM_GM`` as valid inputs.
+``VBM_WM`` and ``VBM_GM`` as valid inputs. The output of the Marker depends on
+the input. For ``BOLD``, it will be ``timeseries``, while for the rest of the
+inputs, it will be ``vector``. Thus, we have a class attribute like so:
 
 .. code-block:: python
 
-    def get_valid_inputs(self) -> list[str]:
-        return ["BOLD", "VBM_WM", "VBM_GM"]
-
-The output of the Marker depends on the input. For ``BOLD``, it will be
-``timeseries``, while for the rest of the inputs, it will be ``vector``. Thus,
-we can define the output as:
-
-.. code-block:: python
-
-    def get_output_type(self, input_type: str) -> str:
-        if input_type == "BOLD":
-            return "timeseries"
-        else:
-            return "vector"
+    # NOTE: data type -> feature -> storage type
+    # You can have multiple features for one data type,
+    # each feature having same or different storage type
+    _MARKER_INOUT_MAPPINGS = {
+        "BOLD": {
+            "parcel_mean": "timeseries",
+        },
+        "VBM_WM": {
+            "parcel_mean": "vector",
+        },
+        "VBM_GM": {
+            "parcel_mean": "vector",
+        },
+    }
 
 .. _extending_markers_init:
 
@@ -119,7 +114,8 @@ arguments:
 Following the example, we will compute the mean of the data in each parcel using
 :class:`nilearn.maskers.NiftiLabelsMasker`. Importantly, the output of the
 compute function must be a dictionary. This dictionary will later be passed onto
-the ``store`` method.
+the ``store`` method. The dictionary's first level of keys would the feature name
+and the values would be a dictionary of storage type specific key-value pairs.
 
 .. hint::
 
@@ -162,11 +158,13 @@ the ``store`` method.
         # mask the data
         out_values = masker.fit_transform([data])
 
-        # Create the output dictionary
-        out = {"data": out_values, "col_names": t_labels}
-
-        return out
-
+        # Create and return the output dictionary
+        return {
+            "parcel_mean": {
+                "data": out_values,
+                "col_names": t_labels,
+            },
+        }
 
 .. _extending_markers_finalize:
 
@@ -193,11 +191,11 @@ Finally, we need to register the Marker using the ``@register_marker`` decorator
 
 .. code-block:: python
 
-    from typing import Any
+    from typing import Any, ClassVar
 
     from junifer.api.decorators import register_marker
     from junifer.data import get_parcellation
-    from junifer.markers.base import BaseMarker
+    from junifer.markers import BaseMarker
     from nilearn.maskers import NiftiLabelsMasker
 
 
@@ -206,6 +204,18 @@ Finally, we need to register the Marker using the ``@register_marker`` decorator
 
         _DEPENDENCIES = {"nilearn", "numpy"}
 
+        _MARKER_INOUT_MAPPINGS: ClassVar[dict[str, dict[str, str]]] = {
+            "BOLD": {
+                "parcel_mean": "timeseries",
+            },
+            "VBM_WM": {
+                "parcel_mean": "vector",
+            },
+            "VBM_GM": {
+                "parcel_mean": "vector",
+            },
+        }
+
         def __init__(
             self,
             parcellation: str,
@@ -215,15 +225,6 @@ Finally, we need to register the Marker using the ``@register_marker`` decorator
             self.parcellation = parcellation
             super().__init__(on=on, name=name)
 
-        def get_valid_inputs(self) -> list[str]:
-            return ["BOLD", "VBM_WM", "VBM_GM"]
-
-        def get_output_type(self, input_type: str) -> str:
-            if input_type == "BOLD":
-                return "timeseries"
-            else:
-                return "vector"
-
         def compute(
             self,
             input: dict[str, Any],
@@ -250,11 +251,13 @@ Finally, we need to register the Marker using the ``@register_marker`` decorator
             # mask the data
             out_values = masker.fit_transform([data])
 
-            # Create the output dictionary
-            out = {"data": out_values, "col_names": t_labels}
-
-            return out
-
+            # Create and return the output dictionary
+            return {
+                "parcel_mean": {
+                    "data": out_values,
+                    "col_names": t_labels,
+                },
+            }
 
 .. _extending_markers_template:
 
@@ -269,22 +272,16 @@ Template for a custom Marker
 
     @register_marker
     class TemplateMarker(BaseMarker):
+
+        # TODO: add the dependencies
+        _DEPENDENCIES = {}
+
+        # TODO: add the input-output mappings
+        _MARKER_INOUT_MAPPINGS = {}
+
         def __init__(self, on=None, name=None):
             # TODO: add marker-specific parameters
             super().__init__(on=on, name=name)
 
-        def get_valid_inputs(self):
-            # TODO: Complete with the valid inputs
-            valid = []
-            return valid
-
-        def get_output_type(self, input_type):
-            # TODO: Return the valid output type for each input type
-            pass
-
         def compute(self, input, extra_input):
             # TODO: compute the marker and create the output dictionary
-
-            # Create the output dictionary
-            out = {"data": None, "col_names": None}
-            return out

{junifer-0.0.5.dev183 → junifer-0.0.5.dev202}/docs/understanding/marker.rst

@@ -26,7 +26,5 @@ on them outside the context as long as the actual data is in the memory and the
 Python runtime has not garbage-collected it.
 
 If you are interested in using already provided Markers, please go to
-:doc:`../builtin`. And, if you want to implement your own Marker, you need to
-provide concrete implementation of :class:`.BaseMarker`. Specifically, you
-need to override ``get_valid_inputs``, ``get_output_type`` and ``compute``
-methods.
+:doc:`../builtin`. And, if you want to implement your own Marker, please check
+out :doc:`../extending/marker`.

{junifer-0.0.5.dev183 → junifer-0.0.5.dev202}/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-0.0.5.dev183 → junifer-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-0.0.5.dev183 → junifer-0.0.5.dev202}/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-0.0.5.dev183 → junifer-0.0.5.dev202}/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