junifer 0.0.5.dev110__py3-none-any.whl → 0.0.5.dev145__py3-none-any.whl

junifer/external/BrainPrint/brainprint/utils/_config.py

@@ -0,0 +1,112 @@
+import platform
+import re
+import sys
+from functools import partial
+from importlib.metadata import requires, version
+from typing import IO, Callable, List, Optional
+
+import psutil
+
+
+def sys_info(fid: Optional[IO] = None, developer: bool = False):
+    """Print the system information for debugging.
+
+    Parameters
+    ----------
+    fid : file-like, default=None
+        The file to write to, passed to :func:`print`.
+        Can be None to use :data:`sys.stdout`.
+    developer : bool, default=False
+        If True, display information about optional dependencies.
+    """
+
+    ljust = 26
+    out = partial(print, end="", file=fid)
+    package = __package__.split(".")[0]
+
+    # OS information - requires python 3.8 or above
+    out("Platform:".ljust(ljust) + platform.platform() + "\n")
+    # Python information
+    out("Python:".ljust(ljust) + sys.version.replace("\n", " ") + "\n")
+    out("Executable:".ljust(ljust) + sys.executable + "\n")
+    # CPU information
+    out("CPU:".ljust(ljust) + platform.processor() + "\n")
+    out("Physical cores:".ljust(ljust) + str(psutil.cpu_count(False)) + "\n")
+    out("Logical cores:".ljust(ljust) + str(psutil.cpu_count(True)) + "\n")
+    # Memory information
+    out("RAM:".ljust(ljust))
+    out(f"{psutil.virtual_memory().total / float(2 ** 30):0.1f} GB\n")
+    out("SWAP:".ljust(ljust))
+    out(f"{psutil.swap_memory().total / float(2 ** 30):0.1f} GB\n")
+
+    # dependencies
+    out("\nDependencies info\n")
+    out(f"{package}:".ljust(ljust) + version(package) + "\n")
+    dependencies = [
+        elt.split(";")[0].rstrip() for elt in requires(package) if "extra" not in elt
+    ]
+    _list_dependencies_info(out, ljust, dependencies)
+
+    # extras
+    if developer:
+        keys = (
+            "build",
+            "doc",
+            "test",
+            "style",
+        )
+        for key in keys:
+            dependencies = [
+                elt.split(";")[0].rstrip()
+                for elt in requires(package)
+                if f"extra == '{key}'" in elt or f'extra == "{key}"' in elt
+            ]
+            if len(dependencies) == 0:
+                continue
+            out(f"\nOptional '{key}' info\n")
+            _list_dependencies_info(out, ljust, dependencies)
+
+
+def _list_dependencies_info(out: Callable, ljust: int, dependencies: List[str]):
+    """List dependencies names and versions.
+
+    Parameters
+    ----------
+    out : Callable
+        output function
+    ljust : int
+         length of returned string
+    dependencies : List[str]
+        list of dependencies
+
+    """
+
+    for dep in dependencies:
+        # handle dependencies with version specifiers
+        specifiers_pattern = r"(~=|==|!=|<=|>=|<|>|===)"
+        specifiers = re.findall(specifiers_pattern, dep)
+        if len(specifiers) != 0:
+            dep, _ = dep.split(specifiers[0])
+            while not dep[-1].isalpha():
+                dep = dep[:-1]
+        # handle dependencies provided with a [key], e.g. pydocstyle[toml]
+        if "[" in dep:
+            dep = dep.split("[")[0]
+        try:
+            version_ = version(dep)
+        except Exception:
+            version_ = "Not found."
+
+        # handle special dependencies with backends, C dep, ..
+        if dep in ("matplotlib", "seaborn") and version_ != "Not found.":
+            try:
+                from matplotlib import pyplot as plt
+
+                backend = plt.get_backend()
+            except Exception:
+                backend = "Not found"
+
+            out(f"{dep}:".ljust(ljust) + version_ + f" (backend: {backend})\n")
+
+        else:
+            out(f"{dep}:".ljust(ljust) + version_ + "\n")

junifer/external/BrainPrint/brainprint/utils/utils.py

@@ -0,0 +1,188 @@
+"""
+Utilities for the :mod:`brainprint` module.
+"""
+import os
+import shlex
+import subprocess
+from pathlib import Path
+from typing import Dict
+
+import numpy as np
+import pandas as pd
+
+
+def validate_environment() -> None:
+    """
+    Checks whether required environment variables are set.
+    """
+    if not os.getenv("FREESURFER_HOME"):
+        raise RuntimeError(
+            "FreeSurfer root directory must be set as the $FREESURFER_HOME "
+            "environment variable!"
+        )
+
+
+def test_freesurfer() -> None:
+    """
+    Tests FreeSurfer binarize are accessible and executable.
+
+    Raises
+    ------
+    RuntimeError
+        Failed to execute test FreeSurfer command
+    """
+    command = "mri_binarize -version"
+    try:
+        run_shell_command(command)
+    except FileNotFoundError:
+        raise RuntimeError(
+            "Failed to run FreeSurfer command, please check the required binaries "
+            "are included in your $PATH."
+        )
+
+
+def run_shell_command(command: str, verbose: bool = False):
+    """
+    Execute shell command.
+
+    Parameters
+    ----------
+    command : str
+        Shell command to be executed
+
+    Raises
+    ------
+    RuntimeError
+        Shell command execution failure
+    """
+    if verbose:
+        print(f"Executing command:\t{command}", end="\n")
+    args = shlex.split(command)
+    try:
+        return_code = subprocess.call(args)
+    except Exception as e:
+        message = (
+            "Failed to execute the following command:\n{command}\n"
+            "The following exception was raised:\n{exception}".format(
+                command=command, exception=e
+            )
+        )
+        print(message)
+        raise
+    if return_code != 0:
+        message = (
+            "Execution of the following command:\n{command}\n"
+            "Returned non-zero exit code!".format(command=command)
+        )
+        raise RuntimeError(message)
+
+
+def validate_subject_dir(subjects_dir: Path, subject_id: str) -> Path:
+    """
+    Checks the input FreeSurfer preprocessing results directory exists.
+
+    Parameters
+    ----------
+    subjects_dir : Path
+        FreeSurfer's subjects directory
+    subject_id : str
+        The subject identifier, as defined within the FreeSurfer's subjects
+        directory
+
+    Raises
+    ------
+    FileNotFoundError
+        Subject results directory does not exist
+    """
+    subject_dir = Path(subjects_dir) / subject_id
+    if not subject_dir.is_dir():
+        message = "FreeSurfer results directory at {path} does not exist!".format(
+            path=subject_dir
+        )
+        raise FileNotFoundError(message)
+    return subject_dir
+
+
+def resolve_destination(subject_dir: Path, destination: Path = None) -> Path:
+    if destination is None:
+        return Path(subject_dir) / "brainprint"
+    return destination
+
+
+def create_output_paths(subject_dir: Path = None, destination: Path = None) -> None:
+    """
+    Creates the output directories in which the BrainPrint analysis derivatives
+    will be created. One of *subject_dir* or *destination* must be
+    provided.
+
+    Parameters
+    ----------
+    subject_dir : Path, optional
+        If provided, will simply nest results in the provided directory, by
+        default None
+    destination : Path, optional
+        If provided, will use this path as the results root directory, by
+        default None
+
+    Raises
+    ------
+    ValueError
+        No *subject_dir* or *destination* provided
+    """
+    destination = resolve_destination(subject_dir, destination)
+    destination.mkdir(parents=True, exist_ok=True)
+    (destination / "surfaces").mkdir(parents=True, exist_ok=True)
+    (destination / "temp").mkdir(parents=True, exist_ok=True)
+    return destination
+
+
+def export_brainprint_results(
+    destination: Path,
+    eigenvalues: np.ndarray,
+    eigenvectors: np.ndarray = None,
+    distances: np.ndarray = None,
+) -> Dict[str, Path]:
+    """
+    Writes the BrainPrint analysis results to CSV files.
+
+    Parameters
+    ----------
+    destination : Path
+        Eigenvalues CSV file destination
+    eigenvalues : np.ndarray
+        Eigenvalues
+    eigenvectors : np.ndarray, optional
+        Eigenvectors, by default None
+    distances : np.ndarray, optional
+        Distances, by default None
+    """
+    files = {}
+    df = pd.DataFrame(eigenvalues).sort_index(axis=1)
+    ev_indices = [f"ev{i}" for i in range(len(df) - 2)]
+    df.index = ["area", "volume"] + ev_indices
+    df.to_csv(destination, index=True, na_rep="NaN")
+    files["eigenvalues"] = destination
+
+    if eigenvectors is not None:
+        eigenvectors_dir = destination.parent / "eigenvectors"
+        eigenvectors_dir.mkdir(parents=True, exist_ok=True)
+        for key, value in eigenvectors.items():
+            suffix = ".evecs-{key}.csv".format(key=key)
+            name = destination.with_suffix(suffix).name
+            vectors_destination = eigenvectors_dir / name
+            pd.DataFrame(value).to_csv(
+                vectors_destination,
+                index=True,
+                na_rep="NaN",
+            )
+        files["eigenvectors"] = eigenvectors_dir
+
+    if distances is not None:
+        distances_destination = destination.with_suffix(".asymmetry.csv")
+        pd.DataFrame([distances]).to_csv(
+            distances_destination,
+            index=False,
+            na_rep="NaN",
+        )
+        files["distances"] = distances_destination
+    return files

junifer/markers/__init__.py

@@ -23,3 +23,25 @@ from .temporal_snr import (
     TemporalSNRParcels,
     TemporalSNRSpheres,
 )
+from .brainprint import BrainPrint
+
+
+__all__ = [
+    "BaseMarker",
+    "MarkerCollection",
+    "RSSETSMarker",
+    "ParcelAggregation",
+    "SphereAggregation",
+    "FunctionalConnectivityParcels",
+    "FunctionalConnectivitySpheres",
+    "CrossParcellationFC",
+    "EdgeCentricFCParcels",
+    "EdgeCentricFCSpheres",
+    "ReHoParcels",
+    "ReHoSpheres",
+    "ALFFParcels",
+    "ALFFSpheres",
+    "TemporalSNRParcels",
+    "TemporalSNRSpheres",
+    "BrainPrint",
+]

junifer/markers/base.py

@@ -15,16 +15,22 @@ if TYPE_CHECKING:
     from junifer.storage import BaseFeatureStorage
 
 
+__all__ = ["BaseMarker"]
+
+
 class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
     """Abstract base class for all markers.
 
+    For every interface that is required, one needs to provide a concrete
+    implementation of this abstract class.
+
     Parameters
     ----------
-    on : str or list of str
-        The kind of data to apply the marker to. By default, will work on all
-        available data.
+    on : str or list of str or None, optional
+        The data type to apply the marker on. If None,
+        will work on all available data types (default None).
     name : str, optional
-        The name of the marker. By default, it will use the class name as the
+        The name of the marker. If None, will use the class name as the
         name of the marker (default None).
 
     Raises
@@ -192,17 +198,25 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         for type_ in self._on:
             if type_ in input.keys():
                 logger.info(f"Computing {type_}")
+                # Get data dict for data type
                 t_input = input[type_]
+                # Pass the other data types as extra input, removing
+                # the current type
                 extra_input = input.copy()
                 extra_input.pop(type_)
+                logger.debug(
+                    f"Extra data type for feature extraction: "
+                    f"{extra_input.keys()}"
+                )
+                # Copy metadata
                 t_meta = t_input["meta"].copy()
                 t_meta["type"] = type_
-
+                # Compute marker
                 t_out = self.compute(input=t_input, extra_input=extra_input)
                 t_out["meta"] = t_meta
-
+                # Update metadata for step
                 self.update_meta(t_out, "marker")
-
+                # Check storage
                 if storage is not None:
                     logger.info(f"Storing in {storage}")
                     self.store(type_=type_, out=t_out, storage=storage)