junifer 0.0.7.dev332__py3-none-any.whl → 0.0.8__py3-none-any.whl

junifer/markers/complexity/tests/test_perm_entropy.py

@@ -11,66 +11,78 @@ import pytest
 
 pytest.importorskip("neurokit2")
 
+
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
 from junifer.markers.complexity import PermEntropy
-from junifer.pipeline.utils import _check_ants
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
 from junifer.testing.datagrabbers import (
-    SPMAuditoryTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
 )
 
 
+pytestmark = pytest.mark.external
+
+
 # Set parcellation
-PARCELLATION = "Schaefer100x17"
+PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_compute() -> None:
-    """Test PermEntropy compute()."""
-    with SPMAuditoryTestingDataGrabber() as dg:
+@pytest.fixture(scope="module")
+def element_data() -> dict:
+    """Load the data element once for all tests in the module.
+
+    Returns
+    -------
+    dict
+        The element data.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
         # Fetch element
-        element = dg["sub001"]
+        element = dg["sub-01"]
         # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = PermEntropy(parcellation=PARCELLATION)
-        # Compute the marker
-        feature_map = marker.fit_transform(element_data)
-        # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        return DefaultDataReader().fit_transform(element)
+
+
+def test_compute(element_data: dict) -> None:
+    """Test PermEntropy compute().
+
+    Parameters
+    ----------
+    element_data : dict
+        The element data.
+
+    """
+    # Initialize the marker
+    marker = PermEntropy(parcellation=PARCELLATION)
+    # Compute the marker
+    feature_map = marker.fit_transform(element_data)
+    # Assert the dimension of timeseries
+    assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_storage_type() -> None:
     """Test PermEntropy storage_type."""
     assert "vector" == PermEntropy(parcellation=PARCELLATION).storage_type(
-        input_type="BOLD", output_feature="complexity"
+        input_type=DataType.BOLD, output_feature="complexity"
     )
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_store(tmp_path: Path) -> None:
+def test_store(element_data: dict, tmp_path: Path) -> None:
     """Test PermEntropy store().
 
     Parameters
     ----------
+    element_data : dict
+        The element data.
     tmp_path : pathlib.Path
         The path to the test directory.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Fetch element
-        element = dg["sub001"]
-        # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = PermEntropy(parcellation=PARCELLATION)
-        # Create storage
-        storage = SQLiteFeatureStorage(
-            uri=tmp_path / "test_perm_entropy.sqlite"
-        )
-        # Compute the marker and store
-        marker.fit_transform(input=element_data, storage=storage)
+    # Initialize the marker
+    marker = PermEntropy(parcellation=PARCELLATION)
+    # Create storage
+    storage = HDF5FeatureStorage(uri=tmp_path / "test_perm_entropy.hdf5")
+    # Compute the marker and store
+    marker.fit_transform(input=element_data, storage=storage)

junifer/markers/complexity/tests/test_range_entropy.py

@@ -12,66 +12,77 @@ import pytest
 pytest.importorskip("neurokit2")
 
 
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
 from junifer.markers.complexity import RangeEntropy
-from junifer.pipeline.utils import _check_ants
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
 from junifer.testing.datagrabbers import (
-    SPMAuditoryTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
 )
 
 
+pytestmark = pytest.mark.external
+
+
 # Set parcellation
-PARCELLATION = "Schaefer100x17"
+PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_compute() -> None:
-    """Test RangeEntropy compute()."""
-    with SPMAuditoryTestingDataGrabber() as dg:
+@pytest.fixture(scope="module")
+def element_data() -> dict:
+    """Load the data element once for all tests in the module.
+
+    Returns
+    -------
+    dict
+        The element data.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
         # Fetch element
-        element = dg["sub001"]
+        element = dg["sub-01"]
         # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = RangeEntropy(parcellation=PARCELLATION)
-        # Compute the marker
-        feature_map = marker.fit_transform(element_data)
-        # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        return DefaultDataReader().fit_transform(element)
+
+
+def test_compute(element_data: dict) -> None:
+    """Test RangeEntropy compute().
+
+    Parameters
+    ----------
+    element_data : dict
+        The element data.
+
+    """
+    # Initialize the marker
+    marker = RangeEntropy(parcellation=PARCELLATION)
+    # Compute the marker
+    feature_map = marker.fit_transform(element_data)
+    # Assert the dimension of timeseries
+    assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_storage_type() -> None:
     """Test RangeEntropy storage_type."""
     assert "vector" == RangeEntropy(parcellation=PARCELLATION).storage_type(
-        input_type="BOLD", output_feature="complexity"
+        input_type=DataType.BOLD, output_feature="complexity"
     )
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_store(tmp_path: Path) -> None:
+def test_store(element_data: dict, tmp_path: Path) -> None:
     """Test RangeEntropy store().
 
     Parameters
     ----------
+    element_data : dict
+        The element data.
     tmp_path : pathlib.Path
         The path to the test directory.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Fetch element
-        element = dg["sub001"]
-        # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = RangeEntropy(parcellation=PARCELLATION)
-        # Create storage
-        storage = SQLiteFeatureStorage(
-            uri=tmp_path / "test_range_entropy.sqlite"
-        )
-        # Compute the marker and store
-        marker.fit_transform(input=element_data, storage=storage)
+    # Initialize the marker
+    marker = RangeEntropy(parcellation=PARCELLATION)
+    # Create storage
+    storage = HDF5FeatureStorage(uri=tmp_path / "test_range_entropy.hdf5")
+    # Compute the marker and store
+    marker.fit_transform(input=element_data, storage=storage)

junifer/markers/complexity/tests/test_range_entropy_auc.py

@@ -12,66 +12,77 @@ import pytest
 pytest.importorskip("neurokit2")
 
 
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
 from junifer.markers.complexity import RangeEntropyAUC
-from junifer.pipeline.utils import _check_ants
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
 from junifer.testing.datagrabbers import (
-    SPMAuditoryTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
 )
 
 
+pytestmark = pytest.mark.external
+
+
 # Set parcellation
-PARCELLATION = "Schaefer100x17"
+PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_compute() -> None:
-    """Test RangeEntropyAUC compute()."""
-    with SPMAuditoryTestingDataGrabber() as dg:
+@pytest.fixture(scope="module")
+def element_data() -> dict:
+    """Load the data element once for all tests in the module.
+
+    Returns
+    -------
+    dict
+        The element data.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
         # Fetch element
-        element = dg["sub001"]
+        element = dg["sub-01"]
         # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = RangeEntropyAUC(parcellation=PARCELLATION)
-        # Compute the marker
-        feature_map = marker.fit_transform(element_data)
-        # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        return DefaultDataReader().fit_transform(element)
+
+
+def test_compute(element_data: dict) -> None:
+    """Test RangeEntropyAUC compute().
+
+    Parameters
+    ----------
+    element_data : dict
+        The element data.
+
+    """
+    # Initialize the marker
+    marker = RangeEntropyAUC(parcellation=PARCELLATION)
+    # Compute the marker
+    feature_map = marker.fit_transform(element_data)
+    # Assert the dimension of timeseries
+    assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_storage_type() -> None:
     """Test RangeEntropyAUC storage_type."""
     assert "vector" == RangeEntropyAUC(parcellation=PARCELLATION).storage_type(
-        input_type="BOLD", output_feature="complexity"
+        input_type=DataType.BOLD, output_feature="complexity"
     )
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_store(tmp_path: Path) -> None:
+def test_store(element_data: dict, tmp_path: Path) -> None:
     """Test RangeEntropyAUC store().
 
     Parameters
     ----------
+    element_data : dict
+        The element data.
     tmp_path : pathlib.Path
         The path to the test directory.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Fetch element
-        element = dg["sub001"]
-        # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = RangeEntropyAUC(parcellation=PARCELLATION)
-        # Create storage
-        storage = SQLiteFeatureStorage(
-            uri=tmp_path / "test_range_entropy_auc.sqlite"
-        )
-        # Compute the marker and store
-        marker.fit_transform(input=element_data, storage=storage)
+    # Initialize the marker
+    marker = RangeEntropyAUC(parcellation=PARCELLATION)
+    # Create storage
+    storage = HDF5FeatureStorage(uri=tmp_path / "test_range_entropy_auc.hdf5")
+    # Compute the marker and store
+    marker.fit_transform(input=element_data, storage=storage)

junifer/markers/complexity/tests/test_sample_entropy.py

@@ -11,66 +11,78 @@ import pytest
 
 pytest.importorskip("neurokit2")
 
+
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
 from junifer.markers.complexity import SampleEntropy
-from junifer.pipeline.utils import _check_ants
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
 from junifer.testing.datagrabbers import (
-    SPMAuditoryTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
 )
 
 
+pytestmark = pytest.mark.external
+
+
 # Set parcellation
-PARCELLATION = "Schaefer100x17"
+PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_compute() -> None:
-    """Test SampleEntropy compute()."""
-    with SPMAuditoryTestingDataGrabber() as dg:
+@pytest.fixture(scope="module")
+def element_data() -> dict:
+    """Load the data element once for all tests in the module.
+
+    Returns
+    -------
+    dict
+        The element data.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
         # Fetch element
-        element = dg["sub001"]
+        element = dg["sub-01"]
         # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = SampleEntropy(parcellation=PARCELLATION)
-        # Compute the marker
-        feature_map = marker.fit_transform(element_data)
-        # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        return DefaultDataReader().fit_transform(element)
+
+
+def test_compute(element_data: dict) -> None:
+    """Test SampleEntropy compute().
+
+    Parameters
+    ----------
+    element_data : dict
+        The element data.
+
+    """
+    # Initialize the marker
+    marker = SampleEntropy(parcellation=PARCELLATION)
+    # Compute the marker
+    feature_map = marker.fit_transform(element_data)
+    # Assert the dimension of timeseries
+    assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_storage_type() -> None:
     """Test SampleEntropy storage_type."""
     assert "vector" == SampleEntropy(parcellation=PARCELLATION).storage_type(
-        input_type="BOLD", output_feature="complexity"
+        input_type=DataType.BOLD, output_feature="complexity"
     )
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_store(tmp_path: Path) -> None:
+def test_store(element_data: dict, tmp_path: Path) -> None:
     """Test SampleEntropy store().
 
     Parameters
     ----------
+    element_data : dict
+        The element data.
     tmp_path : pathlib.Path
         The path to the test directory.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Fetch element
-        element = dg["sub001"]
-        # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = SampleEntropy(parcellation=PARCELLATION)
-        # Create storage
-        storage = SQLiteFeatureStorage(
-            uri=tmp_path / "test_sample_entropy.sqlite"
-        )
-        # Compute the marker and store
-        marker.fit_transform(input=element_data, storage=storage)
+    # Initialize the marker
+    marker = SampleEntropy(parcellation=PARCELLATION)
+    # Create storage
+    storage = HDF5FeatureStorage(uri=tmp_path / "test_sample_entropy.hdf5")
+    # Compute the marker and store
+    marker.fit_transform(input=element_data, storage=storage)

junifer/markers/complexity/tests/test_weighted_perm_entropy.py

@@ -11,66 +11,80 @@ import pytest
 
 pytest.importorskip("neurokit2")
 
+
+from junifer.datagrabber import DataType
 from junifer.datareader import DefaultDataReader
 from junifer.markers.complexity import WeightedPermEntropy
-from junifer.pipeline.utils import _check_ants
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
 from junifer.testing.datagrabbers import (
-    SPMAuditoryTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
 )
 
 
+pytestmark = pytest.mark.external
+
+
 # Set parcellation
-PARCELLATION = "Schaefer100x17"
+PARCELLATION = "TianxS1x3TxMNInonlinear2009cAsym"
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_compute() -> None:
-    """Test WeightedPermEntropy compute()."""
-    with SPMAuditoryTestingDataGrabber() as dg:
+@pytest.fixture(scope="module")
+def element_data() -> dict:
+    """Load the data element once for all tests in the module.
+
+    Returns
+    -------
+    dict
+        The element data.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
         # Fetch element
-        element = dg["sub001"]
+        element = dg["sub-01"]
         # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = WeightedPermEntropy(parcellation=PARCELLATION)
-        # Compute the marker
-        feature_map = marker.fit_transform(element_data)
-        # Assert the dimension of timeseries
-        assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
+        return DefaultDataReader().fit_transform(element)
+
+
+def test_compute(element_data: dict) -> None:
+    """Test WeightedPermEntropy compute().
+
+    Parameters
+    ----------
+    element_data : dict
+        The element data.
+
+    """
+    # Initialize the marker
+    marker = WeightedPermEntropy(parcellation=PARCELLATION)
+    # Compute the marker
+    feature_map = marker.fit_transform(element_data)
+    # Assert the dimension of timeseries
+    assert feature_map["BOLD"]["complexity"]["data"].ndim == 2
 
 
 def test_storage_type() -> None:
     """Test WeightedPermEntropy storage_type."""
     assert "vector" == WeightedPermEntropy(
         parcellation=PARCELLATION
-    ).storage_type(input_type="BOLD", output_feature="complexity")
+    ).storage_type(input_type=DataType.BOLD, output_feature="complexity")
 
 
-@pytest.mark.skipif(
-    _check_ants() is False, reason="requires ANTs to be in PATH"
-)
-def test_store(tmp_path: Path) -> None:
+def test_store(element_data: dict, tmp_path: Path) -> None:
     """Test WeightedPermEntropy store().
 
     Parameters
     ----------
+    element_data : dict
+        The element data.
     tmp_path : pathlib.Path
         The path to the test directory.
 
     """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        # Fetch element
-        element = dg["sub001"]
-        # Fetch element data
-        element_data = DefaultDataReader().fit_transform(element)
-        # Initialize the marker
-        marker = WeightedPermEntropy(parcellation=PARCELLATION)
-        # Create storage
-        storage = SQLiteFeatureStorage(
-            uri=tmp_path / "test_weighted_perm_entropy.sqlite"
-        )
-        # Compute the marker and store
-        marker.fit_transform(input=element_data, storage=storage)
+    # Initialize the marker
+    marker = WeightedPermEntropy(parcellation=PARCELLATION)
+    # Create storage
+    storage = HDF5FeatureStorage(
+        uri=tmp_path / "test_weighted_perm_entropy.hdf5"
+    )
+    # Compute the marker and store
+    marker.fit_transform(input=element_data, storage=storage)

junifer/markers/complexity/weighted_perm_entropy.py

@@ -2,15 +2,15 @@
 
 # Authors: Amir Omidvarnia <a.omidvarnia@fz-juelich.de>
 #          Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Optional, Union
-
 import neurokit2 as nk
 import numpy as np
 
 from ...api.decorators import register_marker
-from ...utils import logger, warn_with_log
+from ...utils import warn_with_log
+from ..base import logger
 from .complexity_base import ComplexityBase
 
 
@@ -27,24 +27,24 @@ class WeightedPermEntropy(ComplexityBase):
         The name(s) of the parcellation(s) to use.
         See :func:`.list_data` for options.
     agg_method : str, optional
-        The method to perform aggregation using. Check valid options in
-        :func:`junifer.stats.get_aggfunc_by_name` (default "mean").
-    agg_method_params : dict, optional
-        Parameters to pass to the aggregation function. Check valid options in
-        :func:`junifer.stats.get_aggfunc_by_name` (default None).
-    masks : str, dict or list of dict or str, optional
+        The aggregation function to use.
+        See :func:`.get_aggfunc_by_name` for options
+        (default "mean").
+    agg_method_params : dict or None, optional
+        The parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options (default None).
+    masks : str, dict, list of them or None, optional
         The specification of the masks to apply to regions before extracting
         signals. Check :ref:`Using Masks <using_masks>` for more details.
         If None, will not apply any mask (default None).
-    params : dict, optional
-        Parameters to pass to the weighted permutation entropy calculation
-        function.
-        For more information, check out
-        ``junifer.markers.utils._weighted_perm_entropy``. If None, value
-        is set to {"m": 2, "delay": 1} (default None).
-    name : str, optional
-        The name of the marker. If None, it will use the class name
+    params : dict or None, optional
+        The parameters to pass to the weighted permutation entropy calculation
+        function. See ``junifer.markers.utils._weighted_perm_entropy`` for more
+        information. If None, value is set to ``{"m": 2, "delay": 1}``
         (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     Warnings
     --------
@@ -55,26 +55,12 @@ class WeightedPermEntropy(ComplexityBase):
 
     """
 
-    def __init__(
-        self,
-        parcellation: Union[str, list[str]],
-        agg_method: str = "mean",
-        agg_method_params: Optional[dict] = None,
-        masks: Union[str, dict, list[Union[dict, str]], None] = None,
-        params: Optional[dict] = None,
-        name: Optional[str] = None,
-    ) -> None:
-        super().__init__(
-            parcellation=parcellation,
-            agg_method=agg_method,
-            agg_method_params=agg_method_params,
-            masks=masks,
-            name=name,
-        )
-        if params is None:
+    params: dict | None = None
+
+    def validate_marker_params(self) -> None:
+        """Run extra logical validation for marker."""
+        if self.params is None:
             self.params = {"m": 4, "delay": 1}
-        else:
-            self.params = params
 
     def compute_complexity(
         self,