junifer 0.0.5.dev240__py3-none-any.whl → 0.0.6__py3-none-any.whl

junifer/datagrabber/pattern.py

@@ -8,11 +8,12 @@
 import re
 from copy import deepcopy
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import numpy as np
 
 from ..api.decorators import register_datagrabber
+from ..typing import DataGrabberPatterns, Elements
 from ..utils import logger, raise_error
 from .base import BaseDataGrabber
 from .pattern_validation_mixin import PatternValidationMixin
@@ -89,7 +90,7 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
           .. code-block:: none
 
             {
-              "mandatory": ["pattern", "src", "dst"],
+              "mandatory": ["pattern", "src", "dst", "warper"],
               "optional": []
             }
 
@@ -127,11 +128,22 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
                 "pattern": "...",
                 "space": "...",
               },
-              "Warp": {
-                "pattern": "...",
-                "src": "...",
-                "dst": "...",
-              }
+          }
+
+        except ``Warp``, which needs to be a list of dictionaries as there can
+        be multiple spaces to warp (for example, with fMRIPrep):
+
+        .. code-block:: none
+
+          {
+              "Warp": [
+                {
+                  "pattern": "...",
+                  "src": "...",
+                  "dst": "...",
+                  "warper": "...",
+                },
+              ],
           }
 
         taken from :class:`.HCP1200`.
@@ -159,9 +171,9 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
 
     def __init__(
         self,
-        types: List[str],
-        patterns: Dict[str, Dict[str, str]],
-        replacements: Union[List[str], str],
+        types: list[str],
+        patterns: DataGrabberPatterns,
+        replacements: Union[list[str], str],
         datadir: Union[str, Path],
         confounds_format: Optional[str] = None,
         partial_pattern_ok: bool = False,
@@ -204,7 +216,7 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
 
     def _replace_patterns_regex(
         self, pattern: str
-    ) -> Tuple[str, str, List[str]]:
+    ) -> tuple[str, str, list[str]]:
         """Replace the patterns in ``pattern`` with the named groups.
 
         It allows elements to be obtained from the filesystem.
@@ -250,7 +262,7 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
 
         return re_pattern, glob_pattern, t_replacements
 
-    def _replace_patterns_glob(self, element: Dict, pattern: str) -> str:
+    def _replace_patterns_glob(self, element: dict, pattern: str) -> str:
         """Replace ``pattern`` with the ``element`` so it can be globbed.
 
         Parameters
@@ -283,7 +295,7 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
         return pattern.format(**element)
 
     def _get_path_from_patterns(
-        self, element: Dict, pattern: str, data_type: str
+        self, element: dict, pattern: str, data_type: str
     ) -> Path:
         """Get path from resolved patterns.
 
@@ -340,7 +352,7 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
 
         return path
 
-    def get_element_keys(self) -> List[str]:
+    def get_element_keys(self) -> list[str]:
         """Get element keys.
 
         For each item in the "element" tuple, this functions returns the
@@ -355,7 +367,7 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
         """
         return self.replacements
 
-    def get_item(self, **element: str) -> Dict[str, Dict]:
+    def get_item(self, **element: dict) -> dict[str, dict]:
         """Implement single element indexing for the datagrabber.
 
         This method constructs a real path to the requested item's data, by
@@ -380,46 +392,65 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
             t_pattern = self.patterns[t_type]
             # Copy data type dictionary in output
             out[t_type] = deepcopy(t_pattern)
-            # Iterate to check for nested "types" like mask
-            for k, v in t_pattern.items():
-                # Resolve pattern for base data type
-                if k == "pattern":
-                    logger.info(f"Resolving path from pattern for {t_type}")
+            # Conditional for list dtype vals like Warp
+            if isinstance(t_pattern, list):
+                for idx, entry in enumerate(t_pattern):
+                    logger.info(
+                        f"Resolving path from pattern for {t_type}.{idx}"
+                    )
                     # Resolve pattern
-                    base_data_type_pattern_path = self._get_path_from_patterns(
+                    dtype_pattern_path = self._get_path_from_patterns(
                         element=element,
-                        pattern=v,
-                        data_type=t_type,
+                        pattern=entry["pattern"],
+                        data_type=f"{t_type}.{idx}",
                     )
                     # Remove pattern key
-                    out[t_type].pop("pattern")
+                    out[t_type][idx].pop("pattern")
                     # Add path key
-                    out[t_type].update({"path": base_data_type_pattern_path})
-                # Resolve pattern for nested data type
-                if isinstance(v, dict) and "pattern" in v:
-                    # Set nested type key for easier access
-                    t_nested_type = f"{t_type}.{k}"
-                    logger.info(
-                        f"Resolving path from pattern for {t_nested_type}"
-                    )
-                    # Resolve pattern
-                    nested_data_type_pattern_path = (
-                        self._get_path_from_patterns(
+                    out[t_type][idx].update({"path": dtype_pattern_path})
+            else:
+                # Iterate to check for nested "types" like mask
+                for k, v in t_pattern.items():
+                    # Resolve pattern for base data type
+                    if k == "pattern":
+                        logger.info(
+                            f"Resolving path from pattern for {t_type}"
+                        )
+                        # Resolve pattern
+                        base_dtype_pattern_path = self._get_path_from_patterns(
                             element=element,
-                            pattern=v["pattern"],
-                            data_type=t_nested_type,
+                            pattern=v,
+                            data_type=t_type,
+                        )
+                        # Remove pattern key
+                        out[t_type].pop("pattern")
+                        # Add path key
+                        out[t_type].update({"path": base_dtype_pattern_path})
+                    # Resolve pattern for nested data type
+                    if isinstance(v, dict) and "pattern" in v:
+                        # Set nested type key for easier access
+                        t_nested_type = f"{t_type}.{k}"
+                        logger.info(
+                            f"Resolving path from pattern for {t_nested_type}"
+                        )
+                        # Resolve pattern
+                        nested_dtype_pattern_path = (
+                            self._get_path_from_patterns(
+                                element=element,
+                                pattern=v["pattern"],
+                                data_type=t_nested_type,
+                            )
+                        )
+                        # Remove pattern key
+                        out[t_type][k].pop("pattern")
+                        # Add path key
+                        out[t_type][k].update(
+                            {"path": nested_dtype_pattern_path}
                         )
-                    )
-                    # Remove pattern key
-                    out[t_type][k].pop("pattern")
-                    # Add path key
-                    out[t_type][k].update(
-                        {"path": nested_data_type_pattern_path}
-                    )
 
         return out
 
-    def get_elements(self) -> List:
+    def get_elements(self) -> Elements:
         """Implement fetching list of elements in the dataset.
 
         It will use regex to search for "replacements" in the "patterns" and
@@ -448,58 +479,63 @@ class PatternDataGrabber(BaseDataGrabber, PatternValidationMixin):
             t_type = self.types[t_idx]
             types_element = set()
 
-            # Get the pattern dict
-            t_pattern = self.patterns[t_type]
-            # Conditional fetch of base pattern for getting elements
-            pattern = None
-            # Try for data type pattern
-            pattern = t_pattern.get("pattern")
-            # Try for nested data type pattern
-            if pattern is None and self.partial_pattern_ok:
-                for v in t_pattern.values():
-                    if isinstance(v, dict) and "pattern" in v:
-                        pattern = v["pattern"]
-                        break
-
-            # Replace the pattern
-            (
-                re_pattern,
-                glob_pattern,
-                t_replacements,
-            ) = self._replace_patterns_regex(pattern)
-            for fname in self.datadir.glob(glob_pattern):
-                suffix = fname.relative_to(self.datadir).as_posix()
-                m = re.match(re_pattern, suffix)
-                if m is not None:
-                    # Find the groups of replacements present in the pattern
-                    # If one replacement is not present, set it to None.
-                    # We will take care of this in the intersection
-                    t_element = tuple([m.group(k) for k in t_replacements])
-                    if len(self.replacements) == 1:
-                        t_element = t_element[0]
-                    types_element.add(t_element)
-            # TODO: does this make sense as elements is always None
-            if elements is None:
-                elements = types_element
-            else:
-                # Do the intersection by filtering out elements in which
-                # the replacements are not None
-                if t_replacements == self.replacements:
-                    elements.intersection(types_element)
+            # Data type dictionary
+            patterns = self.patterns[t_type]
+            # Conditional for list dtype vals like Warp
+            if not isinstance(patterns, list):
+                patterns = [patterns]
+            for t_pattern in patterns:
+                # Conditional fetch of base pattern for getting elements
+                pattern = None
+                # Try for data type pattern
+                pattern = t_pattern.get("pattern")
+                # Try for nested data type pattern
+                if pattern is None and self.partial_pattern_ok:
+                    for v in t_pattern.values():
+                        if isinstance(v, dict) and "pattern" in v:
+                            pattern = v["pattern"]
+                            break
+
+                # Replace the pattern
+                (
+                    re_pattern,
+                    glob_pattern,
+                    t_replacements,
+                ) = self._replace_patterns_regex(pattern)
+                for fname in self.datadir.glob(glob_pattern):
+                    suffix = fname.relative_to(self.datadir).as_posix()
+                    m = re.match(re_pattern, suffix)
+                    if m is not None:
+                        # Find the groups of replacements present in the
+                        # pattern. If one replacement is not present, set it
+                        # to None. We will take care of this in the
+                        # intersection.
+                        t_element = tuple([m.group(k) for k in t_replacements])
+                        if len(self.replacements) == 1:
+                            t_element = t_element[0]
+                        types_element.add(t_element)
+                # TODO: does this make sense as elements is always None
+                if elements is None:
+                    elements = types_element
                 else:
-                    t_repl_idx = [
-                        i
-                        for i, v in enumerate(self.replacements)
-                        if v in t_replacements
-                    ]
-                    new_elements = set()
-                    for t_element in elements:
-                        if (
-                            tuple(np.array(t_element)[t_repl_idx])
-                            in types_element
-                        ):
-                            new_elements.add(t_element)
-                    elements = new_elements
+                    # Do the intersection by filtering out elements in which
+                    # the replacements are not None
+                    if t_replacements == self.replacements:
+                        elements.intersection(types_element)
+                    else:
+                        t_repl_idx = [
+                            i
+                            for i, v in enumerate(self.replacements)
+                            if v in t_replacements
+                        ]
+                        new_elements = set()
+                        for t_element in elements:
+                            if (
+                                tuple(np.array(t_element)[t_repl_idx])
+                                in types_element
+                            ):
+                                new_elements.add(t_element)
+                        elements = new_elements
         if elements is None:
             elements = set()
         return list(elements)