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

junifer/data/pipeline_data_registry_base.py

@@ -0,0 +1,76 @@
+"""Provide abstract base class for pipeline data registry."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
+from typing import Any
+
+from ..utils import raise_error
+from ..utils.singleton import ABCSingleton
+
+
+__all__ = ["BasePipelineDataRegistry"]
+
+
+class BasePipelineDataRegistry(ABC, metaclass=ABCSingleton):
+    """Abstract base class for pipeline data registry.
+
+    For every interface that is required, one needs to provide a concrete
+    implementation for this abstract class.
+
+    Attributes
+    ----------
+    registry : dict
+        Registry of available pipeline data.
+    list : dict
+        Keys of available pipeline data registry.
+
+    """
+
+    def __init__(self) -> None:
+        """Initialize the class."""
+        self._registry: Mapping[str, Any] = {}
+
+    @property
+    def data(self) -> Mapping[str, Any]:
+        """Get available pipeline data."""
+        return self._registry
+
+    @property
+    def list(self) -> list[str]:
+        """List available pipeline data keys."""
+        return sorted(self._registry.keys())
+
+    @abstractmethod
+    def register(self) -> None:
+        """Register data."""
+        raise_error(
+            msg="Concrete classes need to implement register().",
+            klass=NotImplementedError,
+        )
+
+    @abstractmethod
+    def deregister(self) -> None:
+        """De-register data."""
+        raise_error(
+            msg="Concrete classes need to implement deregister().",
+            klass=NotImplementedError,
+        )
+
+    @abstractmethod
+    def load(self) -> Any:
+        """Load data."""
+        raise_error(
+            msg="Concrete classes need to implement load().",
+            klass=NotImplementedError,
+        )
+
+    @abstractmethod
+    def get(self) -> Any:
+        """Get tailored data for a target."""
+        raise_error(
+            msg="Concrete classes need to implement get().",
+            klass=NotImplementedError,
+        )

junifer/data/template_spaces.py

@@ -4,23 +4,21 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
-import httpx
 import nibabel as nib
 import numpy as np
+from junifer_data import get
 from templateflow import api as tflow
 
 from ..utils import logger, raise_error
-from .utils import closest_resolution
+from .utils import JUNIFER_DATA_PARAMS, closest_resolution, get_dataset_path
 
 
-__all__ = ["get_xfm", "get_template"]
+__all__ = ["get_template", "get_xfm"]
 
 
-def get_xfm(
-    src: str, dst: str, xfms_dir: Union[str, Path, None] = None
-) -> Path:  # pragma: no cover
+def get_xfm(src: str, dst: str) -> Path:  # pragma: no cover
     """Fetch warp files to convert from ``src`` to ``dst``.
 
     Parameters
@@ -29,80 +27,29 @@ def get_xfm(
         The template space to transform from.
     dst : str
         The template space to transform to.
-    xfms_dir : str or pathlib.Path, optional
-        Path where the retrieved transformation files are stored.
-        The default location is "$HOME/junifer/data/xfms" (default None).
 
     Returns
     -------
     pathlib.Path
         The path to the transformation file.
 
-    Raises
-    ------
-    RuntimeError
-        If there is a problem fetching files.
-
     """
-    if xfms_dir is None:
-        xfms_dir = Path().home() / "junifer" / "data" / "xfms"
-        logger.debug(f"Creating xfm directory at: {xfms_dir.resolve()}")
-        # Create default junifer data directory if not present
-        xfms_dir.mkdir(exist_ok=True, parents=True)
-    # Convert str to Path
-    elif not isinstance(xfms_dir, Path):
-        xfms_dir = Path(xfms_dir)
-
-    # Set local file prefix
-    xfm_file_prefix = f"{src}_to_{dst}"
-    # Set local file dir
-    xfm_file_dir = xfms_dir / xfm_file_prefix
-    # Create local directory if not present
-    xfm_file_dir.mkdir(exist_ok=True, parents=True)
-    # Set file name with extension
-    xfm_file = f"{src}_to_{dst}_Composite.h5"
-    # Set local file path
-    xfm_file_path = xfm_file_dir / xfm_file
-    # Check if the file exists
-    if xfm_file_path.exists():
-        logger.info(
-            f"Found existing xfm file for {src} to {dst} at "
-            f"{xfm_file_path.resolve()}"
-        )
-        return xfm_file_path
-
-    # Set URL
-    url = (
-        "https://gin.g-node.org/juaml/human-template-xfms/raw/main/xfms/"
-        f"{xfm_file_prefix}/{xfm_file}"
+    # Set file path to retrieve
+    xfm_file_path = Path(f"xfms/{src}_to_{dst}/{src}_to_{dst}_Composite.h5")
+    # Retrieve file
+    return get(
+        file_path=xfm_file_path,
+        dataset_path=get_dataset_path(),
+        **JUNIFER_DATA_PARAMS,
     )
-    # Create the file before proceeding
-    xfm_file_path.touch()
-
-    logger.info(f"Downloading xfm file for {src} to {dst} from {url}")
-    # Steam response
-    with httpx.stream("GET", url) as resp:
-        try:
-            resp.raise_for_status()
-        except httpx.HTTPError as exc:
-            raise_error(
-                f"Error response {exc.response.status_code} while "
-                f"requesting {exc.request.url!r}",
-                klass=RuntimeError,
-            )
-        else:
-            with open(xfm_file_path, "ab") as f:
-                for chunk in resp.iter_bytes():
-                    f.write(chunk)
-
-    return xfm_file_path
 
 
 def get_template(
     space: str,
-    target_data: Dict[str, Any],
-    extra_input: Optional[Dict[str, Any]] = None,
+    target_img: nib.Nifti1Image,
+    extra_input: Optional[dict[str, Any]] = None,
     template_type: str = "T1w",
+    resolution: Optional[Union[int, "str"]] = None,
 ) -> nib.Nifti1Image:
     """Get template for the space, tailored for the target image.
 
@@ -110,14 +57,18 @@ def get_template(
     ----------
     space : str
         The name of the template space.
-    target_data : dict
-        The corresponding item of the data object for which the template space
-        will be loaded.
+    target_img : Nifti1Image
+        The corresponding image for which the template space will be loaded.
+        This is used to obtain the best matching resolution.
     extra_input : dict, optional
         The other fields in the data object. Useful for accessing other data
         types (default None).
     template_type : {"T1w", "brain", "gm", "wm", "csf"}, optional
         The template type to retrieve (default "T1w").
+    resolution : int or "highest", optional
+        The resolution of the template to fetch. If None, the closest
+        resolution to the target image is used (default None). If "highest",
+        the highest resolution is used.
 
     Returns
     -------
@@ -127,7 +78,8 @@ def get_template(
     Raises
     ------
     ValueError
-        If ``space`` or ``template_type`` is invalid.
+        If ``space`` or ``template_type`` is invalid or
+        if ``resolution`` is not at int or "highest".
     RuntimeError
         If required template is not found.
 
@@ -140,19 +92,30 @@ def get_template(
     if template_type not in ["T1w", "brain", "gm", "wm", "csf"]:
         raise_error(f"Unknown template type: {template_type}")
 
-    # Get the min of the voxels sizes and use it as the resolution
-    target_img = target_data["data"]
-    resolution = np.min(target_img.header.get_zooms()[:3]).astype(int)
+    if isinstance(resolution, str) and resolution != "highest":
+        raise_error(
+            "Invalid resolution value. Must be an integer or 'highest'"
+        )
 
     # Fetch available resolutions for the template
     available_resolutions = [
         int(min(val["zooms"]))
         for val in tflow.get_metadata(space)["res"].values()
     ]
+
+    # Get the min of the voxels sizes and use it as the resolution
+    if resolution is None:
+        resolution = np.min(target_img.header.get_zooms()[:3]).astype(int)
+    elif resolution == "highest":
+        resolution = 0
+
     # Use the closest resolution if desired resolution is not found
     resolution = closest_resolution(resolution, available_resolutions)
 
-    logger.info(f"Downloading template {space} in resolution {resolution}")
+    logger.info(
+        f"Downloading template {space} ({template_type} in "
+        f"resolution {resolution})"
+    )
     # Retrieve template
     try:
         suffix = None
@@ -185,9 +148,11 @@ def get_template(
         )
     except Exception:  # noqa: BLE001
         raise_error(
-            f"Template {space} ({template_type}) with resolution {resolution} "
-            "not found",
+            msg=(
+                f"Template {space} ({template_type}) with resolution "
+                f"{resolution}) not found"
+            ),
             klass=RuntimeError,
         )
     else:
-        return nib.load(template_path)  # type: ignore
+        return nib.load(template_path)

junifer/data/tests/test_data_utils.py

@@ -3,7 +3,6 @@
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 # License: AGPL
 
-from typing import List
 
 import numpy as np
 import pytest
@@ -24,7 +23,7 @@ from junifer.data.utils import closest_resolution
     ],
 )
 def test_closest_resolution(
-    resolution: float, valid_resolutions: List[float], expected: float
+    resolution: float, valid_resolutions: list[float], expected: float
 ):
     """Test closest_resolution.
 

junifer/data/tests/test_template_spaces.py

@@ -61,7 +61,9 @@ def test_get_template(template_type: str) -> None:
         bold = element_data["BOLD"]
         # Get tailored parcellation
         tailored_template = get_template(
-            space=bold["space"], target_data=bold, template_type=template_type
+            space=bold["space"],
+            target_img=bold["data"],
+            template_type=template_type,
         )
         assert isinstance(tailored_template, nib.Nifti1Image)
 
@@ -74,7 +76,7 @@ def test_get_template_invalid_space() -> None:
         vbm_gm = element_data["VBM_GM"]
         # Get tailored parcellation
         with pytest.raises(ValueError, match="Unknown template space:"):
-            get_template(space="andromeda", target_data=vbm_gm)
+            get_template(space="andromeda", target_img=vbm_gm["data"])
 
 
 def test_get_template_invalid_template_type() -> None:
@@ -87,7 +89,7 @@ def test_get_template_invalid_template_type() -> None:
         with pytest.raises(ValueError, match="Unknown template type:"):
             get_template(
                 space=vbm_gm["space"],
-                target_data=vbm_gm,
+                target_img=vbm_gm["data"],
                 template_type="xenon",
             )
 
@@ -100,5 +102,7 @@ def test_get_template_closest_resolution() -> None:
         vbm_gm = element_data["VBM_GM"]
         # Change header resolution to fetch closest resolution
         element_data["VBM_GM"]["data"].header.set_zooms((3, 3, 3))
-        template = get_template(space=vbm_gm["space"], target_data=vbm_gm)
+        template = get_template(
+            space=vbm_gm["space"], target_img=vbm_gm["data"]
+        )
         assert isinstance(template, nib.Nifti1Image)

junifer/data/utils.py

@@ -1,18 +1,43 @@
 """Provide utilities for data module."""
 
-from typing import List, Optional, Union
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from collections.abc import MutableMapping
+from pathlib import Path
+from typing import Optional, Union
 
 import numpy as np
 
-from ..utils.logging import logger
+from ..utils import config, logger, raise_error
+
+
+__all__ = [
+    "JUNIFER_DATA_HEXSHA",
+    "JUNIFER_DATA_PARAMS",
+    "JUNIFER_DATA_VERSION",
+    "closest_resolution",
+    "get_dataset_path",
+    "get_native_warper",
+]
+
 
+# junifer-data version constant
+JUNIFER_DATA_VERSION = "2"
 
-__all__ = ["closest_resolution"]
+# junifer-data hexsha constant
+JUNIFER_DATA_HEXSHA = "015712689254c052fa64bca19f0f2da342e664ac"
+
+JUNIFER_DATA_PARAMS = {
+    "tag": JUNIFER_DATA_VERSION,
+    "hexsha": JUNIFER_DATA_HEXSHA,
+}
 
 
 def closest_resolution(
     resolution: Optional[Union[float, int]],
-    valid_resolution: Union[List[float], List[int], np.ndarray],
+    valid_resolution: Union[list[float], list[int], np.ndarray],
 ) -> Union[float, int]:
     """Find the closest resolution.
 
@@ -45,3 +70,83 @@ def closest_resolution(
         closest = np.min(valid_resolution)
 
     return closest
+
+
+def get_native_warper(
+    target_data: MutableMapping,
+    other_data: MutableMapping,
+    inverse: bool = False,
+) -> dict:
+    """Get correct warping specification for native space.
+
+    Parameters
+    ----------
+    target_data : dict
+        The target data from the pipeline data object.
+    other_data : dict
+        The other data in the pipeline data object.
+    inverse : bool, optional
+        Whether to get the inverse warping specification (default False).
+
+    Returns
+    -------
+    dict
+        The correct warping specification.
+
+    Raises
+    ------
+    RuntimeError
+        If no warper or multiple possible warpers are found.
+
+    """
+    # Get possible warpers
+    possible_warpers = []
+    for entry in other_data["Warp"]:
+        if not inverse:
+            if (
+                entry["src"] == target_data["prewarp_space"]
+                and entry["dst"] == "native"
+            ):
+                possible_warpers.append(entry)
+        else:
+            if (
+                entry["dst"] == target_data["prewarp_space"]
+                and entry["src"] == "native"
+            ):
+                possible_warpers.append(entry)
+
+    # Check for no warper
+    if not possible_warpers:
+        raise_error(
+            klass=RuntimeError,
+            msg="Could not find correct warping specification",
+        )
+
+    # Check for multiple possible warpers
+    if len(possible_warpers) > 1:
+        raise_error(
+            klass=RuntimeError,
+            msg=(
+                "Cannot proceed as multiple warping specification found, "
+                "adjust either the DataGrabber or the working space: "
+                f"{possible_warpers}"
+            ),
+        )
+
+    return possible_warpers[0]
+
+
+def get_dataset_path() -> Optional[Path]:
+    """Get junifer-data dataset path.
+
+    Returns
+    -------
+    pathlib.Path or None
+        Path to the dataset or None.
+
+    """
+    return (
+        Path(config.get("data.location"))
+        if config.get("data.location") is not None
+        else None
+    )

junifer/datagrabber/__init__.py

@@ -5,31 +5,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+import lazy_loader as lazy
 
-# These 4 need to be in this order, otherwise it is a circular import
-from .base import BaseDataGrabber
-from .datalad_base import DataladDataGrabber
-from .pattern import PatternDataGrabber
-from .pattern_datalad import PatternDataladDataGrabber
 
-from .aomic import DataladAOMICID1000, DataladAOMICPIOP1, DataladAOMICPIOP2
-from .hcp1200 import HCP1200, DataladHCP1200
-from .multiple import MultipleDataGrabber
-from .dmcc13_benchmark import DMCC13Benchmark
-
-from .pattern_validation_mixin import PatternValidationMixin
-
-__all__ = [
-    "BaseDataGrabber",
-    "DataladDataGrabber",
-    "PatternDataGrabber",
-    "PatternDataladDataGrabber",
-    "DataladAOMICID1000",
-    "DataladAOMICPIOP1",
-    "DataladAOMICPIOP2",
-    "HCP1200",
-    "DataladHCP1200",
-    "MultipleDataGrabber",
-    "DMCC13Benchmark",
-    "PatternValidationMixin",
-]
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

junifer/datagrabber/__init__.pyi

@@ -0,0 +1,27 @@
+__all__ = [
+    "BaseDataGrabber",
+    "DataladDataGrabber",
+    "PatternDataGrabber",
+    "PatternDataladDataGrabber",
+    "DataladAOMICID1000",
+    "DataladAOMICPIOP1",
+    "DataladAOMICPIOP2",
+    "HCP1200",
+    "DataladHCP1200",
+    "MultipleDataGrabber",
+    "DMCC13Benchmark",
+    "PatternValidationMixin",
+]
+
+# These 4 need to be in this order, otherwise it is a circular import
+from .base import BaseDataGrabber
+from .datalad_base import DataladDataGrabber
+from .pattern import PatternDataGrabber
+from .pattern_datalad import PatternDataladDataGrabber
+
+from .aomic import DataladAOMICID1000, DataladAOMICPIOP1, DataladAOMICPIOP2
+from .hcp1200 import HCP1200, DataladHCP1200
+from .multiple import MultipleDataGrabber
+from .dmcc13_benchmark import DMCC13Benchmark
+
+from .pattern_validation_mixin import PatternValidationMixin

junifer/datagrabber/aomic/__init__.py

@@ -4,9 +4,7 @@
 #          Leonard Sasse <l.sasse@fz-juelich.de>
 # License: AGPL
 
-from .id1000 import DataladAOMICID1000
-from .piop1 import DataladAOMICPIOP1
-from .piop2 import DataladAOMICPIOP2
+import lazy_loader as lazy
 
 
-__all__ = ["DataladAOMICID1000", "DataladAOMICPIOP1", "DataladAOMICPIOP2"]
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

junifer/datagrabber/aomic/__init__.pyi

@@ -0,0 +1,5 @@
+__all__ = ["DataladAOMICID1000", "DataladAOMICPIOP1", "DataladAOMICPIOP2"]
+
+from .id1000 import DataladAOMICID1000
+from .piop1 import DataladAOMICPIOP1
+from .piop2 import DataladAOMICPIOP2