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

junifer/markers/falff/__init__.pyi

@@ -0,0 +1,4 @@
+__all__ = ["ALFFParcels", "ALFFSpheres"]
+
+from .falff_parcels import ALFFParcels
+from .falff_spheres import ALFFSpheres

junifer/markers/falff/_afni_falff.py

@@ -8,29 +8,25 @@ from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Tuple,
-    Union,
 )
 
 import nibabel as nib
 
 from ...pipeline import WorkDirManager
-from ...pipeline.singleton import singleton
+from ...typing import ExternalDependencies
 from ...utils import logger, run_ext_cmd
+from ...utils.singleton import Singleton
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["AFNIALFF"]
 
 
-@singleton
-class AFNIALFF:
+class AFNIALFF(metaclass=Singleton):
     """Class for computing ALFF using AFNI.
 
     This class uses AFNI's 3dRSFC to compute ALFF. It's designed as a singleton
@@ -38,7 +34,7 @@ class AFNIALFF:
 
     """
 
-    _EXT_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, List[str]]]]] = [
+    _EXT_DEPENDENCIES: ClassVar[ExternalDependencies] = [
         {
             "name": "afni",
             "commands": ["3dRSFC", "3dAFNItoNIFTI"],
@@ -54,17 +50,17 @@ class AFNIALFF:
     @lru_cache(maxsize=None, typed=True)
     def compute(
         self,
-        data: "Nifti1Image",
+        input_path: Path,
         highpass: float,
         lowpass: float,
         tr: Optional[float],
-    ) -> Tuple["Nifti1Image", "Nifti1Image", Path, Path]:
+    ) -> tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF + fALFF map.
 
         Parameters
         ----------
-        data : 4D Niimg-like object
-            Images to process.
+        input_path : pathlib.Path
+            Path to the input data.
         highpass : positive float
             Highpass cutoff frequency.
         lowpass : positive float
@@ -86,19 +82,17 @@ class AFNIALFF:
         """
         logger.debug("Creating cache for ALFF computation via AFNI")
 
-        # Create component-scoped tempdir
-        tempdir = WorkDirManager().get_tempdir(prefix="afni_alff+falff")
-
-        # Save target data to a component-scoped tempfile
-        nifti_in_file_path = tempdir / "input.nii"  # needs to be .nii
-        nib.save(data, nifti_in_file_path)
+        # Create element-scoped tempdir
+        element_tempdir = WorkDirManager().get_element_tempdir(
+            prefix="afni_lff"
+        )
 
         # Set 3dRSFC command
-        alff_falff_out_path_prefix = tempdir / "alff_falff"
+        lff_out_path_prefix = element_tempdir / "output"
         bp_cmd = [
             "3dRSFC",
-            f"-prefix {alff_falff_out_path_prefix.resolve()}",
-            f"-input {nifti_in_file_path.resolve()}",
+            f"-prefix {lff_out_path_prefix.resolve()}",
+            f"-input {input_path.resolve()}",
             f"-band {highpass} {lowpass}",
             "-no_rsfa -nosat -nodetrend",
         ]
@@ -108,49 +102,48 @@ class AFNIALFF:
         # Call 3dRSFC
         run_ext_cmd(name="3dRSFC", cmd=bp_cmd)
 
-        # Create element-scoped tempdir so that the ALFF and fALFF maps are
-        # available later as nibabel stores file path reference for
-        # loading on computation
-        element_tempdir = WorkDirManager().get_element_tempdir(
-            prefix="afni_alff_falff"
-        )
-
+        # Read header to get output suffix
+        niimg = nib.load(input_path)
+        header = niimg.header
+        sform_code = header.get_sform(coded=True)[1]
+        if sform_code == 4:
+            output_suffix = "tlrc"
+        else:
+            output_suffix = "orig"
+        # Set params suffix
         params_suffix = f"_{highpass}_{lowpass}_{tr}"
 
         # Convert alff afni to nifti
-        alff_afni_to_nifti_out_path = (
-            element_tempdir / f"alff{params_suffix}_output.nii"
+        alff_nifti_out_path = (
+            element_tempdir / f"output_alff{params_suffix}.nii"
         )  # needs to be .nii
         convert_alff_cmd = [
             "3dAFNItoNIFTI",
-            f"-prefix {alff_afni_to_nifti_out_path.resolve()}",
-            f"{alff_falff_out_path_prefix}_ALFF+orig.BRIK",
+            f"-prefix {alff_nifti_out_path.resolve()}",
+            f"{lff_out_path_prefix}_ALFF+{output_suffix}.BRIK",
         ]
         # Call 3dAFNItoNIFTI
         run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_alff_cmd)
 
         # Convert falff afni to nifti
-        falff_afni_to_nifti_out_path = (
-            element_tempdir / f"falff{params_suffix}_output.nii"
+        falff_nifti_out_path = (
+            element_tempdir / f"output_falff{params_suffix}.nii"
         )  # needs to be .nii
         convert_falff_cmd = [
             "3dAFNItoNIFTI",
-            f"-prefix {falff_afni_to_nifti_out_path.resolve()}",
-            f"{alff_falff_out_path_prefix}_fALFF+orig.BRIK",
+            f"-prefix {falff_nifti_out_path.resolve()}",
+            f"{lff_out_path_prefix}_fALFF+{output_suffix}.BRIK",
         ]
         # Call 3dAFNItoNIFTI
         run_ext_cmd(name="3dAFNItoNIFTI", cmd=convert_falff_cmd)
 
         # Load nifti
-        alff_data = nib.load(alff_afni_to_nifti_out_path)
-        falff_data = nib.load(falff_afni_to_nifti_out_path)
-
-        # Delete tempdir
-        WorkDirManager().delete_tempdir(tempdir)
+        alff_data = nib.load(alff_nifti_out_path)
+        falff_data = nib.load(falff_nifti_out_path)
 
         return (
             alff_data,
             falff_data,
-            alff_afni_to_nifti_out_path,
-            falff_afni_to_nifti_out_path,
-        )  # type: ignore
+            alff_nifti_out_path,
+            falff_nifti_out_path,
+        )

junifer/markers/falff/_junifer_falff.py

@@ -9,8 +9,6 @@ from typing import (
     TYPE_CHECKING,
     ClassVar,
     Optional,
-    Set,
-    Tuple,
 )
 
 import nibabel as nib
@@ -19,26 +17,26 @@ import scipy as sp
 from nilearn import image as nimg
 
 from ...pipeline import WorkDirManager
-from ...pipeline.singleton import singleton
+from ...typing import Dependencies
 from ...utils import logger
+from ...utils.singleton import Singleton
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["JuniferALFF"]
 
 
-@singleton
-class JuniferALFF:
+class JuniferALFF(metaclass=Singleton):
     """Class for computing ALFF using junifer.
 
     It's designed as a singleton with caching for efficient computation.
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"numpy", "nilearn", "scipy"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"numpy", "nilearn", "scipy"}
 
     def __del__(self) -> None:
         """Terminate the class."""
@@ -49,17 +47,17 @@ class JuniferALFF:
     @lru_cache(maxsize=None, typed=True)
     def compute(
         self,
-        data: "Nifti1Image",
+        input_path: Path,
         highpass: float,
         lowpass: float,
         tr: Optional[float],
-    ) -> Tuple["Nifti1Image", "Nifti1Image", Path, Path]:
+    ) -> tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF + fALFF map.
 
         Parameters
         ----------
-        data : 4D Niimg-like object
-            Images to process.
+        input_path : pathlib.Path
+            Path to the input data.
         highpass : positive float
             Highpass cutoff frequency.
         lowpass : positive float
@@ -82,9 +80,10 @@ class JuniferALFF:
         logger.debug("Creating cache for ALFF computation via junifer")
 
         # Get scan data
-        niimg_data = data.get_fdata().copy()
+        niimg = nib.load(input_path)
+        niimg_data = niimg.get_fdata().copy()
         if tr is None:
-            tr = float(data.header["pixdim"][4])  # type: ignore
+            tr = float(niimg.header["pixdim"][4])  # type: ignore
             logger.info(f"`tr` not provided, using `tr` from header: {tr}")
 
         # Bandpass the data within the lowpass and highpass cutoff freqs
@@ -122,19 +121,17 @@ class JuniferALFF:
         # Calculate ALFF
         alff = numerator / np.sqrt(niimg_data.shape[-1])
         alff_data = nimg.new_img_like(
-            ref_niimg=data,
+            ref_niimg=niimg,
             data=alff,
         )
         falff_data = nimg.new_img_like(
-            ref_niimg=data,
+            ref_niimg=niimg,
             data=falff,
         )
 
-        # Create element-scoped tempdir so that the ALFF and fALFF maps are
-        # available later as nibabel stores file path reference for
-        # loading on computation
+        # Create element-scoped tempdir
         element_tempdir = WorkDirManager().get_element_tempdir(
-            prefix="junifer_alff+falff"
+            prefix="junifer_lff"
         )
         output_alff_path = element_tempdir / "output_alff.nii.gz"
         output_falff_path = element_tempdir / "output_falff.nii.gz"

junifer/markers/falff/falff_base.py

@@ -11,14 +11,10 @@ from typing import (
     TYPE_CHECKING,
     Any,
     ClassVar,
-    Dict,
-    List,
     Optional,
-    Tuple,
-    Type,
-    Union,
 )
 
+from ...typing import ConditionalDependencies, MarkerInOutMappings
 from ...utils.logging import logger, raise_error
 from ..base import BaseMarker
 from ._afni_falff import AFNIALFF
@@ -26,7 +22,7 @@ from ._junifer_falff import JuniferALFF
 
 
 if TYPE_CHECKING:
-    from nibabel import Nifti1Image
+    from nibabel.nifti1 import Nifti1Image
 
 
 __all__ = ["ALFFBase"]
@@ -72,7 +68,7 @@ class ALFFBase(BaseMarker):
 
     """
 
-    _CONDITIONAL_DEPENDENCIES: ClassVar[List[Dict[str, Union[str, Type]]]] = [
+    _CONDITIONAL_DEPENDENCIES: ClassVar[ConditionalDependencies] = [
         {
             "using": "afni",
             "depends_on": AFNIALFF,
@@ -83,7 +79,7 @@ class ALFFBase(BaseMarker):
         },
     ]
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "BOLD": {
             "alff": "vector",
             "falff": "vector",
@@ -118,8 +114,8 @@ class ALFFBase(BaseMarker):
 
     def _compute(
         self,
-        input_data: Dict[str, Any],
-    ) -> Tuple["Nifti1Image", "Nifti1Image", Path, Path]:
+        input_data: dict[str, Any],
+    ) -> tuple["Nifti1Image", "Nifti1Image", Path, Path]:
         """Compute ALFF and fALFF.
 
         Parameters
@@ -150,7 +146,7 @@ class ALFFBase(BaseMarker):
             estimator = JuniferALFF()
         # Compute ALFF + fALFF
         alff, falff, alff_path, falff_path = estimator.compute(  # type: ignore
-            data=input_data["data"],
+            input_path=input_data["path"],
             highpass=self.highpass,
             lowpass=self.lowpass,
             tr=self.tr,

junifer/markers/falff/falff_parcels.py

@@ -6,7 +6,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from ...api.decorators import register_marker
 from ...utils import logger
@@ -24,8 +24,8 @@ class ALFFParcels(ALFFBase):
     Parameters
     ----------
     parcellation : str or list of str
-        The name(s) of the parcellation(s). Check valid options by calling
-        :func:`.list_parcellations`.
+        The name(s) of the parcellation(s) to use.
+        See :func:`.list_data` for options.
     using : {"junifer", "afni"}
         Implementation to use for computing ALFF:
 
@@ -70,14 +70,14 @@ class ALFFParcels(ALFFBase):
 
     def __init__(
         self,
-        parcellation: Union[str, List[str]],
+        parcellation: Union[str, list[str]],
         using: str,
         highpass: float = 0.01,
         lowpass: float = 0.1,
         tr: Optional[float] = None,
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
-        masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
+        agg_method_params: Optional[dict] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         # Superclass init first to validate `using` parameter
@@ -95,9 +95,9 @@ class ALFFParcels(ALFFBase):
 
     def compute(
         self,
-        input: Dict[str, Any],
-        extra_input: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
+        input: dict[str, Any],
+        extra_input: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
         """Compute.
 
         Parameters

junifer/markers/falff/falff_spheres.py

@@ -6,7 +6,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from ...api.decorators import register_marker
 from ...utils import logger
@@ -24,8 +24,8 @@ class ALFFSpheres(ALFFBase):
     Parameters
     ----------
     coords : str
-        The name of the coordinates list to use. See
-        :func:`.list_coordinates` for options.
+        The name of the coordinates list to use.
+        See :func:`.list_data` for options.
     using : {"junifer", "afni"}
         Implementation to use for computing ALFF:
 
@@ -85,8 +85,8 @@ class ALFFSpheres(ALFFBase):
         lowpass: float = 0.1,
         tr: Optional[float] = None,
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
-        masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
+        agg_method_params: Optional[dict] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         # Superclass init first to validate `using` parameter
@@ -106,9 +106,9 @@ class ALFFSpheres(ALFFBase):
 
     def compute(
         self,
-        input: Dict[str, Any],
-        extra_input: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
+        input: dict[str, Any],
+        extra_input: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
         """Compute.
 
         Parameters

junifer/markers/falff/tests/test_falff_spheres.py

@@ -69,7 +69,9 @@ def test_ALFFSpheres(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             # Fit transform marker on data
             output = marker.fit_transform(element_data)
 
-            assert "Creating cache" in caplog.text
+            # Tests for ALFFParcels run before this with the same data and that
+            # should create the cache
+            assert "Calculating ALFF and fALFF" in caplog.text
 
             # Get BOLD output
             assert "BOLD" in output

junifer/markers/functional_connectivity/__init__.py

@@ -3,17 +3,7 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from .functional_connectivity_parcels import FunctionalConnectivityParcels
-from .functional_connectivity_spheres import FunctionalConnectivitySpheres
-from .crossparcellation_functional_connectivity import CrossParcellationFC
-from .edge_functional_connectivity_parcels import EdgeCentricFCParcels
-from .edge_functional_connectivity_spheres import EdgeCentricFCSpheres
+import lazy_loader as lazy
 
 
-__all__ = [
-    "FunctionalConnectivityParcels",
-    "FunctionalConnectivitySpheres",
-    "CrossParcellationFC",
-    "EdgeCentricFCParcels",
-    "EdgeCentricFCSpheres",
-]
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

junifer/markers/functional_connectivity/__init__.pyi

@@ -0,0 +1,13 @@
+__all__ = [
+    "FunctionalConnectivityParcels",
+    "FunctionalConnectivitySpheres",
+    "CrossParcellationFC",
+    "EdgeCentricFCParcels",
+    "EdgeCentricFCSpheres",
+]
+
+from .functional_connectivity_parcels import FunctionalConnectivityParcels
+from .functional_connectivity_spheres import FunctionalConnectivitySpheres
+from .crossparcellation_functional_connectivity import CrossParcellationFC
+from .edge_functional_connectivity_parcels import EdgeCentricFCParcels
+from .edge_functional_connectivity_spheres import EdgeCentricFCSpheres

junifer/markers/functional_connectivity/crossparcellation_functional_connectivity.py

@@ -4,11 +4,12 @@
 #          Kaustubh R. Patil <k.patil@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from typing import Any, ClassVar, Optional, Union
 
 import pandas as pd
 
 from ...api.decorators import register_marker
+from ...typing import Dependencies, MarkerInOutMappings
 from ...utils import logger, raise_error
 from ..base import BaseMarker
 from ..parcel_aggregation import ParcelAggregation
@@ -49,9 +50,9 @@ class CrossParcellationFC(BaseMarker):
 
     """
 
-    _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn"}
+    _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
+    _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
         "BOLD": {
             "functional_connectivity": "matrix",
         },
@@ -62,9 +63,9 @@ class CrossParcellationFC(BaseMarker):
         parcellation_one: str,
         parcellation_two: str,
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
+        agg_method_params: Optional[dict] = None,
         corr_method: str = "pearson",
-        masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         if parcellation_one == parcellation_two:
@@ -81,9 +82,9 @@ class CrossParcellationFC(BaseMarker):
 
     def compute(
         self,
-        input: Dict[str, Any],
-        extra_input: Optional[Dict] = None,
-    ) -> Dict:
+        input: dict[str, Any],
+        extra_input: Optional[dict] = None,
+    ) -> dict:
         """Compute.
 
         Take a timeseries, parcellate them with two different parcellation

junifer/markers/functional_connectivity/edge_functional_connectivity_parcels.py

@@ -4,7 +4,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from ...api.decorators import register_marker
 from ..parcel_aggregation import ParcelAggregation
@@ -23,7 +23,7 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
     ----------
     parcellation : str or list of str
         The name(s) of the parcellation(s) to use.
-        See :func:`.list_parcellations` for options.
+        See :func:`.list_data` for options.
     agg_method : str, optional
         The method to perform aggregation using.
         See :func:`.get_aggfunc_by_name` for options
@@ -61,12 +61,12 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
 
     def __init__(
         self,
-        parcellation: Union[str, List[str]],
+        parcellation: Union[str, list[str]],
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
+        agg_method_params: Optional[dict] = None,
         conn_method: str = "correlation",
-        conn_method_params: Optional[Dict] = None,
-        masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
+        conn_method_params: Optional[dict] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         self.parcellation = parcellation
@@ -80,8 +80,8 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
         )
 
     def aggregate(
-        self, input: Dict[str, Any], extra_input: Optional[Dict] = None
-    ) -> Dict:
+        self, input: dict[str, Any], extra_input: Optional[dict] = None
+    ) -> dict:
         """Perform parcel aggregation and ETS computation.
 
         Parameters

junifer/markers/functional_connectivity/edge_functional_connectivity_spheres.py

@@ -4,7 +4,7 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from ...api.decorators import register_marker
 from ..sphere_aggregation import SphereAggregation
@@ -23,7 +23,7 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
     ----------
     coords : str
         The name of the coordinates list to use.
-        See :func:`.list_coordinates` for options.
+        See :func:`.list_data` for options.
     radius : positive float, optional
         The radius of the sphere around each coordinates in millimetres.
         If None, the signal will be extracted from a single voxel.
@@ -73,10 +73,10 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
         radius: Optional[float] = None,
         allow_overlap: bool = False,
         agg_method: str = "mean",
-        agg_method_params: Optional[Dict] = None,
+        agg_method_params: Optional[dict] = None,
         conn_method: str = "correlation",
-        conn_method_params: Optional[Dict] = None,
-        masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
+        conn_method_params: Optional[dict] = None,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         self.coords = coords
@@ -94,8 +94,8 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
         )
 
     def aggregate(
-        self, input: Dict[str, Any], extra_input: Optional[Dict] = None
-    ) -> Dict:
+        self, input: dict[str, Any], extra_input: Optional[dict] = None
+    ) -> dict:
         """Perform sphere aggregation and ETS computation.
 
         Parameters