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

junifer/markers/functional_connectivity/crossparcellation_functional_connectivity.py

@@ -4,14 +4,17 @@
 #          Kaustubh R. Patil <k.patil@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, ClassVar, Optional, Union
+from typing import Annotated, Any, ClassVar
 
 import pandas as pd
+from pydantic import BeforeValidator
 
 from ...api.decorators import register_marker
+from ...datagrabber import DataType
+from ...storage import StorageType
 from ...typing import Dependencies, MarkerInOutMappings
-from ...utils import logger, raise_error
-from ..base import BaseMarker
+from ...utils import ensure_list_or_none, raise_error
+from ..base import BaseMarker, logger
 from ..parcel_aggregation import ParcelAggregation
 from ..utils import _correlate_dataframes
 
@@ -30,60 +33,55 @@ class CrossParcellationFC(BaseMarker):
     parcellation_two : str
         The name of the second parcellation.
     agg_method : str, optional
-        The method to perform aggregation using.
+        The aggregation function to use.
         See :func:`.get_aggfunc_by_name` for options
         (default "mean").
     agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
+        The parameters to pass to the aggregation function.
         See :func:`.get_aggfunc_by_name` for options
         (default None).
     corr_method : str, optional
         Any method that can be passed to
         :meth:`pandas.DataFrame.corr` (default "pearson").
-    masks : str, dict or list of dict or str, optional
+    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).
-    name : str, optional
-        The name of the marker. If None, will use
-        ``BOLD_CrossParcellationFC`` (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     """
 
     _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn"}
 
     _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
-        "BOLD": {
-            "functional_connectivity": "matrix",
+        DataType.BOLD: {
+            "functional_connectivity": StorageType.Matrix,
         },
     }
 
-    def __init__(
-        self,
-        parcellation_one: str,
-        parcellation_two: str,
-        agg_method: str = "mean",
-        agg_method_params: Optional[dict] = None,
-        corr_method: str = "pearson",
-        masks: Union[str, dict, list[Union[dict, str]], None] = None,
-        name: Optional[str] = None,
-    ) -> None:
-        if parcellation_one == parcellation_two:
+    parcellation_one: str
+    parcellation_two: str
+    agg_method: str = "mean"
+    agg_method_params: dict | None = None
+    corr_method: str = "pearson"
+    masks: Annotated[
+        dict | str | list[dict | str] | None,
+        BeforeValidator(ensure_list_or_none),
+    ] = None
+
+    def validate_marker_params(self) -> None:
+        """Run extra logical validation for marker."""
+        if self.parcellation_one == self.parcellation_two:
             raise_error(
                 "The two parcellations must be different.",
             )
-        self.parcellation_one = parcellation_one
-        self.parcellation_two = parcellation_two
-        self.agg_method = agg_method
-        self.agg_method_params = agg_method_params
-        self.corr_method = corr_method
-        self.masks = masks
-        super().__init__(on=["BOLD"], name=name)
 
     def compute(
         self,
         input: dict[str, Any],
-        extra_input: Optional[dict] = None,
+        extra_input: dict | None = None,
     ) -> dict:
         """Compute.
 
@@ -123,18 +121,18 @@ class CrossParcellationFC(BaseMarker):
         )
         # Perform aggregation using two parcellations
         aggregation_parcellation_one = ParcelAggregation(
-            parcellation=self.parcellation_one,
+            parcellation=[self.parcellation_one],
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
-            on="BOLD",
+            on=DataType.BOLD,
         ).compute(input, extra_input=extra_input)
         aggregation_parcellation_two = ParcelAggregation(
-            parcellation=self.parcellation_two,
+            parcellation=[self.parcellation_two],
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
-            on="BOLD",
+            on=DataType.BOLD,
         ).compute(input, extra_input=extra_input)
 
         return {

junifer/markers/functional_connectivity/edge_functional_connectivity_maps.py

@@ -3,9 +3,10 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Optional, Union
+from typing import Any
 
 from ...api.decorators import register_marker
+from ...datagrabber import DataType
 from ..maps_aggregation import MapsAggregation
 from ..utils import _ets
 from .functional_connectivity_base import FunctionalConnectivityBase
@@ -24,23 +25,23 @@ class EdgeCentricFCMaps(FunctionalConnectivityBase):
         The name of the map(s) to use.
         See :func:`.list_data` for options.
     conn_method : str, optional
-        The method to perform connectivity measure using.
+        The connectivity measure to use.
         See :class:`.JuniferConnectivityMeasure` for options
         (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+    conn_method_params : dict or None, optional
+        The parameters to pass to :class:`.JuniferConnectivityMeasure`.
         If None, ``{"empirical": True}`` will be used, which would mean
         :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
         covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
         desired, ``{"empirical": False}`` should be passed
         (default None).
-    masks : str, dict or list of dict or str, optional
+    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).
-    name : str, optional
-        The name of the marker. If None, will use
-        ``BOLD_EdgeCentricFCParcels`` (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     References
     ----------
@@ -50,24 +51,10 @@ class EdgeCentricFCMaps(FunctionalConnectivityBase):
 
     """
 
-    def __init__(
-        self,
-        maps: str,
-        conn_method: str = "correlation",
-        conn_method_params: Optional[dict] = None,
-        masks: Union[str, dict, list[Union[dict, str]], None] = None,
-        name: Optional[str] = None,
-    ) -> None:
-        self.maps = maps
-        super().__init__(
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
-            masks=masks,
-            name=name,
-        )
+    maps: str
 
     def aggregate(
-        self, input: dict[str, Any], extra_input: Optional[dict] = None
+        self, input: dict[str, Any], extra_input: dict | None = None
     ) -> dict:
         """Perform maps aggregation and ETS computation.
 
@@ -99,7 +86,7 @@ class EdgeCentricFCMaps(FunctionalConnectivityBase):
         aggregation = MapsAggregation(
             maps=self.maps,
             masks=self.masks,
-            on="BOLD",
+            on=DataType.BOLD,
         ).compute(input, extra_input=extra_input)
         # Compute edgewise timeseries
         ets, edge_names = _ets(

junifer/markers/functional_connectivity/edge_functional_connectivity_parcels.py

@@ -4,9 +4,13 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Optional, Union
+from typing import Annotated, Any
+
+from pydantic import BeforeValidator
 
 from ...api.decorators import register_marker
+from ...datagrabber import DataType
+from ...utils import ensure_list
 from ..parcel_aggregation import ParcelAggregation
 from ..utils import _ets
 from .functional_connectivity_base import FunctionalConnectivityBase
@@ -25,31 +29,30 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
         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.
+        The aggregation function to use.
         See :func:`.get_aggfunc_by_name` for options
         (default "mean").
-    agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        See :func:`.get_aggfunc_by_name` for options
-        (default None).
+    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).
     conn_method : str, optional
-        The method to perform connectivity measure using.
+        The connectivity measure to use.
         See :class:`.JuniferConnectivityMeasure` for options
         (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+    conn_method_params : dict or None, optional
+        The parameters to pass to :class:`.JuniferConnectivityMeasure`.
         If None, ``{"empirical": True}`` will be used, which would mean
         :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
         covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
         desired, ``{"empirical": False}`` should be passed
         (default None).
-    masks : str, dict or list of dict or str, optional
+    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).
-    name : str, optional
-        The name of the marker. If None, will use
-        ``BOLD_EdgeCentricFCParcels`` (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     References
     ----------
@@ -59,28 +62,10 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
 
     """
 
-    def __init__(
-        self,
-        parcellation: Union[str, list[str]],
-        agg_method: str = "mean",
-        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,
-        name: Optional[str] = None,
-    ) -> None:
-        self.parcellation = parcellation
-        super().__init__(
-            agg_method=agg_method,
-            agg_method_params=agg_method_params,
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
-            masks=masks,
-            name=name,
-        )
+    parcellation: Annotated[str | list[str], BeforeValidator(ensure_list)]
 
     def aggregate(
-        self, input: dict[str, Any], extra_input: Optional[dict] = None
+        self, input: dict[str, Any], extra_input: dict | None = None
     ) -> dict:
         """Perform parcel aggregation and ETS computation.
 
@@ -114,7 +99,7 @@ class EdgeCentricFCParcels(FunctionalConnectivityBase):
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
-            on="BOLD",
+            on=DataType.BOLD,
         ).compute(input, extra_input=extra_input)
         # Compute edgewise timeseries
         ets, edge_names = _ets(

junifer/markers/functional_connectivity/edge_functional_connectivity_spheres.py

@@ -4,11 +4,14 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Optional, Union
+from typing import Any, Literal
+
+from pydantic import PositiveFloat
 
 from ...api.decorators import register_marker
+from ...datagrabber import DataType
 from ..sphere_aggregation import SphereAggregation
-from ..utils import _ets, raise_error
+from ..utils import _ets
 from .functional_connectivity_base import FunctionalConnectivityBase
 
 
@@ -24,40 +27,39 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
     coords : str
         The name of the coordinates list to use.
         See :func:`.list_data` for options.
-    radius : positive float, optional
-        The radius of the sphere around each coordinates in millimetres.
+    radius : ``zero`` or positive float or None, optional
+        The radius of the sphere in millimetres.
         If None, the signal will be extracted from a single voxel.
         See :class:`.JuniferNiftiSpheresMasker` for more information
         (default None).
     allow_overlap : bool, optional
-        Whether to allow overlapping spheres. If False, an error is raised if
-        the spheres overlap (default False).
+        Whether to allow overlapping spheres.
+        If False, an error is raised if the spheres overlap (default False).
     agg_method : str, optional
-        The method to perform aggregation using.
+        The aggregation function to use.
         See :func:`.get_aggfunc_by_name` for options
         (default "mean").
     agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        See :func:`.get_aggfunc_by_name` for options
-        (default None).
+        The parameters to pass to the aggregation function.
+        See :func:`.get_aggfunc_by_name` for options (default None).
     conn_method : str, optional
-        The method to perform connectivity measure using.
+        The connectivity measure to use.
         See :class:`.JuniferConnectivityMeasure` for options
         (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+    conn_method_params : dict or None, optional
+        The parameters to pass to :class:`.JuniferConnectivityMeasure`.
         If None, ``{"empirical": True}`` will be used, which would mean
         :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
         covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
         desired, ``{"empirical": False}`` should be passed
         (default None).
-    masks : str, dict or list of dict or str, optional
+    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).
-    name : str, optional
-        The name of the marker. If None, will use
-        ``BOLD_EdgeCentricFCSpheres`` (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     References
     ----------
@@ -67,34 +69,12 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
 
     """
 
-    def __init__(
-        self,
-        coords: str,
-        radius: Optional[float] = None,
-        allow_overlap: bool = False,
-        agg_method: str = "mean",
-        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,
-        name: Optional[str] = None,
-    ) -> None:
-        self.coords = coords
-        self.radius = radius
-        self.allow_overlap = allow_overlap
-        if radius is None or radius <= 0:
-            raise_error(f"radius should be > 0: provided {radius}")
-        super().__init__(
-            agg_method=agg_method,
-            agg_method_params=agg_method_params,
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
-            masks=masks,
-            name=name,
-        )
+    coords: str
+    radius: Literal[0] | PositiveFloat | None = None
+    allow_overlap: bool = False
 
     def aggregate(
-        self, input: dict[str, Any], extra_input: Optional[dict] = None
+        self, input: dict[str, Any], extra_input: dict | None = None
     ) -> dict:
         """Perform sphere aggregation and ETS computation.
 
@@ -130,7 +110,7 @@ class EdgeCentricFCSpheres(FunctionalConnectivityBase):
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
-            on="BOLD",
+            on=DataType.BOLD,
         ).compute(input, extra_input=extra_input)
         # Compute edgewise timeseries
         ets, edge_names = _ets(

junifer/markers/functional_connectivity/functional_connectivity_base.py

@@ -4,14 +4,19 @@
 # License: AGPL
 
 from abc import abstractmethod
-from typing import Any, ClassVar, Optional, Union
+from typing import Annotated, Any, ClassVar
 
+import numpy as np
+from pydantic import BeforeValidator
 from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
+from ...datagrabber import DataType
 from ...external.nilearn import JuniferConnectivityMeasure
+from ...storage import MatrixKind, StorageType
 from ...typing import Dependencies, MarkerInOutMappings
-from ...utils import raise_error
+from ...utils import ensure_list_or_none, raise_error
 from ..base import BaseMarker
+from ..utils import _has_data
 
 
 __all__ = ["FunctionalConnectivityBase"]
@@ -23,67 +28,63 @@ class FunctionalConnectivityBase(BaseMarker):
     Parameters
     ----------
     agg_method : str, optional
-        The method to perform aggregation using.
-        Check valid options in :func:`.get_aggfunc_by_name`
+        The aggregation function to use.
+        See :func:`.get_aggfunc_by_name` for options
         (default "mean").
-    agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        Check valid options in :func:`.get_aggfunc_by_name`
-        (default None).
+    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).
     conn_method : str, optional
-        The method to perform connectivity measure using.
-        Check valid options in :class:`.JuniferConnectivityMeasure`
+        The connectivity measure to use.
+        See :class:`.JuniferConnectivityMeasure` for more information
         (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+    conn_method_params : dict or None, optional
+        The parameters to pass to :class:`.JuniferConnectivityMeasure`.
         If None, ``{"empirical": True}`` will be used, which would mean
         :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
         covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
         desired, ``{"empirical": False}`` should be passed
         (default None).
-    masks : str, dict or list of dict or str, optional
+    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).
-    name : str, optional
-        The name of the marker. If None, will use ``BOLD_<class_name>``
-        (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     """
 
     _DEPENDENCIES: ClassVar[Dependencies] = {"nilearn", "scikit-learn"}
 
     _MARKER_INOUT_MAPPINGS: ClassVar[MarkerInOutMappings] = {
-        "BOLD": {
-            "functional_connectivity": "matrix",
+        DataType.BOLD: {
+            "functional_connectivity": StorageType.Matrix,
         },
     }
 
-    def __init__(
-        self,
-        agg_method: str = "mean",
-        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,
-        name: Optional[str] = None,
-    ) -> None:
-        self.agg_method = agg_method
-        self.agg_method_params = agg_method_params
-        self.conn_method = conn_method
-        self.conn_method_params = conn_method_params or {}
+    agg_method: str = "mean"
+    agg_method_params: dict | None = None
+    conn_method: str = "correlation"
+    conn_method_params: dict | None = None
+    masks: Annotated[
+        dict | str | list[dict | str] | None,
+        BeforeValidator(ensure_list_or_none),
+    ] = None
+
+    def validate_marker_params(self) -> None:
+        """Run extra logical validation for marker."""
+        self.conn_method_params = self.conn_method_params or {}
         # Reverse of nilearn behavior
         self.conn_method_params["empirical"] = self.conn_method_params.get(
             "empirical", True
         )
-        self.masks = masks
-        super().__init__(on="BOLD", name=name)
 
     @abstractmethod
     def aggregate(
         self,
         input: dict[str, Any],
-        extra_input: Optional[dict[str, Any]] = None,
+        extra_input: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Perform aggregation."""
         raise_error(
@@ -94,7 +95,7 @@ class FunctionalConnectivityBase(BaseMarker):
     def compute(
         self,
         input: dict[str, Any],
-        extra_input: Optional[dict] = None,
+        extra_input: dict | None = None,
     ) -> dict:
         """Compute.
 
@@ -121,7 +122,7 @@ class FunctionalConnectivityBase(BaseMarker):
               - ``data`` : functional connectivity matrix as ``numpy.ndarray``
               - ``row_names`` : ROI labels as list of str
               - ``col_names`` : ROI labels as list of str
-              - ``matrix_kind`` : the kind of matrix (tril, triu or full)
+              - ``matrix_kind`` : :enum:`.MatrixKind`
 
         """
         # Perform necessary aggregation
@@ -141,18 +142,27 @@ class FunctionalConnectivityBase(BaseMarker):
                 if k != "empirical"
             },
         )
+        # Compute on the columns with data (e.g. regions lost in
+        # resampling have none) and set the others to NaN
+        data = aggregation["aggregation"]["data"]
+        has_data = _has_data(data)
+        conn = np.full((data.shape[1], data.shape[1]), np.nan)
+        if has_data.any():
+            conn[np.ix_(has_data, has_data)] = connectivity.fit_transform(
+                [data[:, has_data]]
+            )[0]
         # Create dictionary for output
         labels = aggregation["aggregation"]["col_names"]
         return {
             "functional_connectivity": {
-                "data": connectivity.fit_transform(
-                    [aggregation["aggregation"]["data"]]
-                )[0],
+                "data": conn,
                 "row_names": labels,
                 "col_names": labels,
                 # xi correlation coefficient is not symmetric
                 "matrix_kind": (
-                    "full" if self.conn_method == "xi correlation" else "tril"
+                    MatrixKind.Full
+                    if self.conn_method == "xi correlation"
+                    else MatrixKind.LowerTriangle
                 ),
             },
         }

junifer/markers/functional_connectivity/functional_connectivity_maps.py

@@ -3,9 +3,10 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
-from typing import Any, Optional, Union
+from typing import Any
 
 from ...api.decorators import register_marker
+from ...datagrabber import DataType
 from ..maps_aggregation import MapsAggregation
 from .functional_connectivity_base import FunctionalConnectivityBase
 
@@ -23,44 +24,30 @@ class FunctionalConnectivityMaps(FunctionalConnectivityBase):
         The name of the map(s) to use.
         See :func:`.list_data` for options.
     conn_method : str, optional
-        The method to perform connectivity measure using.
+        The connectivity measure to use.
         See :class:`.JuniferConnectivityMeasure` for options
         (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
+    conn_method_params : dict or None, optional
+        The parameters to pass to :class:`.JuniferConnectivityMeasure`.
         If None, ``{"empirical": True}`` will be used, which would mean
         :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
         covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
         desired, ``{"empirical": False}`` should be passed
         (default None).
-    masks : str, dict or list of dict or str, optional
+    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).
-    name : str, optional
-        The name of the marker. If None, will use
-        ``BOLD_FunctionalConnectivityMaps`` (default None).
+    name : str or None, optional
+        The name of the marker.
+        If None, will use the class name (default None).
 
     """
 
-    def __init__(
-        self,
-        maps: str,
-        conn_method: str = "correlation",
-        conn_method_params: Optional[dict] = None,
-        masks: Union[str, dict, list[Union[dict, str]], None] = None,
-        name: Optional[str] = None,
-    ) -> None:
-        self.maps = maps
-        super().__init__(
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
-            masks=masks,
-            name=name,
-        )
+    maps: str
 
     def aggregate(
-        self, input: dict[str, Any], extra_input: Optional[dict] = None
+        self, input: dict[str, Any], extra_input: dict | None = None
     ) -> dict:
         """Perform maps aggregation.
 
@@ -91,5 +78,5 @@ class FunctionalConnectivityMaps(FunctionalConnectivityBase):
         return MapsAggregation(
             maps=self.maps,
             masks=self.masks,
-            on="BOLD",
+            on=DataType.BOLD,
         ).compute(input=input, extra_input=extra_input)