funcnodes-span 0.1.22__tar.gz → 0.2.1__tar.gz

{funcnodes_span-0.1.22 → funcnodes_span-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funcnodes-span
-Version: 0.1.22
+Version: 0.2.1
 Summary: 
 Home-page: https://linkdlab.de/
 Author: Kourosh Rezaei
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: Numba
 Requires-Dist: funcnodes
-Requires-Dist: funcnodes-core (>=0.1.3)
+Requires-Dist: funcnodes-core (>=0.1.4)
 Requires-Dist: funcnodes_numpy
 Requires-Dist: funcnodes_pandas
 Requires-Dist: funcnodes_plotly

{funcnodes_span-0.1.22 → funcnodes_span-0.2.1}/funcnodes_span/__init__.py

@@ -5,7 +5,7 @@ from .smoothing import SMOOTH_NODE_SHELF as SMOOTH
 from .peak_analysis import PEAKS_NODE_SHELF as PEAK
 from .baseline import BASELINE_NODE_SHELF as BASELINE
 
-__version__ = "0.1.22"
+__version__ = "0.2.1"
 
 NODE_SHELF = fn.Shelf(
     name="Spectral Analysis",

{funcnodes_span-0.1.22 → funcnodes_span-0.2.1}/funcnodes_span/baseline.py

@@ -1,20 +1,16 @@
+import funcnodes as fn
 from funcnodes import NodeDecorator, Shelf
 from exposedfunctionality import controlled_wrapper
 import numpy as np
-from enum import Enum
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Union, List
 import pybaselines
 
 
-class CostFunction(Enum):
+class CostFunction(fn.DataEnum):
     asymmetric_indec = "asymmetric_indec"
     asymmetric_truncated_quadratic = "asymmetric_truncated_quadratic"
     asymmetric_huber = "asymmetric_huber"
 
-    @classmethod
-    def default(cls):
-        return cls.asymmetric_indec.value
-
 
 @NodeDecorator(
     "pybaselines.polynomial.goldindec",
@@ -33,7 +29,7 @@ def _goldindec(
     tol: float = 0.001,
     max_iter: int = 250,
     weights: Optional[np.ndarray] = None,
-    cost_function: CostFunction = CostFunction.default(),
+    cost_function: CostFunction = CostFunction.asymmetric_indec,
     peak_ratio: float = 0.5,
     alpha_factor: float = 0.99,
     tol_2: float = 0.001,
@@ -41,8 +37,7 @@ def _goldindec(
     max_iter_2: int = 100,
     return_coef: bool = False,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(cost_function, CostFunction):
-        cost_function = cost_function.value
+    cost_function = CostFunction.v(cost_function)
     baseline, params = pybaselines.polynomial.goldindec(
         data,
         x_data=x_data,
@@ -186,7 +181,7 @@ def _modpoly(
     return baseline_corrected, baseline, params
 
 
-class PenalizedPolyCostFunction(Enum):
+class PenalizedPolyCostFunction(fn.DataEnum):
     asymmetric_truncated_quadratic = "asymmetric_truncated_quadratic"
     symmetric_truncated_quadratic = "symmetric_truncated_quadratic"
     asymmetric_huber = "asymmetric_huber"
@@ -194,10 +189,6 @@ class PenalizedPolyCostFunction(Enum):
     asymmetric_indec = "asymmetric_indec"
     symmetric_indec = "symmetric_indec"
 
-    @classmethod
-    def default(cls):
-        return cls.asymmetric_truncated_quadratic.value
-
 
 @NodeDecorator(
     "pybaselines.polynomial.penalized_poly",
@@ -218,13 +209,12 @@ def _penalized_poly(
     max_iter: int = 250,
     tol: float = 1e-3,
     weights: Optional[np.ndarray] = None,
-    cost_function: PenalizedPolyCostFunction = PenalizedPolyCostFunction.default(),
+    cost_function: PenalizedPolyCostFunction = PenalizedPolyCostFunction.asymmetric_truncated_quadratic,
     threshold: Optional[float] = None,
     alpha_factor: float = 0.99,
     return_coef: bool = False,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(cost_function, PenalizedPolyCostFunction):
-        cost_function = cost_function.value
+    cost_function = PenalizedPolyCostFunction.v(cost_function)
     baseline, params = pybaselines.polynomial.penalized_poly(
         data,
         x_data=x_data,
@@ -1480,6 +1470,667 @@ SPLINE_NODE_SHELF = Shelf(
 )
 
 
+@NodeDecorator(
+    "pybaselines.smooth.ipsa",
+    name="ipsa",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(pybaselines.smooth.ipsa, wrapper_attribute="__fnwrapped__")
+def _ipsa(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    half_window: Optional[int] = None,
+    max_iter: int = 500,
+    tol: Optional[float] = None,
+    roi: Optional[np.ndarray] = None,
+    original_criteria: bool = False,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.smooth.ipsa(
+        data,
+        x_data=x_data,
+        max_iter=max_iter,
+        half_window=half_window,
+        roi=roi,
+        tol=tol,
+        original_criteria=original_criteria,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.smooth.noise_median",
+    name="noise_median",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(pybaselines.smooth.noise_median, wrapper_attribute="__fnwrapped__")
+def _noise_median(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    half_window: Optional[int] = None,
+    smooth_half_window: Optional[int] = None,
+    sigma: Optional[float] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.smooth.noise_median(
+        data,
+        x_data=x_data,
+        smooth_half_window=smooth_half_window,
+        half_window=half_window,
+        sigma=sigma,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+class Side(fn.DataEnum):
+    both = "both"
+    left = "left"
+    right = "right"
+
+
+@NodeDecorator(
+    "pybaselines.smooth.ria",
+    name="ria",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(pybaselines.smooth.ria, wrapper_attribute="__fnwrapped__")
+def _ria(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    half_window: Optional[int] = None,
+    max_iter: int = 500,
+    tol: float = 0.01,
+    side: Side = Side.both,
+    width_scale: float = 0.1,
+    height_scale: float = 1.0,
+    sigma_scale: float = 1.0 / 12.0,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    side = Side.v(side)
+    baseline, params = pybaselines.smooth.ria(
+        data,
+        x_data=x_data,
+        max_iter=max_iter,
+        tol=tol,
+        half_window=half_window,
+        side=side,
+        width_scale=width_scale,
+        height_scale=height_scale,
+        sigma_scale=sigma_scale,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.smooth.snip",
+    name="snip",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(pybaselines.smooth.snip, wrapper_attribute="__fnwrapped__")
+def _snip(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    decreasing: bool = False,
+    smooth_half_window: Optional[int] = None,
+    filter_order: int = 2,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.smooth.snip(
+        data,
+        x_data=x_data,
+        decreasing=decreasing,
+        smooth_half_window=smooth_half_window,
+        filter_order=filter_order,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.smooth.swima",
+    name="swima",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(pybaselines.smooth.swima, wrapper_attribute="__fnwrapped__")
+def _swima(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    min_half_window: int = 3,
+    max_half_window: Optional[int] = None,
+    smooth_half_window: Optional[int] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.smooth.swima(
+        data,
+        x_data=x_data,
+        min_half_window=min_half_window,
+        smooth_half_window=smooth_half_window,
+        max_half_window=max_half_window,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+SMOOTH_NODE_SHELF = Shelf(
+    nodes=[_ipsa, _noise_median, _ria, _snip, _swima],
+    subshelves=[],
+    name="Smooth",
+    description="Fits a smooth baseline",
+)
+
+
+@NodeDecorator(
+    "pybaselines.classification.cwt_br",
+    name="cwt_br",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.classification.cwt_br, wrapper_attribute="__fnwrapped__"
+)
+def _cwt_br(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    poly_order: int = 5,
+    scale: Optional[np.ndarray] = None,
+    num_std: float = 1.0,
+    min_length: int = 2,
+    max_iter: int = 50,
+    tol: float = 0.001,
+    symmetric: bool = False,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.classification.cwt_br(
+        data,
+        x_data=x_data,
+        poly_order=poly_order,
+        scale=scale,
+        num_std=num_std,
+        min_length=min_length,
+        max_iter=max_iter,
+        tol=tol,
+        symmetric=symmetric,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.classification.dietrich",
+    name="dietrich",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.classification.dietrich, wrapper_attribute="__fnwrapped__"
+)
+def _dietrich(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    smooth_half_window: Optional[int] = None,
+    interp_half_window: int = 5,
+    poly_order: int = 5,
+    max_iter: int = 50,
+    tol: float = 0.001,
+    num_std: float = 1.0,
+    min_length: int = 2,
+    return_coef: bool = False,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.classification.dietrich(
+        data,
+        x_data=x_data,
+        poly_order=poly_order,
+        smooth_half_window=smooth_half_window,
+        num_std=num_std,
+        min_length=min_length,
+        max_iter=max_iter,
+        tol=tol,
+        interp_half_window=interp_half_window,
+        return_coef=return_coef,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.classification.fabc",
+    name="fabc",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(pybaselines.classification.fabc, wrapper_attribute="__fnwrapped__")
+def _fabc(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    lam: float = 1000000.0,
+    scale: Optional[np.ndarray] = None,
+    num_std: float = 3.0,
+    diff_order: int = 2,
+    min_length: int = 2,
+    weights_as_mask: bool = False,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.classification.fabc(
+        data,
+        x_data=x_data,
+        lam=lam,
+        scale=scale,
+        num_std=num_std,
+        min_length=min_length,
+        diff_order=diff_order,
+        weights_as_mask=weights_as_mask,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.classification.fastchrom",
+    name="fastchrom",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.classification.fastchrom, wrapper_attribute="__fnwrapped__"
+)
+def _fastchrom(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    half_window: Optional[int] = None,
+    threshold: Optional[float] = None,
+    min_fwhm: Optional[int] = None,
+    interp_half_window: int = 5,
+    smooth_half_window: Optional[int] = None,
+    max_iter: int = 100,
+    min_length: int = 2,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.classification.fastchrom(
+        data,
+        x_data=x_data,
+        half_window=half_window,
+        threshold=threshold,
+        min_fwhm=min_fwhm,
+        min_length=min_length,
+        max_iter=max_iter,
+        smooth_half_window=smooth_half_window,
+        interp_half_window=interp_half_window,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.classification.golotvin",
+    name="golotvin",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.classification.golotvin, wrapper_attribute="__fnwrapped__"
+)
+def _golotvin(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    half_window: Optional[int] = None,
+    num_std: float = 2.0,
+    sections: int = 32,
+    threshold: Optional[float] = None,
+    interp_half_window: int = 5,
+    smooth_half_window: Optional[int] = None,
+    min_length: int = 2,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.classification.golotvin(
+        data,
+        x_data=x_data,
+        half_window=half_window,
+        threshold=threshold,
+        num_std=num_std,
+        min_length=min_length,
+        sections=sections,
+        smooth_half_window=smooth_half_window,
+        interp_half_window=interp_half_window,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.classification.rubberband",
+    name="rubberband",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.classification.rubberband, wrapper_attribute="__fnwrapped__"
+)
+def _rubberband(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    segments: Union[int, np.ndarray] = 1,
+    lam: Optional[float] = None,
+    diff_order: int = 2,
+    smooth_half_window: Optional[int] = None,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.classification.rubberband(
+        data,
+        x_data=x_data,
+        segments=segments,
+        lam=lam,
+        diff_order=diff_order,
+        smooth_half_window=smooth_half_window,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.classification.std_distribution",
+    name="std_distribution",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.classification.std_distribution, wrapper_attribute="__fnwrapped__"
+)
+def _std_distribution(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    half_window: Optional[int] = None,
+    interp_half_window: int = 5,
+    fill_half_window: int = 3,
+    num_std: float = 1.1,
+    smooth_half_window: Optional[int] = None,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    baseline, params = pybaselines.classification.std_distribution(
+        data,
+        x_data=x_data,
+        half_window=half_window,
+        interp_half_window=interp_half_window,
+        fill_half_window=fill_half_window,
+        smooth_half_window=smooth_half_window,
+        num_std=num_std,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+CLASSIFICATION_NODE_SHELF = Shelf(
+    nodes=[
+        _cwt_br,
+        _dietrich,
+        _fabc,
+        _fastchrom,
+        _golotvin,
+        _rubberband,
+        _std_distribution,
+    ],
+    subshelves=[],
+    name="Classification",
+    description="Fits a classification baseline",
+)
+
+
+class Method(fn.DataEnum):
+    modpoly = "modpoly"
+    imodpoly = "imodpoly"
+
+
+@NodeDecorator(
+    "pybaselines.optimizers.adaptive_minmax",
+    name="adaptive_minmax",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.optimizers.adaptive_minmax, wrapper_attribute="__fnwrapped__"
+)
+def _adaptive_minmax(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    poly_order: Optional[Union[int, List[int]]] = None,
+    method: Method = Method.modpoly,
+    constrained_fraction: Union[float, List[float]] = 0.01,
+    constrained_weight: Union[float, List[float]] = 100000.0,
+    estimation_poly_order: int = 2,
+    weights: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    method = Method.v(method)
+    baseline, params = pybaselines.optimizers.adaptive_minmax(
+        data,
+        x_data=x_data,
+        poly_order=poly_order,
+        constrained_fraction=constrained_fraction,
+        constrained_weight=constrained_weight,
+        method=method,
+        estimation_poly_order=estimation_poly_order,
+        weights=weights,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+class MethodColab(fn.DataEnum):
+    airpls = "airpls"
+    arpls = "arpls"
+    asls = "asls"
+    aspls = "aspls"
+    derpsalsa = "derpsalsa"
+    drpls = "drpls"
+    iarpls = "iarpls"
+    iasls = "iasls"
+    psalsa = "psalsa"
+
+
+@NodeDecorator(
+    "pybaselines.optimizers.collab_pls",
+    name="collab_pls",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.optimizers.collab_pls, wrapper_attribute="__fnwrapped__"
+)
+def _collab_pls(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    average_dataset: bool = True,
+    method: MethodColab = MethodColab.asls,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    method = MethodColab.v(method)
+    baseline, params = pybaselines.optimizers.collab_pls(
+        data,
+        x_data=x_data,
+        method=method,
+        average_dataset=average_dataset,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+class MethodAll(fn.DataEnum):
+    goldindec = "goldindec"
+    imodpoly = "imodpoly"
+    loess = "loess"
+    modpoly = "modpoly"
+    penalizedpoly = "penalizedpoly"
+    poly = "poly"
+    quant_reg = "quant_reg"
+    airpls = "airpls"
+    arpls = "arpls"
+    asls = "asls"
+    aspls = "aspls"
+    derpsalsa = "derpsalsa"
+    drpls = "drpls"
+    iarpls = "iarpls"
+    iasls = "iasls"
+    psalsa = "psalsa"
+    amormol = "amormol"
+    imor = "imor"
+    jbcd = "jbcd"
+    mor = "mor"
+    mormol = "mormol"
+    mpls = "mpls"
+    mpspline = "mpspline"
+    mwmv = "mwmv"
+    rolling_ball = "rolling_ball"
+    tophat = "tophat"
+    corner_cutting = "corner_cutting"
+    irsqr = "irsqr"
+    mixture_model = "mixture_model"
+    pspline_airpls = "pspline_airpls"
+    pspline_asls = "pspline_asls"
+    pspline_aspls = "pspline_aspls"
+    pspline_derpsalsa = "pspline_derpsalsa"
+    pspline_drpls = "pspline_drpls"
+    pspline_iarpls = "pspline_iarpls"
+    pspline_iasls = "pspline_iasls"
+    pspline_mpls = "pspline_mpls"
+    pspline_psalsa = "pspline_psalsa"
+    cwt_br = "cwt_br"
+    dietrich = "dietrich"
+    fabc = "fabc"
+    fastchrom = "fastchrom"
+    golotvin = "golotvin"
+    rubberband = "rubberband"
+    std_distribution = "std_distribution"
+
+
+@NodeDecorator(
+    "pybaselines.optimizers.custom_bc",
+    name="custom_bc",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(pybaselines.optimizers.custom_bc, wrapper_attribute="__fnwrapped__")
+def _custom_bc(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    sampling: Union[int, np.ndarray] = 1,
+    lam: Optional[float] = None,
+    diff_order: int = 2,
+    method: MethodAll = MethodAll.asls,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    method = MethodAll.v(method)
+    baseline, params = pybaselines.optimizers.custom_bc(
+        data,
+        x_data=x_data,
+        diff_order=diff_order,
+        lam=lam,
+        method=method,
+        sampling=sampling,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+@NodeDecorator(
+    "pybaselines.optimizers.optimize_extended_range",
+    name="optimize_extended_range",
+    outputs=[
+        {"name": "baseline_corrected"},
+        {"name": "baseline"},
+        {"name": "params"},
+    ],
+)
+@controlled_wrapper(
+    pybaselines.optimizers.optimize_extended_range, wrapper_attribute="__fnwrapped__"
+)
+def _optimize_extended_range(
+    data: np.ndarray,
+    x_data: Optional[np.ndarray] = None,
+    side: Side = Side.both,
+    width_scale: float = 0.1,
+    height_scale: float = 1.0,
+    sigma_scale: float = 1.0 / 12.0,
+    min_value: float = 2.0,
+    max_value: float = 8.0,
+    step: int = 1,
+    method: MethodAll = MethodAll.asls,
+) -> Tuple[np.ndarray, np.ndarray, dict]:
+    method = MethodAll.v(method)
+    side = Side.v(side)
+    baseline, params = pybaselines.optimizers.optimize_extended_range(
+        data,
+        x_data=x_data,
+        width_scale=width_scale,
+        height_scale=height_scale,
+        method=method,
+        min_value=min_value,
+        sigma_scale=sigma_scale,
+        max_value=max_value,
+        step=step,
+    )
+    baseline_corrected = data - baseline
+    return baseline_corrected, baseline, params
+
+
+OPTIMIZERS_NODE_SHELF = Shelf(
+    nodes=[_adaptive_minmax, _collab_pls, _custom_bc, _optimize_extended_range],
+    subshelves=[],
+    name="Optimizers",
+    description="Fits a optimizers baseline",
+)
+
 BASELINE_NODE_SHELF = Shelf(
     nodes=[],
     subshelves=[
@@ -1487,6 +2138,9 @@ BASELINE_NODE_SHELF = Shelf(
         WHITTAKER_NODE_SHELF,
         MORPHOLOGICAL_NODE_SHELF,
         SPLINE_NODE_SHELF,
+        SMOOTH_NODE_SHELF,
+        CLASSIFICATION_NODE_SHELF,
+        OPTIMIZERS_NODE_SHELF,
     ],
     name="Baseline correction",
     description="Provides different techniques for fitting baselines to experimental data using pybaselines.",

{funcnodes_span-0.1.22 → funcnodes_span-0.2.1}/funcnodes_span/normalization.py

@@ -1,9 +1,10 @@
 from funcnodes import NodeDecorator, Shelf
 import numpy as np
-from enum import Enum
 
+import funcnodes as fn
 
-class NormMode(Enum):
+
+class NormMode(fn.DataEnum):
     ZERO_ONE = "zero_one"
     MINUS_ONE_ONE = "minus_one_one"
     SUM_ABS = "sum_abs"
@@ -12,14 +13,9 @@ class NormMode(Enum):
     MEAN_STD = "mean_std"
     MAX = "max"
 
-    @classmethod
-    def default(cls) -> "NormMode":
-        """Returns the default normalization mode."""
-        return cls.ZERO_ONE.value
-
 
 @NodeDecorator(id="span.basics.norm", name="Normalization node")
-def _norm(array: np.ndarray, mode: NormMode = NormMode.default()) -> np.ndarray:
+def _norm(array: np.ndarray, mode: NormMode = NormMode.ZERO_ONE) -> np.ndarray:
     # """
     # Apply different normalizations to the array.
 
@@ -33,21 +29,23 @@ def _norm(array: np.ndarray, mode: NormMode = NormMode.default()) -> np.ndarray:
     # Raises:
     #     ValueError: If an unsupported normalization mode is provided.
     # """
-    if isinstance(mode, NormMode):
-        mode = mode.value
+    mode = NormMode.v(mode)
     normalization_methods = {
         NormMode.ZERO_ONE.value: lambda x: (x - np.amin(x)) / (np.amax(x) - np.amin(x)),
-        NormMode.MINUS_ONE_ONE.value: lambda x: 2 * ((x - np.amin(x)) / (np.amax(x) - np.amin(x))) - 1,
+        NormMode.MINUS_ONE_ONE.value: lambda x: 2
+        * ((x - np.amin(x)) / (np.amax(x) - np.amin(x)))
+        - 1,
         NormMode.SUM_ABS.value: lambda x: x / np.abs(x).sum(),
         NormMode.SUM.value: lambda x: x / x.sum(),
         NormMode.EUCLIDEAN.value: lambda x: x / np.sqrt((x**2).sum()),
         NormMode.MEAN_STD.value: lambda x: (x - x.mean()) / x.std(),
-        NormMode.MAX.value: lambda x: x / x.max()
+        NormMode.MAX.value: lambda x: x / x.max(),
     }
     if mode not in normalization_methods.keys():
         raise ValueError(f"Unsupported normalization mode: {mode}")
     return normalization_methods[mode](array)
 
+
 NORM_NODE_SHELF = Shelf(
     nodes=[_norm],
     subshelves=[],

{funcnodes_span-0.1.22 → funcnodes_span-0.2.1}/funcnodes_span/peak_analysis.py

@@ -1,8 +1,8 @@
 from funcnodes import NodeDecorator, Shelf
+import funcnodes as fn
 import numpy as np
-from enum import Enum
 from exposedfunctionality import controlled_wrapper
-from typing import Optional, List, Tuple
+from typing import Optional, List, Tuple, Dict
 from scipy.signal import find_peaks
 from scipy.stats import norm
 from scipy import signal, interpolate
@@ -15,6 +15,14 @@ import re
 from dataclasses import dataclass
 
 
+@dataclass
+class FittinInfo:
+    model_name: str
+    best_values: dict
+    data: np.ndarray
+    userkws: dict
+
+
 @dataclass
 class PeakProperties:
     id: str
@@ -35,8 +43,8 @@ class PeakProperties:
     width: float
     _is_fitted: bool = False
     _is_force_fitted: bool = False
-    fitting_data: Optional[dict] = None
-    fitting_info: Optional[dict] = None
+    fitting_data: Optional[Dict[str, np.ndarray]] = None
+    fitting_info: Optional[FittinInfo] = None
 
 
 def compute_peak_properties(
@@ -46,25 +54,27 @@ def compute_peak_properties(
     peak_nr: int,
     is_fitted: bool = False,
     is_force_fitted: bool = False,
-    fitting_data: Optional[dict] = None,
-    fitting_info: Optional[dict] = None,
+    fitting_data: Optional[Dict[str, np.ndarray]] = None,
+    fitting_info: Optional[FittinInfo] = None,
 ) -> PeakProperties:
-    # """
-    # Compute various properties of a given peak.
-
-    # Parameters:
-    # - x_array: np.ndarray - The array of x-values (e.g., time or wavelength).
-    # - y_array: np.ndarray - The array of y-values (e.g., intensity).
-    # - peak_indices: List[int] - A list containing the start index, peak index, and end index of the peak.
-    # - peak_nr: int - The identifier number of the peak.
-    # - is_fitted: bool = False - A flag indicating whether the peak is fitted or not.
-    # - is_force_fitted: bool = False - A flag indicating whether the peak is forced fitted or not.
-    # - fitting_data: Optional[dict] = None - A dictionary containing the fitting data if the peak is fitted.
-    # - fitting_info: Optional[dict] = None - A dictionary containing the fitting information if the peak is fitted.
-
-    # Returns:
-    # - peak_properties: PeakProperties - A dictionary containing various properties of the peak.
-    # """
+    """
+    Compute various properties of a given peak.
+
+    Parameters:
+    - x_array: np.ndarray - The array of x-values (e.g., time or wavelength).
+    - y_array: np.ndarray - The array of y-values (e.g., intensity).
+    - peak_indices: List[int] - A list containing the start index, peak index, and end index of the peak.
+    - peak_nr: int - The identifier number of the peak.
+    - is_fitted: bool = False - A flag indicating whether the peak is fitted or not.
+    - is_force_fitted: bool = False - A flag indicating whether the peak is forced fitted or not.
+    - fitting_data: Optional[Dict[str, np.ndarray]] = None - A dictionary containing the fitting
+        data if the peak is fitted.
+    - fitting_info: Optional[FittinInfo] = None - A dictionary containing the fitting information
+        if the peak is fitted.
+
+    Returns:
+    - peak_properties: PeakProperties - A dictionary containing various properties of the peak.
+    """
 
     i_index, index, f_index = peak_indices
 
@@ -198,7 +208,7 @@ def peak_finder(
     wlen: Optional[int] = None,
     rel_height: float = 0.5,
     plateau_size: Optional[int] = None,
-) -> dict:
+) -> List[PeakProperties]:
     peak_lst = []
     x_array = np.array(x_array, dtype=float)
     y_array = np.array(y_array, dtype=float)
@@ -331,7 +341,7 @@ def interpolation_1d(
     return x_interpolated, y_interpolated
 
 
-class FittingModel(Enum):
+class FittingModel(fn.DataEnum):
     ComplexConstant = "Complex Constant"
     Gaussian = "Gaussian"
     Gaussian2D = "Gaussian-2D"
@@ -356,12 +366,8 @@ class FittingModel(Enum):
     Rectangle = "Rectangle"
     Expression = "Expression"
 
-    @classmethod
-    def default(cls):
-        return cls.Gaussian.value
 
-
-class BaselineModel(Enum):
+class BaselineModel(fn.DataEnum):
     # Polynomial = "Polynomial"
     Linear = "Linear"
     Spline = "Spline"
@@ -374,13 +380,13 @@ class BaselineModel(Enum):
         return cls.Exponential.value
 
 
-@NodeDecorator(id="span.basics.fit", name="Fit 1D")
+@NodeDecorator(id="span.basics.fit", name="Fit 1D", separate_process=True)
 def fit_1D(
     x_array: np.ndarray,
     y_array: np.ndarray,
     basic_peaks: List[PeakProperties],
-    main_model: FittingModel = FittingModel.default(),
-    baseline_model: BaselineModel = BaselineModel.default(),
+    main_model: FittingModel = FittingModel.Gaussian,
+    baseline_model: BaselineModel = BaselineModel.Exponential,
 ) -> List[PeakProperties]:
     # """
     # Fit a 1D model to the given data.
@@ -405,10 +411,9 @@ def fit_1D(
     x_array = np.array(x_array)
     y_array = np.array(y_array)
 
-    if isinstance(main_model, FittingModel):
-        main_model = main_model.value
-    if isinstance(baseline_model, BaselineModel):
-        baseline_model = baseline_model.value
+    main_model = FittingModel.v(main_model)
+
+    baseline_model = BaselineModel.v(baseline_model)
     peaks = copy.deepcopy(basic_peaks)
     y = y_array
     x = x_array
@@ -473,8 +478,15 @@ def fit_1D(
 
     out = f.fit(y, pars, x=x)
     com = out.eval_components(x=x)
-    info_dict = out.__dict__
-    info_dict["model_name"] = main_model
+    # info_dict = out.__dict__
+    # info_dict["model_name"] = main_model
+
+    info_dict = FittinInfo(
+        model_name=main_model,
+        best_values=out.best_values,
+        data=out.data,
+        userkws=out.userkws,
+    )
 
     peak_properties_list = []
 

{funcnodes_span-0.1.22 → funcnodes_span-0.2.1}/funcnodes_span/smoothing.py

@@ -1,28 +1,70 @@
+from typing import Dict, Callable
 from funcnodes import NodeDecorator, Shelf
 import numpy as np
 import pandas as pd
-from enum import Enum
 from scipy.signal import savgol_filter, medfilt
 from scipy.ndimage import gaussian_filter1d
 import warnings
+import funcnodes as fn
 
 warnings.filterwarnings("ignore")
 
-class SmoothMode(Enum):
+
+class SmoothMode(fn.DataEnum):
     SAVITZKY_GOLAY = "savgol"
     GAUSSIAN = "gaussian"
     MOVING_AVERAGE = "ma"
     EXPONENTIAL_MOVING_AVERAGE = "ema"
     MEDIAN = "median"
-    
-    @classmethod
-    def default(cls) -> 'SmoothMode':
-        """Returns the default smoothing mode."""
-        return cls.SAVITZKY_GOLAY.value
 
-@NodeDecorator("span.basics.smooth", name="Smoothing")
 
-def _smooth(array: np.ndarray, mode: SmoothMode = SmoothMode.default(), window: int = 5) -> np.ndarray:
+def smooth_savgol(x: np.ndarray, window: int) -> np.ndarray:
+    return savgol_filter(x, window, 2)
+
+
+def smooth_gaussian(x: np.ndarray, window: int) -> np.ndarray:
+    return gaussian_filter1d(x, window)
+
+
+def smooth_ma(x: np.ndarray, window: int) -> np.ndarray:
+    if x.ndim > 1:
+        n, m = x.shape
+        result = np.zeros((n, m))
+        for i in range(n):
+            result[i, :] = np.convolve(x[i, :], np.ones(window) / window, mode="same")
+        return result
+    else:
+        return np.convolve(x, np.ones(window) / window, mode="same")
+
+
+def smooth_ema(x: np.ndarray, window: int) -> np.ndarray:
+    if x.ndim > 1:
+        n, m = x.shape
+        result = np.zeros((n, m))
+        for i in range(n):
+            result[i, :] = pd.Series(x[i, :]).ewm(span=window).mean().values
+        return result
+    else:
+        return pd.Series(x).ewm(span=window).mean().values
+
+
+def smooth_median(x: np.ndarray, window: int) -> np.ndarray:
+    return medfilt(x, window)
+
+
+_SMOOTHING_MAPPER: Dict[str, Callable[[np.ndarray, int], np.ndarray]] = {
+    SmoothMode.SAVITZKY_GOLAY.value: smooth_savgol,
+    SmoothMode.GAUSSIAN.value: smooth_gaussian,
+    SmoothMode.MOVING_AVERAGE.value: smooth_ma,
+    SmoothMode.EXPONENTIAL_MOVING_AVERAGE.value: smooth_ema,
+    SmoothMode.MEDIAN.value: smooth_median,
+}
+
+
+@NodeDecorator("span.basics.smooth", name="Smoothing")
+def _smooth(
+    array: np.ndarray, mode: SmoothMode = SmoothMode.SAVITZKY_GOLAY, window: int = 5
+) -> np.ndarray:
     # """
     # Apply different smoothing techniques to the input array.
 
@@ -37,49 +79,12 @@ def _smooth(array: np.ndarray, mode: SmoothMode = SmoothMode.default(), window:
     # Raises:
     #     ValueError: If an unsupported smoothing mode is provided.
     # """
-    if isinstance(mode, SmoothMode):
-        mode = mode.value
-    def smooth_savgol(x: np.ndarray) -> np.ndarray:
-        return savgol_filter(x, window, 2)
-    
-    def smooth_gaussian(x: np.ndarray) -> np.ndarray:
-        return gaussian_filter1d(x, window)
-    
-    def smooth_ma(x: np.ndarray) -> np.ndarray:
-        if x.ndim > 1:
-            n, m = x.shape
-            result = np.zeros((n, m))
-            for i in range(n):
-                result[i, :] = np.convolve(x[i, :], np.ones(window) / window, mode="same")
-            return result
-        else:
-            return np.convolve(x, np.ones(window) / window, mode="same")
-    
-    def smooth_ema(x: np.ndarray) -> np.ndarray:
-        if x.ndim > 1:
-            n, m = x.shape
-            result = np.zeros((n, m))
-            for i in range(n):
-                result[i, :] = pd.Series(x[i, :]).ewm(span=window).mean().values
-            return result
-        else:
-            return pd.Series(x).ewm(span=window).mean().values
-    
-    def smooth_median(x: np.ndarray) -> np.ndarray:
-        return medfilt(x, window)
-    
-    smoothing_methods = {
-        SmoothMode.SAVITZKY_GOLAY.value: smooth_savgol,
-        SmoothMode.GAUSSIAN.value: smooth_gaussian,
-        SmoothMode.MOVING_AVERAGE.value: smooth_ma,
-        SmoothMode.EXPONENTIAL_MOVING_AVERAGE.value: smooth_ema,
-        SmoothMode.MEDIAN.value: smooth_median
-    }
-    
-    if mode not in smoothing_methods.keys():
+    mode = SmoothMode.v(mode)
+
+    if mode not in _SMOOTHING_MAPPER.keys():
         raise ValueError(f"Unsupported smoothing mode: {mode}")
-    
-    return smoothing_methods[mode](array)
+
+    return _SMOOTHING_MAPPER[mode](array, window)
 
 
 # @NodeDecorator("span.basics.smooth.savgol", name="Savgol")
@@ -187,4 +192,4 @@ SMOOTH_NODE_SHELF = Shelf(
     subshelves=[],
     name="Smoothing",
     description="Smoothing of the spectra",
-)
+)

{funcnodes_span-0.1.22 → funcnodes_span-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "funcnodes-span"
-version = "0.1.22"
+version = "0.2.1"
 description = ""
 authors = ["Kourosh Rezaei <kouroshrezaei90@gmail.com>"]
 readme = "README.md"
@@ -15,7 +15,7 @@ funcnodes_numpy = "*"
 funcnodes_pandas = "*"
 funcnodes_plotly = "*"
 
-funcnodes-core = ">=0.1.3"
+funcnodes-core = ">=0.1.4"
 pybaselines = "*"
 Numba = "*"
 pentapy = "*"