funcnodes-span 0.1.0__tar.gz

funcnodes_span-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: funcnodes-span
+Version: 0.1.0
+Summary: 
+Author: Kourosh Rezaei
+Author-email: kouroshrezaei90@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: funcnodes (>=0.2.21,<0.3.0)
+Requires-Dist: funcnodes_numpy (>=0.1.57,<0.2.0)
+Requires-Dist: funcnodes_pandas (>=0.1.9,<0.2.0)
+Requires-Dist: pooch (>=1.8.2,<2.0.0)
+Requires-Dist: scipy (>=1.14.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+

funcnodes_span-0.1.0/funcnodes_span/__init__.py

@@ -0,0 +1,16 @@
+import funcnodes as fn
+
+from .normalization import NORM_NODE_SHELF as NORM
+# from .basics import SMOOTH_NODE_SHELF as SMOOTH
+
+
+__version__ = "0.1.0"
+
+NODE_SHELF = fn.Shelf(
+    name="Spectral Analysis",
+    description="Spectral analysis for funcnodes",
+    nodes=[],
+    subshelves=[
+        NORM,
+    ],
+)

funcnodes_span-0.1.0/funcnodes_span/normalization.py

@@ -0,0 +1,58 @@
+from funcnodes import NodeDecorator, Shelf
+import numpy as np
+from enum import Enum
+
+
+class NormMode(Enum):
+    ZERO_ONE = "zero_one"
+    MINUS_ONE_ONE = "minus_one_one"
+    SUM_ABS = "sum_abs"
+    SUM = "sum"
+    EUCLIDEAN = "euclidean"
+    MEAN_STD = "mean_std"
+    MAX = "max"
+
+    @classmethod
+    def default(cls) -> "NormMode":
+        """Returns the default normalization mode."""
+        return cls.ZERO_ONE
+
+
+@NodeDecorator(id="span.basics.norm", name="Normalizations")
+def _norm(array: np.ndarray, mode: NormMode = NormMode.default()) -> np.ndarray:
+    # """
+    # Apply different normalizations to the array.
+
+    # Args:
+    #     array (np.ndarray): The input array to be normalized.
+    #     mode (NormMode): The normalization mode to apply. Defaults to NormMode.ZERO_ONE.
+
+    # Returns:
+    #     np.ndarray: The normalized array.
+
+    # Raises:
+    #     ValueError: If an unsupported normalization mode is provided.
+    # """
+    normalization_methods = {
+        NormMode.ZERO_ONE: lambda x: (x - np.amin(x)) / (np.amax(x) - np.amin(x)),
+        NormMode.MINUS_ONE_ONE: lambda x: 2
+        * ((x - np.amin(x)) / (np.amax(x) - np.amin(x)))
+        - 1,
+        NormMode.SUM_ABS: lambda x: x / np.abs(x).sum(),
+        NormMode.SUM: lambda x: x / x.sum(),
+        NormMode.EUCLIDEAN: lambda x: x / np.sqrt((x**2).sum()),
+        NormMode.MEAN_STD: lambda x: (x - x.mean()) / x.std(),
+        NormMode.MAX: lambda x: x / x.max(),
+    }
+    if mode not in normalization_methods:
+        raise ValueError(f"Unsupported normalization mode: {mode}")
+
+    return normalization_methods[mode](array)
+
+
+NORM_NODE_SHELF = Shelf(
+    nodes=[_norm],
+    subshelves=[],
+    name="Normalization",
+    description="Normalization of the spectra",
+)

funcnodes_span-0.1.0/funcnodes_span/smoothing.py

@@ -0,0 +1,189 @@
+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
+
+warnings.filterwarnings("ignore")
+
+class SmoothMode(Enum):
+    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
+
+@NodeDecorator("span.basics.smooth", name="Smoothing")
+
+def _smooth(array: np.ndarray, mode: SmoothMode = SmoothMode.default(), window: int = 5) -> np.ndarray:
+    # """
+    # Apply different smoothing techniques to the input array.
+
+    # Args:
+    #     array (np.ndarray): The input array to be smoothed.
+    #     mode (SmoothMode): The smoothing mode to apply. Defaults to SmoothMode.SAVITZKY_GOLAY.
+    #     window (int): The window size for the smoothing function. Defaults to 5.
+
+    # Returns:
+    #     np.ndarray: The smoothed array.
+
+    # Raises:
+    #     ValueError: If an unsupported smoothing mode is provided.
+    # """
+    
+    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: smooth_savgol,
+        SmoothMode.GAUSSIAN: smooth_gaussian,
+        SmoothMode.MOVING_AVERAGE: smooth_ma,
+        SmoothMode.EXPONENTIAL_MOVING_AVERAGE: smooth_ema,
+        SmoothMode.MEDIAN: smooth_median
+    }
+    
+    if mode not in smoothing_methods:
+        raise ValueError(f"Unsupported smoothing mode: {mode}")
+    
+    return smoothing_methods[mode](array)
+
+
+# @NodeDecorator("span.basics.smooth.savgol", name="Savgol")
+# def _smooth_savgol(array: np.array, window: int = 5) -> np.array:
+#     """
+#     Apply Savitzky-Golay smoothing to the input array.
+
+#     Args:
+#         window (int): Parameter passed to scipy.signal.savgol_filter function
+
+#     Returns:
+#         array_o (np.array): Smoothed array
+#     """
+
+#     array_o = savgol_filter(array, window, 2)
+
+#     return array_o
+
+
+# @NodeDecorator("span.basics.smooth.gaussian", name="Gaussian")
+# def _smooth_gaussian(array: np.array, window: int = 5) -> np.array:
+#     """
+#     Apply Gaussians moothing to the input array.
+
+#     Args:
+#         window (int): Parameter passed to scipy.signal.savgol_filter function
+
+#     Returns:
+#         array_o (np.array): Smoothed array
+#     """
+
+#     array_o = gaussian_filter1d(array, window)
+
+#     return array_o
+
+
+# @NodeDecorator("span.basics.smooth.ma", name="Moving average")
+# def _smooth_ma(array: np.array, window: int = 5) -> np.array:
+#     """
+#     Apply Moving Average moothing to the input array.
+
+#     Args:
+#         window (int): Parameter passed to scipy.signal.savgol_filter function
+
+#     Returns:
+#         array_o (np.array): Smoothed array
+#     """
+
+#     if array.ndim > 1:
+#         n, m = array.shape
+#         array_o = np.zeros((n, m))
+#         for i in range(n):
+#             array_o[i, :] = np.convolve(
+#                 array[i, :], np.ones(window) / window, mode="same"
+#             )
+#     else:
+#         array_o = np.convolve(array, np.ones(window) / window, mode="same")
+
+#     return array_o
+
+
+# @NodeDecorator(
+#     "span.basics.smooth.ema", name="Exponential moving average"
+# )
+# def _smooth_ema(array: np.array, window: int = 5) -> np.array:
+#     """
+#     Apply Exponential Moving Average moothing to the input array.
+
+#     Args:
+#         window (int): Parameter passed to scipy.signal.savgol_filter function
+
+#     Returns:
+#         array_o (np.array): Smoothed array
+#     """
+#     if array.ndim > 1:
+#         n, m = array.shape
+#         array_o = np.zeros((n, m))
+#         for i in range(n):
+#             array_o[i, :] = pd.Series(array[i, :]).ewm(span=window).mean().values
+#     else:
+#         array_o = pd.Series(array).ewm(span=window).mean().values
+
+#     return array_o
+
+
+# @NodeDecorator("span.basics.smooth.median", name="Median")
+# def _smooth_median(array: np.array, window: int = 5) -> np.array:
+#     """
+#     Apply Median smoothing to the input array.
+
+#     Args:
+#         window (int): Parameter passed to scipy.signal.savgol_filter function
+
+#     Returns:
+#         array_o (np.array): Smoothed array
+#     """
+
+#     array_o = medfilt(array, window)
+
+#     return array_o
+
+
+SMOOTH_NODE_SHELF = Shelf(
+    nodes=[_smooth],
+    subshelves=[],
+    name="Smoothing",
+    description="Smoothing of the spectra",
+)

funcnodes_span-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "funcnodes-span"
+version = "0.1.0"
+description = ""
+authors = ["Kourosh Rezaei <kouroshrezaei90@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+scipy = "^1.14.0"
+funcnodes = "^0.2.21"
+funcnodes_numpy = "^0.1.57"
+funcnodes_pandas = "^0.1.9"
+pooch = "^1.8.2"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.2.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"