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

junifer/pipeline/pipeline_step_mixin.py

@@ -44,7 +44,7 @@ class PipelineStepMixin:
         raise_error(
             msg="Concrete classes need to implement validate_input().",
             klass=NotImplementedError,
-        )
+        )  # pragma: no cover
 
     def get_output_type(self, input_type: str) -> str:
         """Get output type.
@@ -63,10 +63,11 @@ class PipelineStepMixin:
         raise_error(
             msg="Concrete classes need to implement get_output_type().",
             klass=NotImplementedError,
-        )
+        )  # pragma: no cover
 
     def _fit_transform(
-        self, input: Dict[str, Dict], **kwargs: Any
+        self,
+        input: Dict[str, Dict],
     ) -> Dict[str, Dict]:
         """Fit and transform.
 
@@ -74,8 +75,6 @@ class PipelineStepMixin:
         ----------
         input : dict
             The Junifer Data object.
-        **kwargs : dict
-            Extra keyword arguments.
 
         Returns
         -------
@@ -86,7 +85,7 @@ class PipelineStepMixin:
         raise_error(
             msg="Concrete classes need to implement _fit_transform().",
             klass=NotImplementedError,
-        )
+        )  # pragma: no cover
 
     def validate(self, input: List[str]) -> List[str]:
         """Validate the the pipeline step.
@@ -101,44 +100,109 @@ class PipelineStepMixin:
         list of str
             The output of the pipeline step.
 
-        Raises
-        ------
-        ValueError
-            If the pipeline step object is missing dependencies required for
-            its working or if the input does not have the required data.
-
         """
-        # Check if _DEPENDENCIES attribute is found;
-        # (markers and preprocessors will have them but not datareaders
-        # as of now)
-        dependencies_not_found = []
-        if hasattr(self, "_DEPENDENCIES"):
-            # Check if dependencies are importable
-            for dependency in self._DEPENDENCIES:  # type: ignore
-                # First perform an easy check
-                if find_spec(dependency) is None:
-                    # Then check mapped names
-                    if dependency not in list(
-                        chain.from_iterable(packages_distributions().values())
-                    ):
-                        dependencies_not_found.append(dependency)
-        # Raise error if any dependency is not found
-        if dependencies_not_found:
-            raise_error(
-                msg=f"{dependencies_not_found} are not installed but are "
-                "required for using {self.name}.",
-                klass=ImportError,
-            )
-        # Check if _EXT_DEPENDENCIES attribute is found;
-        # (some markers might have them like ReHo-family)
-        if hasattr(self, "_EXT_DEPENDENCIES"):
-            for dependency in self._EXT_DEPENDENCIES:  # type: ignore
-                out = check_ext_dependencies(**dependency)
-                if getattr(self, f"use_{dependency['name']}", None) is None:
-                    # Set attribute for using external tools
-                    setattr(self, f"use_{dependency['name']}", out)
 
+        def _check_dependencies(obj) -> None:
+            """Check obj._DEPENDENCIES.
+
+            Parameters
+            ----------
+            obj : object
+                Object to check _DEPENDENCIES of.
+
+            Raises
+            ------
+            ImportError
+                If the pipeline step object is missing dependencies required
+                for its working.
+
+            """
+            # Check if _DEPENDENCIES attribute is found;
+            # (markers and preprocessors will have them but not datareaders
+            # as of now)
+            dependencies_not_found = []
+            if hasattr(obj, "_DEPENDENCIES"):
+                # Check if dependencies are importable
+                for dependency in obj._DEPENDENCIES:
+                    # First perform an easy check
+                    if find_spec(dependency) is None:
+                        # Then check mapped names
+                        if dependency not in list(
+                            chain.from_iterable(
+                                packages_distributions().values()
+                            )
+                        ):
+                            dependencies_not_found.append(dependency)
+            # Raise error if any dependency is not found
+            if dependencies_not_found:
+                raise_error(
+                    msg=(
+                        f"{dependencies_not_found} are not installed but are "
+                        f"required for using {obj.__class__.__name__}."
+                    ),
+                    klass=ImportError,
+                )
+
+        def _check_ext_dependencies(obj) -> None:
+            """Check obj._EXT_DEPENDENCIES.
+
+            Parameters
+            ----------
+            obj : object
+                Object to check _EXT_DEPENDENCIES of.
+
+            """
+            # Check if _EXT_DEPENDENCIES attribute is found;
+            # (some markers and preprocessors might have them)
+            if hasattr(obj, "_EXT_DEPENDENCIES"):
+                for dependency in obj._EXT_DEPENDENCIES:
+                    check_ext_dependencies(**dependency)
+
+        def _check_conditional_dependencies(obj) -> None:
+            """Check obj._CONDITIONAL_DEPENDENCIES.
+
+            Parameters
+            ----------
+            obj : object
+                Object to check _CONDITIONAL_DEPENDENCIES of.
+
+            Raises
+            ------
+            AttributeError
+                If the pipeline step object does not have `using` as a
+                constructor parameter.
+
+            """
+            # Check if _CONDITIONAL_DEPENDENCIES attribute is found;
+            # (some markers and preprocessors might have them)
+            if hasattr(obj, "_CONDITIONAL_DEPENDENCIES"):
+                if not hasattr(obj, "using"):
+                    raise_error(
+                        msg=(
+                            f"The pipeline step: {obj.__class__.__name__} has "
+                            "`_CONDITIONAL_DEPENDENCIES` but does not have "
+                            "`using` as a constructor parameter"
+                        ),
+                        klass=AttributeError,
+                    )
+                else:
+                    for dependency in obj._CONDITIONAL_DEPENDENCIES:
+                        if dependency["using"] == obj.using:
+                            depends_on = dependency["depends_on"]
+                            # Check dependencies
+                            _check_dependencies(depends_on)
+                            # Check external dependencies
+                            _check_ext_dependencies(depends_on)
+
+        # Check dependencies
+        _check_dependencies(self)
+        # Check external dependencies
+        _check_ext_dependencies(self)
+        # Check conditional dependencies
+        _check_conditional_dependencies(self)
+        # Validate input
         fit_input = self.validate_input(input=input)
+        # Validate output type
         outputs = [self.get_output_type(t_input) for t_input in fit_input]
         return outputs
 

junifer/pipeline/registry.py

@@ -41,6 +41,11 @@ def register(step: str, name: str, klass: type) -> None:
     klass : class
         Class to be registered.
 
+    Raises
+    ------
+    ValueError
+        If the ``step`` is invalid.
+
     """
     # Verify step
     if step not in _VALID_STEPS:
@@ -63,6 +68,11 @@ def get_step_names(step: str) -> List[str]:
     list
         List of registered function names.
 
+    Raises
+    ------
+    ValueError
+        If the ``step`` is invalid.
+
     """
     # Verify step
     if step not in _VALID_STEPS:
@@ -86,6 +96,11 @@ def get_class(step: str, name: str) -> type:
     class
         Registered function class.
 
+    Raises
+    ------
+    ValueError
+        If the ``step`` or ``name`` is invalid.
+
     """
     # Verify step
     if step not in _VALID_STEPS:
@@ -123,6 +138,8 @@ def build(
 
     Raises
     ------
+    RuntimeError
+        If there is a problem creating the instance.
     ValueError
         If the created object with the given name is not an instance of the
         base class.

junifer/pipeline/singleton.py

@@ -0,0 +1,45 @@
+"""Provide a singleton class to be used by pipeline components."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from typing import Any, Dict, Type
+
+
+def singleton(cls: Type) -> Type:
+    """Make a class singleton.
+
+    Parameters
+    ----------
+    cls : class
+        The class to designate as singleton.
+
+    Returns
+    -------
+    class
+        The only instance of the class.
+
+    """
+    instances: Dict = {}
+
+    def get_instance(*args: Any, **kwargs: Any) -> Type:
+        """Get the only instance for a class.
+
+        Parameters
+        ----------
+        *args : tuple
+            The positional arguments to pass to the class.
+        **kwargs : dict
+            The keyword arguments to pass to the class.
+
+        Returns
+        -------
+        class
+            The only instance of the class.
+
+        """
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance

junifer/pipeline/tests/test_pipeline_step_mixin.py

@@ -1,11 +1,11 @@
-"""Provide tests for pipeline mixin."""
+"""Provide tests for PipelineStepMixin."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 import warnings
-from typing import ClassVar, Dict, List, Set, Union
+from typing import ClassVar, Dict, List, Set, Type, Union
 
 import pytest
 
@@ -13,24 +13,13 @@ from junifer.pipeline.pipeline_step_mixin import PipelineStepMixin
 from junifer.pipeline.utils import _check_afni
 
 
-def test_PipelineStepMixin() -> None:
-    """Test PipelineStepMixin."""
-    mixin = PipelineStepMixin()
-    with pytest.raises(NotImplementedError):
-        mixin.validate_input([])
-    with pytest.raises(NotImplementedError):
-        mixin.get_output_type("")
-    with pytest.raises(NotImplementedError):
-        mixin._fit_transform({})
-
-
-def test_pipeline_step_mixin_validate_correct_dependencies() -> None:
-    """Test validate with correct dependencies."""
+def test_PipelineStepMixin_correct_dependencies() -> None:
+    """Test fit-transform with correct dependencies."""
 
     class CorrectMixer(PipelineStepMixin):
         """Test class for validation."""
 
-        _DEPENDENCIES: ClassVar[Set[str]] = {"setuptools"}
+        _DEPENDENCIES: ClassVar[Set[str]] = {"math"}
 
         def validate_input(self, input: List[str]) -> List[str]:
             return input
@@ -38,15 +27,15 @@ def test_pipeline_step_mixin_validate_correct_dependencies() -> None:
         def get_output_type(self, input_type: str) -> str:
             return input_type
 
-        def fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
             return {"input": input}
 
     mixer = CorrectMixer()
-    mixer.validate([])
+    mixer.fit_transform({})
 
 
-def test_pipeline_step_mixin_validate_incorrect_dependencies() -> None:
-    """Test validate with incorrect dependencies."""
+def test_PipelineStepMixin_incorrect_dependencies() -> None:
+    """Test fit-transform with incorrect dependencies."""
 
     class IncorrectMixer(PipelineStepMixin):
         """Test class for validation."""
@@ -59,26 +48,24 @@ def test_pipeline_step_mixin_validate_incorrect_dependencies() -> None:
         def get_output_type(self, input_type: str) -> str:
             return input_type
 
-        def fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
             return {"input": input}
 
     mixer = IncorrectMixer()
     with pytest.raises(ImportError, match="not installed"):
-        mixer.validate([])
+        mixer.fit_transform({})
 
 
 @pytest.mark.skipif(
-    _check_afni() is False, reason="requires afni to be in PATH"
+    _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_pipeline_step_mixin_validate_correct_ext_dependencies() -> None:
-    """Test validate with correct external dependencies."""
+def test_PipelineStepMixin_correct_ext_dependencies() -> None:
+    """Test fit-transform with correct external dependencies."""
 
     class CorrectMixer(PipelineStepMixin):
         """Test class for validation."""
 
-        _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, bool]]]] = [
-            {"name": "afni", "optional": False}
-        ]
+        _EXT_DEPENDENCIES: ClassVar[List[Dict[str, str]]] = [{"name": "afni"}]
 
         def validate_input(self, input: List[str]) -> List[str]:
             return input
@@ -86,25 +73,25 @@ def test_pipeline_step_mixin_validate_correct_ext_dependencies() -> None:
         def get_output_type(self, input_type: str) -> str:
             return input_type
 
-        def fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
             return {"input": input}
 
     mixer = CorrectMixer()
-    mixer.validate([])
+    mixer.fit_transform({})
 
 
 @pytest.mark.skipif(
-    _check_afni() is False, reason="requires afni to be in PATH"
+    _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_pipeline_step_mixin_validate_ext_deps_correct_commands() -> None:
-    """Test validate with correct external dependencies' correct commands."""
+def test_PipelineStepMixin_ext_deps_correct_commands() -> None:
+    """Test fit-transform with correct external dependency commands."""
 
     class CorrectMixer(PipelineStepMixin):
         """Test class for validation."""
 
-        _EXT_DEPENDENCIES: ClassVar[
-            List[Dict[str, Union[str, bool, List[str]]]]
-        ] = [{"name": "afni", "optional": False, "commands": ["3dReHo"]}]
+        _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+            {"name": "afni", "commands": ["3dReHo"]}
+        ]
 
         def validate_input(self, input: List[str]) -> List[str]:
             return input
@@ -112,27 +99,27 @@ def test_pipeline_step_mixin_validate_ext_deps_correct_commands() -> None:
         def get_output_type(self, input_type: str) -> str:
             return input_type
 
-        def fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
             return {"input": input}
 
     mixer = CorrectMixer()
     with warnings.catch_warnings():
         warnings.simplefilter("error")
-        mixer.validate([])
+        mixer.fit_transform({})
 
 
 @pytest.mark.skipif(
-    _check_afni() is False, reason="requires afni to be in PATH"
+    _check_afni() is False, reason="requires AFNI to be in PATH"
 )
-def test_pipeline_step_mixin_validate_ext_deps_incorrect_commands() -> None:
-    """Test validate with correct external dependencies' incorrect commands."""
+def test_PipelineStepMixin_ext_deps_incorrect_commands() -> None:
+    """Test fit-transform with inccorrect external dependency commands."""
 
     class CorrectMixer(PipelineStepMixin):
         """Test class for validation."""
 
-        _EXT_DEPENDENCIES: ClassVar[
-            List[Dict[str, Union[str, bool, List[str]]]]
-        ] = [{"name": "afni", "optional": False, "commands": ["3d"]}]
+        _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+            {"name": "afni", "commands": ["3d"]}
+        ]
 
         def validate_input(self, input: List[str]) -> List[str]:
             return input
@@ -140,16 +127,16 @@ def test_pipeline_step_mixin_validate_ext_deps_incorrect_commands() -> None:
         def get_output_type(self, input_type: str) -> str:
             return input_type
 
-        def fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
             return {"input": input}
 
     mixer = CorrectMixer()
     with pytest.warns(RuntimeWarning, match="AFNI is installed"):
-        mixer.validate([])
+        mixer.fit_transform({})
 
 
-def test_pipeline_step_mixin_validate_incorrect_ext_dependencies() -> None:
-    """Test validate with incorrect external dependencies."""
+def test_PipelineStepMixin_incorrect_ext_dependencies() -> None:
+    """Test fit-transform with incorrect external dependencies."""
 
     class IncorrectMixer(PipelineStepMixin):
         """Test class for validation."""
@@ -164,9 +151,110 @@ def test_pipeline_step_mixin_validate_incorrect_ext_dependencies() -> None:
         def get_output_type(self, input_type: str) -> str:
             return input_type
 
-        def fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+            return {"input": input}
+
+    mixer = IncorrectMixer()
+    with pytest.raises(ValueError, match="Invalid value"):
+        mixer.fit_transform({})
+
+
+def test_PipelineStepMixin_correct_conditional_dependencies() -> None:
+    """Test fit-transform with correct conditional dependencies."""
+
+    class Dependency:
+        _DEPENDENCIES: ClassVar[Set[str]] = {"math"}
+
+    class CorrectMixer(PipelineStepMixin):
+        """Test class for validation."""
+
+        _CONDITIONAL_DEPENDENCIES: ClassVar[
+            List[Dict[str, Union[str, Type]]]
+        ] = [
+            {
+                "using": "math",
+                "depends_on": Dependency,
+            },
+        ]
+
+        using = "math"
+
+        def validate_input(self, input: List[str]) -> List[str]:
+            return input
+
+        def get_output_type(self, input_type: str) -> str:
+            return input_type
+
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+            return {"input": input}
+
+    mixer = CorrectMixer()
+    mixer.fit_transform({})
+
+
+def test_PipelineStepMixin_incorrect_conditional_dependencies() -> None:
+    """Test fit-transform with incorrect conditional dependencies."""
+
+    class Dependency:
+        _DEPENDENCIES: ClassVar[Set[str]] = {"math"}
+
+    class IncorrectMixer(PipelineStepMixin):
+        """Test class for validation."""
+
+        _CONDITIONAL_DEPENDENCIES: ClassVar[
+            List[Dict[str, Union[str, Type]]]
+        ] = [
+            {
+                "using": "math",
+                "depends_on": Dependency,
+            },
+        ]
+
+        def validate_input(self, input: List[str]) -> List[str]:
+            return input
+
+        def get_output_type(self, input_type: str) -> str:
+            return input_type
+
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
             return {"input": input}
 
     mixer = IncorrectMixer()
-    with pytest.raises(ValueError, match="too adventurous"):
-        mixer.validate([])
+    with pytest.raises(AttributeError, match="`using`"):
+        mixer.fit_transform({})
+
+
+@pytest.mark.skipif(
+    _check_afni() is False, reason="requires AFNI to be in PATH"
+)
+def test_PipelineStepMixin_correct_conditional_ext_dependencies() -> None:
+    """Test fit-transform with correct conditional external dependencies."""
+
+    class ExternalDependency:
+        _EXT_DEPENDENCIES: ClassVar[List[Dict[str, str]]] = [{"name": "afni"}]
+
+    class CorrectMixer(PipelineStepMixin):
+        """Test class for validation."""
+
+        _CONDITIONAL_DEPENDENCIES: ClassVar[
+            List[Dict[str, Union[str, Type]]]
+        ] = [
+            {
+                "using": "afni",
+                "depends_on": ExternalDependency,
+            },
+        ]
+
+        using = "afni"
+
+        def validate_input(self, input: List[str]) -> List[str]:
+            return input
+
+        def get_output_type(self, input_type: str) -> str:
+            return input_type
+
+        def _fit_transform(self, input: Dict[str, Dict]) -> Dict[str, Dict]:
+            return {"input": input}
+
+    mixer = CorrectMixer()
+    mixer.fit_transform({})

junifer/pipeline/tests/test_update_meta_mixin.py

@@ -38,6 +38,7 @@ def test_UpdateMetaMixin(
         The dependencies of the pipeline step.
     expected : set
         The expected dependencies.
+
     """
 
     class TestUpdateMetaMixin(UpdateMetaMixin):

junifer/pipeline/tests/test_workdir_manager.py

@@ -0,0 +1,104 @@
+"""Provide tests for WorkDirManager."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from pathlib import Path
+
+from junifer.pipeline import WorkDirManager
+
+
+def test_workdir_manager_singleton() -> None:
+    """Test that WorkDirManager is a singleton."""
+    workdir_mgr_1 = WorkDirManager()
+    workdir_mgr_2 = WorkDirManager()
+    assert id(workdir_mgr_1) == id(workdir_mgr_2)
+
+
+def test_workdir_manager_workdir(tmp_path: Path) -> None:
+    """Test WorkDirManager correctly sets workdir.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    workdir_mgr = WorkDirManager()
+    workdir_mgr.workdir = tmp_path
+    assert workdir_mgr.workdir == tmp_path
+
+
+def test_workdir_manager_get_and_delete_element_tempdir(
+    tmp_path: Path,
+) -> None:
+    """Test WorkDirManager gets and deletes element tempdirs correctly.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    workdir_mgr = WorkDirManager()
+    workdir_mgr.workdir = tmp_path
+    # Check no element directory
+    assert workdir_mgr.elementdir is None
+
+    element_tempdir = workdir_mgr.get_element_tempdir()
+    # Should create a temporary directory
+    assert workdir_mgr.elementdir is not None
+
+    workdir_mgr.delete_element_tempdir(element_tempdir)
+    workdir_mgr._cleanup()
+    # Should remove temporary directory
+    assert workdir_mgr.elementdir is None
+
+
+def test_workdir_manager_cleanup_elementdir(
+    tmp_path: Path,
+) -> None:
+    """Test WorkDirManager cleans up element directory correctly.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    workdir_mgr = WorkDirManager()
+    workdir_mgr.workdir = tmp_path
+    # Check no element directory
+    assert workdir_mgr.elementdir is None
+
+    workdir_mgr.get_element_tempdir()
+    # Should create a temporary directory
+    assert workdir_mgr.elementdir is not None
+
+    workdir_mgr.cleanup_elementdir()
+    # Should remove temporary directory
+    assert workdir_mgr.elementdir is None
+
+
+def test_workdir_manager_get_and_delete_tempdir(tmp_path: Path) -> None:
+    """Test WorkDirManager gets and deletes temporary directories correctly.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    workdir_mgr = WorkDirManager()
+    workdir_mgr.workdir = tmp_path
+    # Check no root temporary directory
+    assert workdir_mgr.root_tempdir is None
+
+    tempdir = workdir_mgr.get_tempdir()
+    # Should create a temporary directory
+    assert workdir_mgr.root_tempdir is not None
+
+    workdir_mgr.delete_tempdir(tempdir)
+    workdir_mgr._cleanup()
+    # Should remove temporary directory
+    assert workdir_mgr.root_tempdir is None