junifer 0.0.6.dev154__py3-none-any.whl → 0.0.6.dev194__py3-none-any.whl

junifer/pipeline/pipeline_component_registry.py

@@ -0,0 +1,299 @@
+"""Provide a class for centralized pipeline component registry."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+import importlib
+from typing import TYPE_CHECKING, Dict, List, Mapping, Optional, Union
+
+from ..utils import logger, raise_error
+from .singleton import singleton
+
+
+if TYPE_CHECKING:
+    from ..datagrabber import BaseDataGrabber
+    from ..storage import BaseFeatureStorage
+    from .pipeline_step_mixin import PipelineStepMixin
+
+
+__all__ = ["PipelineComponentRegistry"]
+
+
+@singleton
+class PipelineComponentRegistry:
+    """Class for pipeline component registry.
+
+    This class is a singleton and is used for managing pipeline components.
+    It serves as a centralized registry for built-in and third-party pipeline
+    components like datagrabbers, datareaders, preprocessors, markers and
+    storage.
+
+    Attributes
+    ----------
+    steps : list of str
+        Valid pipeline steps.
+    components : dict
+        Registered components for valid pipeline steps.
+
+    """
+
+    def __init__(self) -> None:
+        """Initialize the class."""
+        # Valid steps for operation
+        self._steps = [
+            "datagrabber",
+            "datareader",
+            "preprocessing",
+            "marker",
+            "storage",
+        ]
+        # Step to sub-package mapping
+        self._step_to_subpkg_mappings = {
+            "datagrabber": "datagrabber",
+            "datareader": "datareader",
+            "preprocessing": "preprocess",
+            "marker": "markers",
+            "storage": "storage",
+        }
+        # Component registry for valid steps
+        self._components = {
+            "datagrabber": {
+                "HCP1200": "HCP1200",
+                "BaseDataGrabber": "BaseDataGrabber",
+                "DataladAOMICID1000": "DataladAOMICID1000",
+                "DataladAOMICPIOP1": "DataladAOMICPIOP1",
+                "DataladAOMICPIOP2": "DataladAOMICPIOP2",
+                "DataladDataGrabber": "DataladDataGrabber",
+                "DataladHCP1200": "DataladHCP1200",
+                "DMCC13Benchmark": "DMCC13Benchmark",
+                "MultipleDataGrabber": "MultipleDataGrabber",
+                "PatternDataGrabber": "PatternDataGrabber",
+                "PatternDataladDataGrabber": "PatternDataladDataGrabber",
+            },
+            "datareader": {
+                "DefaultDataReader": "DefaultDataReader",
+            },
+            "preprocessing": {
+                "BasePreprocessor": "BasePreprocessor",
+                "Smoothing": "Smoothing",
+                "SpaceWarper": "SpaceWarper",
+                "fMRIPrepConfoundRemover": "fMRIPrepConfoundRemover",
+            },
+            "marker": {
+                "ALFFParcels": "ALFFParcels",
+                "ALFFSpheres": "ALFFSpheres",
+                "BaseMarker": "BaseMarker",
+                "BrainPrint": "BrainPrint",
+                "CrossParcellationFC": "CrossParcellationFC",
+                "EdgeCentricFCParcels": "EdgeCentricFCParcels",
+                "EdgeCentricFCSpheres": "EdgeCentricFCSpheres",
+                "FunctionalConnectivityParcels": (
+                    "FunctionalConnectivityParcels"
+                ),
+                "FunctionalConnectivitySpheres": (
+                    "FunctionalConnectivitySpheres"
+                ),
+                "ParcelAggregation": "ParcelAggregation",
+                "ReHoParcels": "ReHoParcels",
+                "ReHoSpheres": "ReHoSpheres",
+                "RSSETSMarker": "RSSETSMarker",
+                "SphereAggregation": "SphereAggregation",
+                "TemporalSNRParcels": "TemporalSNRParcels",
+                "TemporalSNRSpheres": "TemporalSNRSpheres",
+            },
+            "storage": {
+                "BaseFeatureStorage": "BaseFeatureStorage",
+                "HDF5FeatureStorage": "HDF5FeatureStorage",
+                "PandasBaseFeatureStorage": "PandasBaseFeatureStorage",
+                "SQLiteFeatureStorage": "SQLiteFeatureStorage",
+            },
+        }
+
+    def _check_valid_step(self, step: str) -> None:
+        """Check if ``step`` is valid."""
+        if step not in self._steps:
+            raise_error(msg=f"Invalid step: {step}", klass=ValueError)
+
+    @property
+    def steps(self) -> List[str]:
+        """Get valid pipeline steps."""
+        return self._steps
+
+    @property
+    def components(self) -> Mapping[str, Mapping[str, Union[str, type]]]:
+        """Get registered components for valid pipeline steps."""
+        return self._components
+
+    def register(self, step: str, klass: type) -> None:
+        """Register ``klass`` under ``step``.
+
+        Parameters
+        ----------
+        step : str
+            Name of the pipeline step. For valid steps, check :meth:`.steps`.
+        klass : class
+            Class to be registered.
+
+        Raises
+        ------
+        ValueError
+            If the ``step`` is invalid.
+
+        """
+        # Verify step
+        self._check_valid_step(step)
+        # Log and register
+        name = klass.__name__
+        logger.info(f"Registering {name} in {step}")
+        self._components[step][name] = klass
+
+    def deregister(self, step: str, klass: type) -> None:
+        """De-register ``klass`` under ``step``.
+
+        Parameters
+        ----------
+        step : str
+            Name of the pipeline step. For valid steps, check :meth:`.steps`.
+        klass : class
+            Class to be de-registered.
+
+        Raises
+        ------
+        ValueError
+            If the ``step`` is invalid.
+
+        """
+        # Verify step
+        self._check_valid_step(step)
+        # Log and de-register
+        name = klass.__name__
+        logger.info(f"De-registering {name} in {step}")
+        _ = self._components[step].pop(name)
+
+    def step_components(self, step: str) -> List[str]:
+        """Get registered components for ``step``.
+
+        Parameters
+        ----------
+        step : str
+            Name of the pipeline step.
+
+        Returns
+        -------
+        list of str
+            List of registered component classes.
+
+        Raises
+        ------
+        ValueError
+            If the ``step`` is invalid.
+
+        """
+        # Verify step
+        self._check_valid_step(step)
+
+        return list(self._components[step].keys())
+
+    def get_class(self, step: str, name: str) -> type:
+        """Get the class registered under ``name`` for ``step``.
+
+        Parameters
+        ----------
+        step : str
+            Name of the pipeline step.
+        name : str
+            Name of the component.
+
+        Returns
+        -------
+        class
+            Registered class.
+
+        Raises
+        ------
+        ValueError
+            If the ``step`` or ``name`` is invalid.
+
+        """
+        # Verify step
+        self._check_valid_step(step)
+        # Verify step name
+        if name not in self._components[step]:
+            raise_error(msg=f"Invalid name: {name}", klass=ValueError)
+
+        # Check if first-time import, then import it
+        if isinstance(self._components[step][name], str):
+            klass = getattr(
+                importlib.import_module(
+                    f"junifer.{self._step_to_subpkg_mappings[step]}"
+                ),
+                name,
+            )
+        else:
+            klass = self._components[step][name]
+
+        return klass
+
+    def build_component_instance(
+        self,
+        step: str,
+        name: str,
+        baseclass: type,
+        init_params: Optional[Dict] = None,
+    ) -> Union["BaseDataGrabber", "PipelineStepMixin", "BaseFeatureStorage"]:
+        """Build an instance of class registered as ``name``.
+
+        Parameters
+        ----------
+        step : str
+            Name of the pipeline step.
+        name : str
+            Name of the component.
+        baseclass : class
+            Base class to be checked against.
+        init_params : dict or None, optional
+            Parameters to pass to the class constructor (default None).
+
+        Returns
+        -------
+        object
+            An instance of the class registered as ``name`` under ``step``.
+
+        Raises
+        ------
+        RuntimeError
+            If there is a problem creating the instance.
+        ValueError
+            If the created object with the given name is not a subclass of the
+            base class ``baseclass``.
+
+        """
+        # Set default init parameters
+        if init_params is None:
+            init_params = {}
+        # Get registered class
+        logger.debug(f"Building {step}/{name}")
+        klass = self.get_class(step=step, name=name)
+        logger.debug(f"\tClass: {klass.__name__}")
+        logger.debug(f"\tInit params: {init_params}")
+        try:
+            # Create instance of the class
+            object_ = klass(**init_params)
+        except (ValueError, TypeError) as e:
+            raise_error(
+                msg=f"Failed to create {step} ({name}). Error: {e}",
+                klass=RuntimeError,
+                exception=e,
+            )
+        # Verify created instance belongs to the base class
+        if not isinstance(object_, baseclass):
+            raise_error(
+                msg=(
+                    f"Invalid {step} ({object_.__class__.__name__}). "
+                    f"Must inherit from {baseclass.__name__}"
+                ),
+                klass=ValueError,
+            )
+        return object_

junifer/pipeline/tests/test_pipeline_component_registry.py

@@ -0,0 +1,201 @@
+"""Provide tests for PipelineComponentRegistry."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+import logging
+from abc import ABC
+from typing import Type
+
+import pytest
+
+from junifer.datagrabber.pattern import PatternDataGrabber
+from junifer.pipeline.pipeline_component_registry import (
+    PipelineComponentRegistry,
+)
+from junifer.storage import SQLiteFeatureStorage
+
+
+def test_pipeline_component_registry_singleton() -> None:
+    """Test that PipelineComponentRegistry is a singleton."""
+    registry_1 = PipelineComponentRegistry()
+    registry_2 = PipelineComponentRegistry()
+    assert id(registry_1) == id(registry_2)
+
+
+def test_pipeline_component_registry_register_invalid_step():
+    """Test invalid step name during component registration."""
+    with pytest.raises(ValueError, match="Invalid step:"):
+        PipelineComponentRegistry().register(step="foo", klass=str)
+
+
+def test_pipeline_component_registry_steps():
+    """Test steps for PipelineComponentRegistry."""
+    assert set(PipelineComponentRegistry().steps) == {
+        "datagrabber",
+        "datareader",
+        "preprocessing",
+        "marker",
+        "storage",
+    }
+
+
+def test_pipeline_component_registry_components():
+    """Test components for PipelineComponentRegistry."""
+    assert set(PipelineComponentRegistry().steps) == {
+        "datagrabber",
+        "datareader",
+        "preprocessing",
+        "marker",
+        "storage",
+    }
+
+
+@pytest.mark.parametrize(
+    "step, klass",
+    [
+        ("datagrabber", PatternDataGrabber),
+        ("storage", SQLiteFeatureStorage),
+    ],
+)
+def test_pipeline_component_registry_register(
+    caplog: pytest.LogCaptureFixture, step: str, klass: Type
+) -> None:
+    """Test register for PipelineComponentRegistry.
+
+    Parameters
+    ----------
+    caplog : pytest.LogCaptureFixture
+        The pytest.LogCaptureFixture object.
+    step : str
+        The parametrized name of the step.
+    klass : str
+        The parametrized name of the class.
+
+    """
+    with caplog.at_level(logging.INFO):
+        # Register
+        PipelineComponentRegistry().register(step=step, klass=klass)
+        # Check logging message
+        assert "Registering" in caplog.text
+
+
+@pytest.mark.parametrize(
+    "step, klass",
+    [
+        ("datagrabber", PatternDataGrabber),
+        ("storage", SQLiteFeatureStorage),
+    ],
+)
+def test_pipeline_component_registry_deregister(
+    caplog: pytest.LogCaptureFixture, step: str, klass: Type
+) -> None:
+    """Test de-register for PipelineComponentRegistry.
+
+    Parameters
+    ----------
+    caplog : pytest.LogCaptureFixture
+        The pytest.LogCaptureFixture object.
+    step : str
+        The parametrized name of the step.
+    klass : str
+        The parametrized name of the class.
+
+    """
+    with caplog.at_level(logging.INFO):
+        # Register
+        PipelineComponentRegistry().deregister(step=step, klass=klass)
+        # Check logging message
+        assert "De-registering" in caplog.text
+
+
+def test_pipeline_component_registry_step_components() -> None:
+    """Test step components for PipelineComponentRegistry."""
+    # Check absent name
+    assert "fizz" not in PipelineComponentRegistry().step_components(
+        step="datagrabber"
+    )
+
+    # Create new class
+    class fizz(str):
+        pass
+
+    # Register datagrabber
+    PipelineComponentRegistry().register(step="datagrabber", klass=fizz)
+    # Check registered component
+    assert "fizz" in PipelineComponentRegistry().step_components(
+        step="datagrabber"
+    )
+
+
+def test_pipeline_component_registry_get_class_invalid_name() -> None:
+    """Test get class invalid name for PipelineComponentRegistry."""
+    with pytest.raises(ValueError, match="Invalid name:"):
+        PipelineComponentRegistry().get_class(step="datagrabber", name="foo")
+
+
+def test_pipeline_component_registry_get_class():
+    """Test get class for PipelineComponentRegistry."""
+
+    # Create new class
+    class bar(str):
+        pass
+
+    # Register datagrabber
+    PipelineComponentRegistry().register(step="datagrabber", klass=bar)
+    # Get class
+    obj = PipelineComponentRegistry().get_class(step="datagrabber", name="bar")
+    assert isinstance(obj, type(bar))
+
+
+def test_pipeline_component_registry_build():
+    """Test component instance building for PipelineComponentRegistry."""
+    import numpy as np
+
+    # Define abstract base class
+    class SuperClass(ABC):
+        pass
+
+    # Define concrete class
+    class ConcreteClass(SuperClass):
+        def __init__(self, value=1):
+            self.value = value
+
+    # Register
+    PipelineComponentRegistry().register(
+        step="datagrabber", klass=ConcreteClass
+    )
+
+    # Build
+    obj = PipelineComponentRegistry().build_component_instance(
+        step="datagrabber", name="ConcreteClass", baseclass=SuperClass
+    )
+    assert isinstance(obj, ConcreteClass)
+    assert obj.value == 1
+
+    # Build
+    obj = PipelineComponentRegistry().build_component_instance(
+        step="datagrabber",
+        name="ConcreteClass",
+        baseclass=SuperClass,
+        init_params={"value": 2},
+    )
+    assert isinstance(obj, ConcreteClass)
+    assert obj.value == 2
+
+    # Check error
+    with pytest.raises(ValueError, match="Must inherit"):
+        PipelineComponentRegistry().build_component_instance(
+            step="datagrabber", name="ConcreteClass", baseclass=np.ndarray
+        )
+
+    # Check error
+    with pytest.raises(RuntimeError, match="Failed to create"):
+        PipelineComponentRegistry().build_component_instance(
+            step="datagrabber",
+            name="ConcreteClass",
+            baseclass=SuperClass,
+            init_params={"wrong": 2},
+        )

junifer/preprocess/confounds/fmriprep_confound_remover.py

@@ -22,7 +22,7 @@ from nilearn import image as nimg
 from nilearn._utils.niimg_conversions import check_niimg_4d
 
 from ...api.decorators import register_preprocessor
-from ...data import get_mask
+from ...data import get_data
 from ...utils import logger, raise_error
 from ..base import BasePreprocessor
 
@@ -546,8 +546,11 @@ class fMRIPrepConfoundRemover(BasePreprocessor):
         mask_img = None
         if self.masks is not None:
             logger.debug(f"Masking with {self.masks}")
-            mask_img = get_mask(
-                masks=self.masks, target_data=input, extra_input=extra_input
+            mask_img = get_data(
+                kind="mask",
+                names=self.masks,
+                target_data=input,
+                extra_input=extra_input,
             )
             # Return the BOLD mask and link it to the BOLD data type dict;
             # this allows to use "inherit" down the pipeline

junifer/testing/__init__.pyi

@@ -1,4 +1,4 @@
-__all__ = ["datagrabbers", "get_testing_data"]
+__all__ = ["datagrabbers", "registry", "get_testing_data"]
 
-from . import datagrabbers
+from . import datagrabbers, registry
 from .utils import get_testing_data

junifer/testing/registry.py

@@ -4,7 +4,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from ..pipeline.registry import register
+from ..pipeline import PipelineComponentRegistry
 from .datagrabbers import (
     OasisVBMTestingDataGrabber,
     PartlyCloudyTestingDataGrabber,
@@ -13,20 +13,17 @@ from .datagrabbers import (
 
 
 # Register testing DataGrabbers
-register(
+PipelineComponentRegistry().register(
     step="datagrabber",
-    name="OasisVBMTestingDataGrabber",
     klass=OasisVBMTestingDataGrabber,
 )
 
-register(
+PipelineComponentRegistry().register(
     step="datagrabber",
-    name="SPMAuditoryTestingDataGrabber",
     klass=SPMAuditoryTestingDataGrabber,
 )
 
-register(
+PipelineComponentRegistry().register(
     step="datagrabber",
-    name="PartlyCloudyTestingDataGrabber",
     klass=PartlyCloudyTestingDataGrabber,
 )

junifer/testing/tests/test_testing_registry.py

@@ -1,24 +1,16 @@
 """Provide tests for testing registry."""
 
-import importlib
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
 
-from junifer.pipeline.registry import get_step_names
+from junifer.pipeline import PipelineComponentRegistry
 
 
 def test_testing_registry() -> None:
     """Test testing registry."""
-    import junifer
-
-    importlib.reload(junifer.pipeline.registry)
-    importlib.reload(junifer)
-
-    assert "OasisVBMTestingDataGrabber" not in get_step_names("datagrabber")
-    assert "SPMAuditoryTestingDataGrabber" not in get_step_names("datagrabber")
-    assert "PartlyCloudyTestingDataGrabber" not in get_step_names(
-        "datagrabber"
-    )
-    importlib.reload(junifer.testing.registry)  # type: ignore
-
-    assert "OasisVBMTestingDataGrabber" in get_step_names("datagrabber")
-    assert "SPMAuditoryTestingDataGrabber" in get_step_names("datagrabber")
-    assert "PartlyCloudyTestingDataGrabber" in get_step_names("datagrabber")
+    assert {
+        "OasisVBMTestingDataGrabber",
+        "SPMAuditoryTestingDataGrabber",
+        "PartlyCloudyTestingDataGrabber",
+    }.issubset(set(PipelineComponentRegistry().step_components("datagrabber")))

{junifer-0.0.6.dev154.dist-info → junifer-0.0.6.dev194.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: junifer
-Version: 0.0.6.dev154
+Version: 0.0.6.dev194
 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>