junifer 0.0.3.dev188__py3-none-any.whl → 0.0.4__py3-none-any.whl

junifer/datagrabber/utils.py

@@ -6,7 +6,60 @@
 
 from typing import Dict, List
 
-from ..utils import raise_error
+from ..utils import logger, raise_error
+
+
+# Define schema for pattern-based datagrabber's patterns
+PATTERNS_SCHEMA = {
+    "T1w": {
+        "mandatory": ["pattern", "space"],
+        "optional": ["mask_item"],
+    },
+    "T1w_mask": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "T2w": {
+        "mandatory": ["pattern", "space"],
+        "optional": ["mask_item"],
+    },
+    "T2w_mask": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "BOLD": {
+        "mandatory": ["pattern", "space"],
+        "optional": ["mask_item"],
+    },
+    "BOLD_confounds": {
+        "mandatory": ["pattern", "format"],
+        "optional": [],
+    },
+    "BOLD_mask": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "Warp": {
+        "mandatory": ["pattern", "src", "dst"],
+        "optional": [],
+    },
+    "VBM_GM": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "VBM_WM": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "VBM_CSF": {
+        "mandatory": ["pattern", "space"],
+        "optional": [],
+    },
+    "DWI": {
+        "mandatory": ["pattern"],
+        "optional": [],
+    },
+}
 
 
 def validate_types(types: List[str]) -> None:
@@ -17,6 +70,11 @@ def validate_types(types: List[str]) -> None:
     types : list of str
         The object to validate.
 
+    Raises
+    ------
+    TypeError
+        If ``types`` is not a list or if the values are not string.
+
     """
     if not isinstance(types, list):
         raise_error(msg="`types` must be a list", klass=TypeError)
@@ -25,7 +83,7 @@ def validate_types(types: List[str]) -> None:
 
 
 def validate_replacements(
-    replacements: List[str], patterns: Dict[str, str]
+    replacements: List[str], patterns: Dict[str, Dict[str, str]]
 ) -> None:
     """Validate the replacements.
 
@@ -36,32 +94,44 @@ def validate_replacements(
     patterns : dict
         The patterns to validate against.
 
+    Raises
+    ------
+    TypeError
+        If ``replacements`` is not a list or if the values are not string.
+    ValueError
+        If a value in ``replacements`` is not part of a data type pattern or
+        if no data type patterns contain all values in ``replacements``.
+
     """
     if not isinstance(replacements, list):
         raise_error(msg="`replacements` must be a list.", klass=TypeError)
 
-    if not isinstance(patterns, dict):
-        raise_error(msg="`patterns` must be a dict.", klass=TypeError)
-
     if any(not isinstance(x, str) for x in replacements):
         raise_error(
             msg="`replacements` must be a list of strings.", klass=TypeError
         )
 
     for x in replacements:
-        if all(x not in y for y in patterns.values()):
-            raise_error(msg=f"Replacement {x} is not part of any pattern.")
+        if all(
+            x not in y
+            for y in [
+                data_type_val["pattern"] for data_type_val in patterns.values()
+            ]
+        ):
+            raise_error(msg=f"Replacement: {x} is not part of any pattern.")
 
     # Check that at least one pattern has all the replacements
     at_least_one = False
-    for _, v in patterns.items():
-        if all(x in v for x in replacements):
+    for data_type_val in patterns.values():
+        if all(x in data_type_val["pattern"] for x in replacements):
             at_least_one = True
     if at_least_one is False:
         raise_error(msg="At least one pattern must contain all replacements.")
 
 
-def validate_patterns(types: List[str], patterns: Dict[str, str]) -> None:
+def validate_patterns(
+    types: List[str], patterns: Dict[str, Dict[str, str]]
+) -> None:
     """Validate the patterns.
 
     Parameters
@@ -71,6 +141,20 @@ def validate_patterns(types: List[str], patterns: Dict[str, str]) -> None:
     patterns : dict
         The object to validate.
 
+    Raises
+    ------
+    KeyError
+        If any mandatory key is missing for a data type.
+    RuntimeError
+        If an unknown key is found for a data type.
+    TypeError
+        If ``patterns`` is not a dictionary.
+    ValueError
+        If length of ``types`` and ``patterns`` are different or
+        if ``patterns`` is missing entries from ``types`` or
+        if unknown data type is found in ``patterns`` or
+        if data type pattern key contains '*' as value.
+
     """
     # Validate the types
     validate_types(types)
@@ -87,9 +171,60 @@ def validate_patterns(types: List[str], patterns: Dict[str, str]) -> None:
         raise_error(
             msg="`patterns` must contain all `types`", klass=ValueError
         )
-    # Wildcard check in patterns
-    if any("}*" in pattern for pattern in patterns.values()):
-        raise_error(
-            msg="`patterns` must not contain `*` following a replacement",
-            klass=ValueError,
-        )
+    # Check against schema
+    for data_type_key, data_type_val in patterns.items():
+        # Check if valid data type is provided
+        if data_type_key not in PATTERNS_SCHEMA:
+            raise_error(
+                f"Unknown data type: {data_type_key}, "
+                f"should be one of: {list(PATTERNS_SCHEMA.keys())}"
+            )
+        # Check mandatory keys for data type
+        for mandatory_key in PATTERNS_SCHEMA[data_type_key]["mandatory"]:
+            if mandatory_key not in data_type_val:
+                raise_error(
+                    msg=(
+                        f"Mandatory key: `{mandatory_key}` missing for "
+                        f"{data_type_key}"
+                    ),
+                    klass=KeyError,
+                )
+            else:
+                logger.debug(
+                    f"Mandatory key: `{mandatory_key}` found for "
+                    f"{data_type_key}"
+                )
+        # Check optional keys for data type
+        for optional_key in PATTERNS_SCHEMA[data_type_key]["optional"]:
+            if optional_key not in data_type_val:
+                logger.debug(
+                    f"Optional key: `{optional_key}` missing for "
+                    f"{data_type_key}"
+                )
+            else:
+                logger.debug(
+                    f"Optional key: `{optional_key}` found for "
+                    f"{data_type_key}"
+                )
+        # Check stray key for data type
+        for key in data_type_val.keys():
+            if key not in (
+                PATTERNS_SCHEMA[data_type_key]["mandatory"]
+                + PATTERNS_SCHEMA[data_type_key]["optional"]
+            ):
+                raise_error(
+                    msg=(
+                        f"Key: {key} not accepted for {data_type_key} "
+                        "pattern, remove it to proceed"
+                    ),
+                    klass=RuntimeError,
+                )
+        # Wildcard check in patterns
+        if "}*" in data_type_val["pattern"]:
+            raise_error(
+                msg=(
+                    f"`{data_type_key}.pattern` must not contain `*` "
+                    "following a replacement"
+                ),
+                klass=ValueError,
+            )

junifer/datareader/default.py

@@ -53,23 +53,22 @@ class DefaultDataReader(PipelineStepMixin, UpdateMetaMixin):
         # Nothing to validate, any input is fine
         return input
 
-    def get_output_type(self, input: List[str]) -> List[str]:
+    def get_output_type(self, input_type: str) -> str:
         """Get output type.
 
         Parameters
         ----------
-        input : list of str
-            The input to the reader. The list must contain the
-            available Junifer Data dictionary keys.
+        input_type : str
+            The data type input to the reader.
 
         Returns
         -------
-        list of str
-            The updated list of output types, as reading possibilities.
+        str
+            The data type output by the reader.
 
         """
         # It will output the same type of data as the input
-        return input
+        return input_type
 
     def _fit_transform(
         self,
@@ -91,42 +90,69 @@ class DefaultDataReader(PipelineStepMixin, UpdateMetaMixin):
             The processed output as dictionary. The "data" key is added to
             each data type dictionary.
 
+        Warns
+        -----
+        RuntimeWarning
+            If input data type has no key called ``"path"``.
+
         """
-        # For each type of data, try to read it
+        # Copy input to not modify the original
         out = input.copy()
+        # Set default extra parameters
         if params is None:
             params = {}
+        # For each type of data, try to read it
         for type_ in input.keys():
+            # Skip Warp data type
+            if type_ == "Warp":
+                continue
+
+            # Check for malformed datagrabber specification
             if "path" not in input[type_]:
                 warn_with_log(
                     f"Input type {type_} does not provide a path. Skipping."
                 )
                 continue
+
+            # Retrieve actual path
             t_path = input[type_]["path"]
+            # Retrieve loading params for the data type
             t_params = params.get(type_, {})
 
-            # Convert to Path if datareader is not well done
+            # Convert str to Path
             if not isinstance(t_path, Path):
                 t_path = Path(t_path)
                 out[type_]["path"] = t_path
+
             logger.info(f"Reading {type_} from {t_path.as_posix()}")
+            # Initialize variable for file data
             fread = None
-
+            # Lowercase path
             fname = t_path.name.lower()
+            # Loop through extensions to find the correct one
             for ext, ftype in _extensions.items():
                 if fname.endswith(ext):
                     logger.info(f"{type_} is type {ftype}")
+                    # Retrieve reader function
                     reader_func = _readers[ftype]["func"]
+                    # Retrieve reader function params
                     reader_params = _readers[ftype]["params"]
+                    # Update reader function params
                     if reader_params is not None:
                         t_params.update(reader_params)
                     logger.debug(f"Calling {reader_func} with {t_params}")
+                    # Read data
                     fread = reader_func(t_path, **t_params)
                     break
+            # If no file data is found due to unknown extension
             if fread is None:
                 logger.info(
                     f"Unknown file type {t_path.as_posix()}, skipping reading"
                 )
+
+            # Set file data for output
             out[type_]["data"] = fread
+            # Update metadata for step
             self.update_meta(out[type_], "datareader")
+
         return out

junifer/external/nilearn/junifer_nifti_spheres_masker.py

@@ -98,6 +98,7 @@ def _apply_mask_and_get_affinity(
     A : scipy.sparse.lil_matrix
         Contains the boolean indices for each sphere.
         shape: (number of seeds, number of voxels)
+
     """
     seeds = list(seeds)
 
@@ -204,6 +205,7 @@ def _iter_signals_from_spheres(
     mask_img : Niimg-like object, optional
         See :ref:`extracting_data`.
         Mask to apply to regions before extracting signals.
+
     """
     X, A = _apply_mask_and_get_affinity(
         seeds, niimg, radius, allow_overlap, mask_img=mask_img
@@ -397,6 +399,10 @@ class JuniferNiftiSpheresMasker(NiftiSpheresMasker):
 
         params = get_params(NiftiSpheresMasker, self)
 
+        # New in nilearn 0.10.1
+        if hasattr(self, "clean_kwargs"):
+            params["clean_kwargs"] = self.clean_kwargs
+
         signals, _ = self._cache(
             _filter_and_extract, ignore=["verbose", "memory", "memory_level"]
         )(

junifer/markers/base.py

@@ -27,6 +27,11 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         The name of the marker. By default, it will use the class name as the
         name of the marker (default None).
 
+    Raises
+    ------
+    ValueError
+        If required input data type(s) is(are) not found.
+
     """
 
     def __init__(
@@ -34,31 +39,20 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         on: Optional[Union[List[str], str]] = None,
         name: Optional[str] = None,
     ) -> None:
+        # Use all data types if not provided
         if on is None:
             on = self.get_valid_inputs()
+        # Convert data types to list
         if not isinstance(on, list):
             on = [on]
+        # Set default name if not provided
         self.name = self.__class__.__name__ if name is None else name
-
+        # Check if required inputs are found
         if any(x not in self.get_valid_inputs() for x in on):
             wrong_on = [x for x in on if x not in self.get_valid_inputs()]
-            raise ValueError(f"{self.name} cannot be computed on {wrong_on}")
+            raise_error(f"{self.name} cannot be computed on {wrong_on}")
         self._on = on
 
-    @abstractmethod
-    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.
-        """
-        raise_error(
-            msg="Concrete classes need to implement get_valid_inputs().",
-            klass=NotImplementedError,
-        )
-
     def validate_input(self, input: List[str]) -> List[str]:
         """Validate input.
 
@@ -88,6 +82,21 @@ 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.
+
+        Returns
+        -------
+        list of str
+            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,
+        )
+
     @abstractmethod
     def get_output_type(self, input_type: str) -> str:
         """Get output type.

junifer/markers/collection.py

@@ -9,9 +9,10 @@ from typing import TYPE_CHECKING, Dict, List, Optional
 
 from ..datareader.default import DefaultDataReader
 from ..markers.base import BaseMarker
-from ..pipeline import PipelineStepMixin
+from ..pipeline import PipelineStepMixin, WorkDirManager
+from ..preprocess.base import BasePreprocessor
 from ..storage.base import BaseFeatureStorage
-from ..utils import logger
+from ..utils import logger, raise_error
 
 
 if TYPE_CHECKING:
@@ -27,25 +28,30 @@ class MarkerCollection:
         The markers to compute.
     datareader : DataReader-like object, optional
         The DataReader to use (default None).
-    preprocessing : preprocessing-like, optional
-        The preprocessing steps to apply.
+    preprocessors : list of preprocessing-like, optional
+        The preprocessors to apply (default None).
     storage : storage-like, optional
         The storage to use (default None).
 
+    Raises
+    ------
+    ValueError
+        If ``markers`` have same names.
+
     """
 
     def __init__(
         self,
         markers: List[BaseMarker],
         datareader: Optional[PipelineStepMixin] = None,
-        preprocessing: Optional[PipelineStepMixin] = None,
+        preprocessors: Optional[List[BasePreprocessor]] = None,
         storage: Optional[BaseFeatureStorage] = None,
     ):
         # Check that the markers have different names
         marker_names = [m.name for m in markers]
         if len(set(marker_names)) != len(marker_names):
             counts = Counter(marker_names)
-            raise ValueError(
+            raise_error(
                 "Markers must have different names. "
                 f"Current names are: {counts}"
             )
@@ -53,7 +59,7 @@ class MarkerCollection:
         if datareader is None:
             datareader = DefaultDataReader()
         self._datareader = datareader
-        self._preprocessing = preprocessing
+        self._preprocessors = preprocessors
         self._storage = storage
 
     def fit(self, input: Dict[str, Dict]) -> Optional[Dict]:
@@ -79,9 +85,14 @@ class MarkerCollection:
         data = self._datareader.fit_transform(input)
 
         # Apply preprocessing steps
-        if self._preprocessing is not None:
-            logger.info("Preprocessing data")
-            data = self._preprocessing.fit_transform(data)
+        if self._preprocessors is not None:
+            for preprocessor in self._preprocessors:
+                logger.info(
+                    "Preprocessing data with "
+                    f"{preprocessor.__class__.__name__}"
+                )
+                # Mutate data after every iteration
+                data = preprocessor.fit_transform(data)
 
         # Compute markers
         out = {}
@@ -92,15 +103,18 @@ class MarkerCollection:
                 out[marker.name] = m_value
         logger.info("Marker collection fitting done")
 
+        # Cleanup element directory
+        WorkDirManager().cleanup_elementdir()
+
         return None if self._storage else out
 
     def validate(self, datagrabber: "BaseDataGrabber") -> None:
         """Validate the pipeline.
 
         Without doing any computation, check if the marker collection can
-        be fit without problems. That is, the data required for each marker is
+        be fitted without problems i.e., the data required for each marker is
         present and streamed down the steps. Also, if a storage is configured,
-        check that the storage can handle the markers output.
+        check that the storage can handle the markers' output.
 
         Parameters
         ----------
@@ -116,10 +130,15 @@ class MarkerCollection:
         t_data = self._datareader.validate(t_data)
         logger.info(f"Data Reader output type: {t_data}")
 
-        if self._preprocessing is not None:
-            logger.info("Validating Preprocessor:")
-            t_data = self._preprocessing.validate(t_data)
-            logger.info(f"Preprocess output type: {t_data}")
+        if self._preprocessors is not None:
+            for preprocessor in self._preprocessors:
+                logger.info(
+                    "Validating Preprocessor: "
+                    f"{preprocessor.__class__.__name__}"
+                )
+                # Validate preprocessor
+                t_data = preprocessor.validate(t_data)
+                logger.info(f"Preprocess output type: {t_data}")
 
         for marker in self._markers:
             logger.info(f"Validating Marker: {marker.name}")

junifer/markers/complexity/__init__.py

@@ -0,0 +1,27 @@
+"""Provide imports for complexity sub-package."""
+
+# Authors: Amir Omidvarnia <a.omidvarnia@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+
+from importlib.util import find_spec
+
+from ..utils import raise_error
+
+
+# Check if neurokit2 is found
+if find_spec("neurokit2") is None:
+    raise_error(
+        msg="Could not find `neurokit2`, make sure the package is installed.",
+        klass=ImportError,
+    )
+else:
+    # Import markers
+    from .hurst_exponent import HurstExponent
+    from .range_entropy import RangeEntropy
+    from .range_entropy_auc import RangeEntropyAUC
+    from .perm_entropy import PermEntropy
+    from .weighted_perm_entropy import WeightedPermEntropy
+    from .sample_entropy import SampleEntropy
+    from .multiscale_entropy_auc import MultiscaleEntropyAUC