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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funcnodes-span
-Version: 0.2.0
+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.2.0 → 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.2.0"
+__version__ = "0.2.1"
 
 NODE_SHELF = fn.Shelf(
     name="Spectral Analysis",

{funcnodes_span-0.2.0 → 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, 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,
@@ -1540,15 +1530,11 @@ def _noise_median(
     return baseline_corrected, baseline, params
 
 
-class Side(Enum):
+class Side(fn.DataEnum):
     both = "both"
     left = "left"
     right = "right"
 
-    @classmethod
-    def default(cls):
-        return cls.both.value
-
 
 @NodeDecorator(
     "pybaselines.smooth.ria",
@@ -1566,13 +1552,12 @@ def _ria(
     half_window: Optional[int] = None,
     max_iter: int = 500,
     tol: float = 0.01,
-    side: Side = Side.default(),
+    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]:
-    if isinstance(side, Side):
-        side = side.value
+    side = Side.v(side)
     baseline, params = pybaselines.smooth.ria(
         data,
         x_data=x_data,
@@ -1936,14 +1921,10 @@ CLASSIFICATION_NODE_SHELF = Shelf(
 )
 
 
-class Method(Enum):
+class Method(fn.DataEnum):
     modpoly = "modpoly"
     imodpoly = "imodpoly"
 
-    @classmethod
-    def default(cls):
-        return cls.modpoly.value
-
 
 @NodeDecorator(
     "pybaselines.optimizers.adaptive_minmax",
@@ -1961,14 +1942,13 @@ def _adaptive_minmax(
     data: np.ndarray,
     x_data: Optional[np.ndarray] = None,
     poly_order: Optional[Union[int, List[int]]] = None,
-    method: Method = Method.default(),
+    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]:
-    if isinstance(method, Method):
-        method = method.value
+    method = Method.v(method)
     baseline, params = pybaselines.optimizers.adaptive_minmax(
         data,
         x_data=x_data,
@@ -1983,7 +1963,7 @@ def _adaptive_minmax(
     return baseline_corrected, baseline, params
 
 
-class MethodColab(Enum):
+class MethodColab(fn.DataEnum):
     airpls = "airpls"
     arpls = "arpls"
     asls = "asls"
@@ -1994,10 +1974,6 @@ class MethodColab(Enum):
     iasls = "iasls"
     psalsa = "psalsa"
 
-    @classmethod
-    def default(cls):
-        return cls.asls.value
-
 
 @NodeDecorator(
     "pybaselines.optimizers.collab_pls",
@@ -2015,10 +1991,9 @@ def _collab_pls(
     data: np.ndarray,
     x_data: Optional[np.ndarray] = None,
     average_dataset: bool = True,
-    method: MethodColab = MethodColab.default(),
+    method: MethodColab = MethodColab.asls,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(method, MethodColab):
-        method = method.value
+    method = MethodColab.v(method)
     baseline, params = pybaselines.optimizers.collab_pls(
         data,
         x_data=x_data,
@@ -2029,7 +2004,7 @@ def _collab_pls(
     return baseline_corrected, baseline, params
 
 
-class MethodAll(Enum):
+class MethodAll(fn.DataEnum):
     goldindec = "goldindec"
     imodpoly = "imodpoly"
     loess = "loess"
@@ -2076,10 +2051,6 @@ class MethodAll(Enum):
     rubberband = "rubberband"
     std_distribution = "std_distribution"
 
-    @classmethod
-    def default(cls):
-        return cls.asls.value
-
 
 @NodeDecorator(
     "pybaselines.optimizers.custom_bc",
@@ -2097,10 +2068,9 @@ def _custom_bc(
     sampling: Union[int, np.ndarray] = 1,
     lam: Optional[float] = None,
     diff_order: int = 2,
-    method: MethodAll = MethodAll.default(),
+    method: MethodAll = MethodAll.asls,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(method, MethodAll):
-        method = method.value
+    method = MethodAll.v(method)
     baseline, params = pybaselines.optimizers.custom_bc(
         data,
         x_data=x_data,
@@ -2128,19 +2098,17 @@ def _custom_bc(
 def _optimize_extended_range(
     data: np.ndarray,
     x_data: Optional[np.ndarray] = None,
-    side: Side = Side.default(),
+    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.default(),
+    method: MethodAll = MethodAll.asls,
 ) -> Tuple[np.ndarray, np.ndarray, dict]:
-    if isinstance(method, MethodAll):
-        method = method.value
-    if isinstance(side, Side):
-        side = side.value
+    method = MethodAll.v(method)
+    side = Side.v(side)
     baseline, params = pybaselines.optimizers.optimize_extended_range(
         data,
         x_data=x_data,

{funcnodes_span-0.2.0 → 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.2.0 → 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.2.0 → 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.2.0 → funcnodes_span-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "funcnodes-span"
-version = "0.2.0"
+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 = "*"