junifer 0.0.6.dev219__py3-none-any.whl → 0.0.6.dev248__py3-none-any.whl

junifer/datagrabber/pattern_validation_mixin.py

@@ -3,7 +3,7 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Dict, List
+from typing import Dict, List, Union
 
 from ..utils import logger, raise_error, warn_with_log
 
@@ -36,7 +36,7 @@ PATTERNS_SCHEMA = {
         },
     },
     "Warp": {
-        "mandatory": ["pattern", "src", "dst"],
+        "mandatory": ["pattern", "src", "dst", "warper"],
         "optional": {},
     },
     "VBM_GM": {
@@ -96,7 +96,7 @@ class PatternValidationMixin:
     def _validate_replacements(
         self,
         replacements: List[str],
-        patterns: Dict[str, Dict[str, str]],
+        patterns: Dict[str, Union[Dict[str, str], List[Dict[str, str]]]],
         partial_pattern_ok: bool,
     ) -> None:
         """Validate the replacements.
@@ -132,39 +132,51 @@ class PatternValidationMixin:
 
         if any(not isinstance(x, str) for x in replacements):
             raise_error(
-                msg="`replacements` must be a list of strings.",
+                msg="`replacements` must be a list of strings",
                 klass=TypeError,
             )
 
+        # Make a list of all patterns recursively
+        all_patterns = []
+        for dtype_val in patterns.values():
+            # Conditional for list dtype vals like Warp
+            if isinstance(dtype_val, list):
+                for entry in dtype_val:
+                    all_patterns.append(entry.get("pattern", ""))
+            else:
+                all_patterns.append(dtype_val.get("pattern", ""))
+        # Check for stray replacements
         for x in replacements:
-            if all(
-                x not in y
-                for y in [
-                    data_type_val.get("pattern", "")
-                    for data_type_val in patterns.values()
-                ]
-            ):
+            if all(x not in y for y in all_patterns):
                 if partial_pattern_ok:
                     warn_with_log(
                         f"Replacement: `{x}` is not part of any pattern, "
                         "things might not work as expected if you are unsure "
-                        "of what you are doing"
+                        "of what you are doing."
                     )
                 else:
                     raise_error(
-                        msg=f"Replacement: {x} is not part of any pattern."
+                        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 data_type_val in patterns.values():
-            if all(
-                x in data_type_val.get("pattern", "") for x in replacements
-            ):
-                at_least_one = True
+        for dtype_val in patterns.values():
+            # Conditional for list dtype vals like Warp
+            if isinstance(dtype_val, list):
+                for entry in dtype_val:
+                    if all(
+                        x in entry.get("pattern", "") for x in replacements
+                    ):
+                        at_least_one = True
+            else:
+                if all(
+                    x in dtype_val.get("pattern", "") for x in replacements
+                ):
+                    at_least_one = True
         if not at_least_one and not partial_pattern_ok:
             raise_error(
-                msg="At least one pattern must contain all replacements."
+                msg="At least one pattern must contain all replacements"
             )
 
     def _validate_mandatory_keys(
@@ -207,7 +219,7 @@ class PatternValidationMixin:
                     warn_with_log(
                         f"Mandatory key: `{key}` not found for {data_type}, "
                         "things might not work as expected if you are unsure "
-                        "of what you are doing"
+                        "of what you are doing."
                     )
                 else:
                     raise_error(
@@ -215,7 +227,7 @@ class PatternValidationMixin:
                         klass=KeyError,
                     )
             else:
-                logger.debug(f"Mandatory key: `{key}` found for {data_type}")
+                logger.debug(f"Mandatory key: `{key}` found for {data_type}.")
 
     def _identify_stray_keys(
         self, keys: List[str], schema: List[str], data_type: str
@@ -251,7 +263,7 @@ class PatternValidationMixin:
         self,
         types: List[str],
         replacements: List[str],
-        patterns: Dict[str, Dict[str, str]],
+        patterns: Dict[str, Union[Dict[str, str], List[Dict[str, str]]]],
         partial_pattern_ok: bool = False,
     ) -> None:
         """Validate the patterns.
@@ -298,87 +310,185 @@ class PatternValidationMixin:
                 msg="`patterns` must contain all `types`", klass=ValueError
             )
         # Check against schema
-        for data_type_key, data_type_val in patterns.items():
+        for dtype_key, dtype_val in patterns.items():
             # Check if valid data type is provided
-            if data_type_key not in PATTERNS_SCHEMA:
+            if dtype_key not in PATTERNS_SCHEMA:
                 raise_error(
-                    f"Unknown data type: {data_type_key}, "
+                    f"Unknown data type: {dtype_key}, "
                     f"should be one of: {list(PATTERNS_SCHEMA.keys())}"
                 )
-            # Check mandatory keys for data type
-            self._validate_mandatory_keys(
-                keys=list(data_type_val),
-                schema=PATTERNS_SCHEMA[data_type_key]["mandatory"],
-                data_type=data_type_key,
-                partial_pattern_ok=partial_pattern_ok,
-            )
-            # Check optional keys for data type
-            for optional_key, optional_val in PATTERNS_SCHEMA[data_type_key][
-                "optional"
-            ].items():
-                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}"
-                    )
-                    # Set nested type name for easier access
-                    nested_data_type = f"{data_type_key}.{optional_key}"
-                    nested_mandatory_keys_schema = PATTERNS_SCHEMA[
-                        data_type_key
-                    ]["optional"][optional_key]["mandatory"]
-                    nested_optional_keys_schema = PATTERNS_SCHEMA[
-                        data_type_key
-                    ]["optional"][optional_key]["optional"]
-                    # Check mandatory keys for nested type
+            # Conditional for list dtype vals like Warp
+            if isinstance(dtype_val, list):
+                for idx, entry in enumerate(dtype_val):
+                    # Check mandatory keys for data type
                     self._validate_mandatory_keys(
-                        keys=list(optional_val["mandatory"]),
-                        schema=nested_mandatory_keys_schema,
-                        data_type=nested_data_type,
+                        keys=list(entry),
+                        schema=PATTERNS_SCHEMA[dtype_key]["mandatory"],
+                        data_type=f"{dtype_key}.{idx}",
                         partial_pattern_ok=partial_pattern_ok,
                     )
-                    # Check optional keys for nested type
-                    for nested_optional_key in nested_optional_keys_schema:
-                        if nested_optional_key not in optional_val["optional"]:
+                    # Check optional keys for data type
+                    for optional_key, optional_val in PATTERNS_SCHEMA[
+                        dtype_key
+                    ]["optional"].items():
+                        if optional_key not in entry:
                             logger.debug(
-                                f"Optional key: `{nested_optional_key}` "
-                                f"missing for {nested_data_type}"
+                                f"Optional key: `{optional_key}` missing for "
+                                f"{dtype_key}.{idx}"
                             )
                         else:
                             logger.debug(
-                                f"Optional key: `{nested_optional_key}` found "
-                                f"for {nested_data_type}"
+                                f"Optional key: `{optional_key}` found for "
+                                f"{dtype_key}.{idx}"
+                            )
+                            # Set nested type name for easier access
+                            nested_dtype = f"{dtype_key}.{idx}.{optional_key}"
+                            nested_mandatory_keys_schema = PATTERNS_SCHEMA[
+                                dtype_key
+                            ]["optional"][optional_key]["mandatory"]
+                            nested_optional_keys_schema = PATTERNS_SCHEMA[
+                                dtype_key
+                            ]["optional"][optional_key]["optional"]
+                            # Check mandatory keys for nested type
+                            self._validate_mandatory_keys(
+                                keys=list(optional_val["mandatory"]),
+                                schema=nested_mandatory_keys_schema,
+                                data_type=nested_dtype,
+                                partial_pattern_ok=partial_pattern_ok,
+                            )
+                            # Check optional keys for nested type
+                            for (
+                                nested_optional_key
+                            ) in nested_optional_keys_schema:
+                                if (
+                                    nested_optional_key
+                                    not in optional_val["optional"]
+                                ):
+                                    logger.debug(
+                                        f"Optional key: "
+                                        f"`{nested_optional_key}` missing for "
+                                        f"{nested_dtype}"
+                                    )
+                                else:
+                                    logger.debug(
+                                        f"Optional key: "
+                                        f"`{nested_optional_key}` found for "
+                                        f"{nested_dtype}"
+                                    )
+                            # Check stray key for nested data type
+                            self._identify_stray_keys(
+                                keys=(
+                                    optional_val["mandatory"]
+                                    + optional_val["optional"]
+                                ),
+                                schema=(
+                                    nested_mandatory_keys_schema
+                                    + nested_optional_keys_schema
+                                ),
+                                data_type=nested_dtype,
                             )
-                    # Check stray key for nested data type
+                    # Check stray key for data type
                     self._identify_stray_keys(
-                        keys=optional_val["mandatory"]
-                        + optional_val["optional"],
-                        schema=nested_mandatory_keys_schema
-                        + nested_optional_keys_schema,
-                        data_type=nested_data_type,
+                        keys=list(entry.keys()),
+                        schema=(
+                            PATTERNS_SCHEMA[dtype_key]["mandatory"]
+                            + list(
+                                PATTERNS_SCHEMA[dtype_key]["optional"].keys()
+                            )
+                        ),
+                        data_type=dtype_key,
                     )
-            # Check stray key for data type
-            self._identify_stray_keys(
-                keys=list(data_type_val.keys()),
-                schema=(
-                    PATTERNS_SCHEMA[data_type_key]["mandatory"]
-                    + list(PATTERNS_SCHEMA[data_type_key]["optional"].keys())
-                ),
-                data_type=data_type_key,
-            )
-            # Wildcard check in patterns
-            if "}*" in data_type_val.get("pattern", ""):
-                raise_error(
-                    msg=(
-                        f"`{data_type_key}.pattern` must not contain `*` "
-                        "following a replacement"
+                    # Wildcard check in patterns
+                    if "}*" in entry.get("pattern", ""):
+                        raise_error(
+                            msg=(
+                                f"`{dtype_key}.pattern` must not contain `*` "
+                                "following a replacement"
+                            ),
+                            klass=ValueError,
+                        )
+            else:
+                # Check mandatory keys for data type
+                self._validate_mandatory_keys(
+                    keys=list(dtype_val),
+                    schema=PATTERNS_SCHEMA[dtype_key]["mandatory"],
+                    data_type=dtype_key,
+                    partial_pattern_ok=partial_pattern_ok,
+                )
+                # Check optional keys for data type
+                for optional_key, optional_val in PATTERNS_SCHEMA[dtype_key][
+                    "optional"
+                ].items():
+                    if optional_key not in dtype_val:
+                        logger.debug(
+                            f"Optional key: `{optional_key}` missing for "
+                            f"{dtype_key}."
+                        )
+                    else:
+                        logger.debug(
+                            f"Optional key: `{optional_key}` found for "
+                            f"{dtype_key}."
+                        )
+                        # Set nested type name for easier access
+                        nested_dtype = f"{dtype_key}.{optional_key}"
+                        nested_mandatory_keys_schema = PATTERNS_SCHEMA[
+                            dtype_key
+                        ]["optional"][optional_key]["mandatory"]
+                        nested_optional_keys_schema = PATTERNS_SCHEMA[
+                            dtype_key
+                        ]["optional"][optional_key]["optional"]
+                        # Check mandatory keys for nested type
+                        self._validate_mandatory_keys(
+                            keys=list(optional_val["mandatory"]),
+                            schema=nested_mandatory_keys_schema,
+                            data_type=nested_dtype,
+                            partial_pattern_ok=partial_pattern_ok,
+                        )
+                        # Check optional keys for nested type
+                        for nested_optional_key in nested_optional_keys_schema:
+                            if (
+                                nested_optional_key
+                                not in optional_val["optional"]
+                            ):
+                                logger.debug(
+                                    f"Optional key: `{nested_optional_key}` "
+                                    f"missing for {nested_dtype}"
+                                )
+                            else:
+                                logger.debug(
+                                    f"Optional key: `{nested_optional_key}` "
+                                    f"found for {nested_dtype}"
+                                )
+                        # Check stray key for nested data type
+                        self._identify_stray_keys(
+                            keys=(
+                                optional_val["mandatory"]
+                                + optional_val["optional"]
+                            ),
+                            schema=(
+                                nested_mandatory_keys_schema
+                                + nested_optional_keys_schema
+                            ),
+                            data_type=nested_dtype,
+                        )
+                # Check stray key for data type
+                self._identify_stray_keys(
+                    keys=list(dtype_val.keys()),
+                    schema=(
+                        PATTERNS_SCHEMA[dtype_key]["mandatory"]
+                        + list(PATTERNS_SCHEMA[dtype_key]["optional"].keys())
                     ),
-                    klass=ValueError,
+                    data_type=dtype_key,
                 )
+                # Wildcard check in patterns
+                if "}*" in dtype_val.get("pattern", ""):
+                    raise_error(
+                        msg=(
+                            f"`{dtype_key}.pattern` must not contain `*` "
+                            "following a replacement"
+                        ),
+                        klass=ValueError,
+                    )
 
         # Validate replacements
         self._validate_replacements(

junifer/datagrabber/tests/test_dmcc13_benchmark.py

@@ -116,7 +116,12 @@ def test_DMCC13Benchmark(
             data_file_names.extend(
                 [
                     "sub-01_desc-preproc_T1w.nii.gz",
-                    "sub-01_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5",
+                    [
+                        "sub-01_from-MNI152NLin2009cAsym_to-T1w"
+                        "_mode-image_xfm.h5",
+                        "sub-01_from-T1w_to-MNI152NLin2009cAsym"
+                        "_mode-image_xfm.h5",
+                    ],
                 ]
             )
         else:
@@ -127,14 +132,26 @@ def test_DMCC13Benchmark(
         for data_type, data_file_name in zip(data_types, data_file_names):
             # Assert data type
             assert data_type in out
-            # Assert data file path exists
-            assert out[data_type]["path"].exists()
-            # Assert data file path is a file
-            assert out[data_type]["path"].is_file()
-            # Assert data file name
-            assert out[data_type]["path"].name == data_file_name
-            # Assert metadata
-            assert "meta" in out[data_type]
+            # Conditional for Warp
+            if data_type == "Warp":
+                for idx, fname in enumerate(data_file_name):
+                    # Assert data file path exists
+                    assert out[data_type][idx]["path"].exists()
+                    # Assert data file path is a file
+                    assert out[data_type][idx]["path"].is_file()
+                    # Assert data file name
+                    assert out[data_type][idx]["path"].name == fname
+                    # Assert metadata
+                    assert "meta" in out[data_type][idx]
+            else:
+                # Assert data file path exists
+                assert out[data_type]["path"].exists()
+                # Assert data file path is a file
+                assert out[data_type]["path"].is_file()
+                # Assert data file name
+                assert out[data_type]["path"].name == data_file_name
+                # Assert metadata
+                assert "meta" in out[data_type]
 
         # Check BOLD nested data types
         for type_, file_name in zip(

junifer/markers/base.py

@@ -6,16 +6,13 @@
 
 from abc import ABC, abstractmethod
 from copy import deepcopy
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from ..pipeline import PipelineStepMixin, UpdateMetaMixin
+from ..typing import StorageLike
 from ..utils import logger, raise_error
 
 
-if TYPE_CHECKING:
-    from junifer.storage import BaseFeatureStorage
-
-
 __all__ = ["BaseMarker"]
 
 
@@ -159,7 +156,7 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         type_: str,
         feature: str,
         out: Dict[str, Any],
-        storage: "BaseFeatureStorage",
+        storage: StorageLike,
     ) -> None:
         """Store.
 
@@ -182,7 +179,7 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
     def _fit_transform(
         self,
         input: Dict[str, Dict],
-        storage: Optional["BaseFeatureStorage"] = None,
+        storage: Optional[StorageLike] = None,
     ) -> Dict:
         """Fit and transform.
 

junifer/markers/brainprint.py

@@ -11,7 +11,6 @@ from typing import (
     Dict,
     List,
     Optional,
-    Set,
     Union,
 )
 
@@ -25,6 +24,7 @@ from ..external.BrainPrint.brainprint.brainprint import (
 )
 from ..external.BrainPrint.brainprint.surfaces import surf_to_vtk
 from ..pipeline import WorkDirManager
+from ..typing import Dependencies, ExternalDependencies, MarkerInOutMappings
 from ..utils import logger, run_ext_cmd
 from .base import BaseMarker
 
@@ -68,7 +68,7 @@ class BrainPrint(BaseMarker):
 
     """
 
-    _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+    _EXT_DEPENDENCIES: ClassVar[ExternalDependencies] = [
         {
             "name": "freesurfer",
             "commands": [
@@ -80,9 +80,9 @@ class BrainPrint(BaseMarker):
         },
     ]
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"lapy", "numpy"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"lapy", "numpy"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "FreeSurfer": {
             "eigenvalues": "scalar_table",
             "areas": "vector",

junifer/markers/complexity/complexity_base.py

@@ -11,10 +11,10 @@ from typing import (
     Dict,
     List,
     Optional,
-    Set,
     Union,
 )
 
+from ...typing import Dependencies, MarkerInOutMappings
 from ...utils import raise_error
 from ..base import BaseMarker
 from ..parcel_aggregation import ParcelAggregation
@@ -51,9 +51,9 @@ class ComplexityBase(BaseMarker):
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "neurokit2"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn", "neurokit2"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "BOLD": {
             "complexity": "vector",
         },

junifer/markers/ets_rss.py

@@ -6,11 +6,12 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from typing import Any, ClassVar, Dict, List, Optional, Union
 
 import numpy as np
 
 from ..api.decorators import register_marker
+from ..typing import Dependencies, MarkerInOutMappings
 from ..utils import logger
 from .base import BaseMarker
 from .parcel_aggregation import ParcelAggregation
@@ -45,9 +46,9 @@ class RSSETSMarker(BaseMarker):
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "BOLD": {
             "rss_ets": "timeseries",
         },

junifer/markers/falff/_afni_falff.py

@@ -8,22 +8,20 @@ from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     ClassVar,
-    Dict,
-    List,
     Optional,
     Tuple,
-    Union,
 )
 
 import nibabel as nib
 
 from ...pipeline import WorkDirManager
+from ...typing import ExternalDependencies
 from ...utils import logger, run_ext_cmd
 from ...utils.singleton import Singleton
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["AFNIALFF"]
@@ -37,7 +35,7 @@ class AFNIALFF(metaclass=Singleton):
 
     """
 
-    _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+    _EXT_DEPENDENCIES: ClassVar[ExternalDependencies] = [
         {
             "name": "afni",
             "commands": ["3dRSFC", "3dAFNItoNIFTI"],

junifer/markers/falff/_junifer_falff.py

@@ -9,7 +9,6 @@ from typing import (
     TYPE_CHECKING,
     ClassVar,
     Optional,
-    Set,
     Tuple,
 )
 
@@ -19,12 +18,13 @@ import scipy as sp
 from nilearn import image as nimg
 
 from ...pipeline import WorkDirManager
+from ...typing import Dependencies
 from ...utils import logger
 from ...utils.singleton import Singleton
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["JuniferALFF"]
@@ -37,7 +37,7 @@ class JuniferALFF(metaclass=Singleton):
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"numpy", "nilearn", "scipy"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"numpy", "nilearn", "scipy"}
 
     def __del__(self) -> None:
         """Terminate the class."""

junifer/markers/falff/falff_base.py

@@ -12,13 +12,11 @@ from typing import (
     Any,
     ClassVar,
     Dict,
-    List,
     Optional,
     Tuple,
-    Type,
-    Union,
 )
 
+from ...typing import ConditionalDependencies, MarkerInOutMappings
 from ...utils.logging import logger, raise_error
 from ..base import BaseMarker
 from ._afni_falff import AFNIALFF
@@ -26,7 +24,7 @@ from ._junifer_falff import JuniferALFF
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["ALFFBase"]
@@ -72,7 +70,7 @@ class ALFFBase(BaseMarker):
 
     """
 
-    _CONDITIONAL_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, Type]]]] = [
+    _CONDITIONAL_DEPENDENCIES: ClassVar[ConditionalDependencies] = [
         {
             "using": "afni",
             "depends_on": AFNIALFF,
@@ -83,7 +81,7 @@ class ALFFBase(BaseMarker):
         },
     ]
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "BOLD": {
             "alff": "vector",
             "falff": "vector",