Add Pulse Mean Accelerator indicator and related image, and update liquidity sweeps indicator with pivot tracking structures. Also update README and __init__.py files to include the new indicator.

MDUYN · MDUYN · commit 14ff5ef5b4ec · 2026-02-15T21:27:04.000+01:00
diff --git a/README.md b/README.md
@@ -498,6 +498,61 @@ pd_df.tail(10)
 
 ![SUPERTREND_CLUSTERING](https://github.com/coding-kitties/PyIndicators/blob/main/static/images/indicators/supertrend_clustering.png)
 
+#### Pulse Mean Accelerator (PMA)
+
+The Pulse Mean Accelerator is a trend-following overlay indicator
+translated from the Pine Script® by MisinkoMaster.  It adds a
+volatility- and momentum-scaled acceleration offset to a base moving
+average.  The acceleration accumulates over a configurable lookback:
+bars where source momentum exceeds MA momentum push the PMA further
+from the MA, while bars where the MA leads source momentum pull it
+back.  Multiple MA types (RMA, SMA, EMA, WMA, DEMA, TEMA, HMA),
+volatility measures (ATR, Standard Deviation, MAD), and smoothing
+modes are supported.
+
+**Parameters:**
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `source_column` | str | `"Close"` | Source price column |
+| `ma_type` | str | `"RMA"` | MA type: RMA, SMA, EMA, WMA, DEMA, TEMA, HMA |
+| `ma_length` | int | `20` | Lookback for the base moving average |
+| `accel_lookback` | int | `32` | Bars over which acceleration is accumulated |
+| `max_accel` | float | `0.2` | Maximum absolute acceleration factor |
+| `volatility_type` | str | `"Standard Deviation"` | Volatility: ATR, Standard Deviation, MAD |
+| `smooth_type` | str | `"Double Moving Average"` | Smoothing: NONE, Exponential, Extra Moving Average, Double Moving Average |
+| `use_confirmation` | bool | `True` | Require combined PMA+MA momentum to confirm trend flips |
+
+**Output columns:** `pma`, `pma_ma`, `pma_trend`, `pma_long`, `pma_short`, `pma_acceleration`
+
+```python
+import pandas as pd
+from pyindicators import (
+    pulse_mean_accelerator,
+    pulse_mean_accelerator_signal,
+    get_pulse_mean_accelerator_stats,
+)
+
+# --- With pandas ---
+df = pd.read_csv("data.csv")
+df = pulse_mean_accelerator(
+    df,
+    ma_type="RMA",
+    ma_length=20,
+    accel_lookback=32,
+    max_accel=0.2,
+    volatility_type="Standard Deviation",
+    smooth_type="Double Moving Average",
+    use_confirmation=True,
+)
+df = pulse_mean_accelerator_signal(df)
+stats = get_pulse_mean_accelerator_stats(df)
+print(stats)
+df[["Close", "pma", "pma_ma", "pma_trend", "pma_long", "pma_short"]].tail(10)
+```
+
+![PULSE_MEAN_ACCELERATOR](https://github.com/coding-kitties/PyIndicators/blob/main/static/images/indicators/pulse_mean_accelerator.png)
+
 ### Momentum and Oscillators
 
 Indicators that measure the strength and speed of price movements rather than the direction.
@@ -1983,6 +2038,8 @@ The function returns:
 - Mitigation signals a change in market structure; the zone is no longer valid
 - Increase `contact_count` for higher-quality, more reliable zones
 
+![LIQUIDITY_POOLS](https://github.com/coding-kitties/PyIndicators/blob/main/static/images/indicators/liquidity_pools.png)
+
 #### Liquidity Levels / Voids (VP)
 
 Liquidity Levels / Voids is a Smart Money Concept indicator that uses volume-profile analysis between swing points to identify price levels where little volume was traded — these are *liquidity voids* that price tends to revisit.
@@ -2063,6 +2120,8 @@ The function returns:
 - Use `liq_void_count` to gauge overall market imbalance
 - Decrease `detection_length` for more frequent void detection on shorter timeframes
 
+![LIQUIDITY_LEVELS_VOIDS](https://github.com/coding-kitties/PyIndicators/blob/main/static/images/indicators/liquidity_levels_voids.png)
+
 ### Pattern Recognition
 
 #### Detect Peaks
diff --git a/pyindicators/__init__.py b/pyindicators/__init__.py
@@ -33,7 +33,9 @@
     get_pure_price_action_liquidity_sweep_stats,
     liquidity_pools, liquidity_pool_signal, get_liquidity_pool_stats,
     liquidity_levels_voids, liquidity_levels_voids_signal,
-    get_liquidity_levels_voids_stats
+    get_liquidity_levels_voids_stats,
+    pulse_mean_accelerator, pulse_mean_accelerator_signal,
+    get_pulse_mean_accelerator_stats
 )
 from .exceptions import PyIndicatorException
 from .date_range import DateRange
@@ -139,5 +141,8 @@ def get_version():
     'get_liquidity_pool_stats',
     'liquidity_levels_voids',
     'liquidity_levels_voids_signal',
-    'get_liquidity_levels_voids_stats'
+    'get_liquidity_levels_voids_stats',
+    'pulse_mean_accelerator',
+    'pulse_mean_accelerator_signal',
+    'get_pulse_mean_accelerator_stats'
 ]
diff --git a/pyindicators/indicators/__init__.py b/pyindicators/indicators/__init__.py
@@ -67,6 +67,10 @@
     liquidity_levels_voids, liquidity_levels_voids_signal,
     get_liquidity_levels_voids_stats
 )
+from .pulse_mean_accelerator import (
+    pulse_mean_accelerator, pulse_mean_accelerator_signal,
+    get_pulse_mean_accelerator_stats
+)
 
 __all__ = [
     'sma',
@@ -154,5 +158,8 @@
     'get_liquidity_pool_stats',
     'liquidity_levels_voids',
     'liquidity_levels_voids_signal',
-    'get_liquidity_levels_voids_stats'
+    'get_liquidity_levels_voids_stats',
+    'pulse_mean_accelerator',
+    'pulse_mean_accelerator_signal',
+    'get_pulse_mean_accelerator_stats'
 ]
diff --git a/pyindicators/indicators/buyside_sellside_liquidity.py b/pyindicators/indicators/buyside_sellside_liquidity.py
@@ -67,7 +67,7 @@ def buyside_sellside_liquidity(
     Args:
         data: pandas or polars DataFrame with OHLC data.
         detection_length: Lookback period for pivot detection
-            (default: 7). Pine equivalent: ``ta.pivothigh(liqLen, 1)``.
+            (default: 7).
         margin: Divisor for the ATR margin band (default: 6.9).
             Effective margin = ``10 / margin * ATR(atr_period)``.
         buyside_margin: Multiplier for the breach zone around
diff --git a/pyindicators/indicators/liquidity_levels_voids.py b/pyindicators/indicators/liquidity_levels_voids.py
@@ -1,8 +1,7 @@
 """
 Liquidity Levels / Voids (Volume Profile) Indicator
 
-Based on the Liquidity Levels/Voids (VP) [LuxAlgo] concept from
-TradingView.  Uses volume-profile analysis between swing points to
+Uses volume-profile analysis between swing points to
 identify price levels where little volume was traded — these are
 *liquidity voids* that price tends to revisit.
 
@@ -86,8 +85,7 @@ def liquidity_levels_voids(
     Args:
         data: pandas or polars DataFrame with OHLCV data.
         detection_length: Lookback/look-ahead period for swing
-            detection (default: 47).  Equivalent to Pine Script's
-            ``ppLen`` parameter.
+            detection (default: 47).
         threshold: Volume fraction below which a level is classified
             as a liquidity void (default: 0.21, i.e. 21 %).  A level
             is a void if its volume < ``threshold * max_volume_level``.
@@ -156,7 +154,7 @@ def liquidity_levels_voids(
     active_voids: list[list[float]] = []
 
     # Previous pivot bar index and previous HIGH/LOW values for
-    # swing comparison (mirrors pp.x, pp.x1 in Pine).
+    # swing comparison.
     prev_pivot_bar: int = -1
     prev_pivot_bar_2: int = -1
 
@@ -225,7 +223,7 @@ def liquidity_levels_voids(
 
                                 # Check if already filled in the
                                 # interval from vp_start to current
-                                # bar (mirrors Pine's fill loop)
+                                # bar
                                 filled_already = False
                                 mid = (lev_bot + lev_top) / 2.0
                                 fill_start = -1
diff --git a/pyindicators/indicators/liquidity_pools.py b/pyindicators/indicators/liquidity_pools.py
@@ -1,13 +1,10 @@
 """
 Liquidity Pools Indicator
 
-Faithful Python translation of the **Liquidity Pools [LuxAlgo]**
-indicator from TradingView (Pine Script v5, Oct 16 2024, 332 lines).
-
 Identifies liquidity pool zones by analysing high and low wicked
 price areas, the number of contacts, and the frequency of visits.
 
-Algorithm overview (matching Pine Script exactly)
+Algorithm overview
 -------------------------------------------------
 1. Track a *highest* (``hst``) and *lowest* (``lst``) reference
    candle.  On each bar, adjust these references when price makes
@@ -19,8 +16,8 @@
    body level must be stable (unchanged for 2 bars).
 
 3. When enough contacts accumulate (``contact_count``) and the
-   bars-since-last-wick counter crosses above ``confirmation_bars``
-   (``ta.crossover(bs_hw, wait)`` in Pine), AND the close is on
+   bars-since-last-wick counter crosses above ``confirmation_bars``,
+   AND the close is on
    the correct side of the reference body level, a zone is created.
 
 4. Zone creation uses a *running zone* pattern (``h_zn`` / ``l_zn``)
@@ -31,7 +28,7 @@
    - No overlap -> create a fresh running zone and push to array.
 
 5. Zone extension: the most recent zone accumulates fractional volume
-   from every overlapping candle (``get_civ`` in Pine).
+   from every overlapping candle.
 
 6. Zone mitigation: when price closes beyond the zone boundary for
    two consecutive bars, the zone is removed.
@@ -55,10 +52,6 @@
 def _get_civ(h: float, lo: float, v: float,
              zone_top: float, zone_bot: float) -> float:
     """Return the fraction of candle volume that lies inside *zone*.
-
-    Mirrors Pine Script's ``get_civ`` helper:
-    ``nz((_h - _l) / _r, 1) * volume`` where _h/_l are clamped to
-    the zone boundaries.
     """
     r = h - lo
     if r <= 0:
@@ -94,17 +87,11 @@ def liquidity_pools(
 ) -> Union[PdDataFrame, PlDataFrame]:
     """Detect Liquidity Pool zones on OHLC(V) data.
 
-    Faithful translation of:
-    *Liquidity Pools [LuxAlgo]* -- Pine Script v5, Oct 16 2024.
-
     Args:
         data: pandas or polars DataFrame with OHLC(V) data.
         contact_count: Minimum wick contacts required to form a zone
-            (Pine: ``cNum``, default 2).
         gap_bars: Minimum bars between successive contacts
-            (Pine: ``gapCount``, default 5).
         confirmation_bars: Bars to wait before confirming a zone
-            (Pine: ``wait``, default 10).
         high_column: Column name for highs.
         low_column: Column name for lows.
         open_column: Column name for opens.
@@ -188,7 +175,6 @@ def liquidity_pools(
             return pl.from_pandas(df)
         return df
 
-    # -- Pine: var declarations (persistent across bars) --------------
     c_top_0 = max(opens[0], closes[0])
     c_bot_0 = min(opens[0], closes[0])
 
@@ -210,7 +196,6 @@ def liquidity_pools(
     hi_vol = 0.0    # var float hi_vol = 0
     lo_vol = 0.0    # var float lo_vol = 0
 
-    # Running zones (Pine: var zn h_zn, l_zn -- initially na)
     # Each: {top, bottom, state, vol, start_bar, right_bar} or None
     h_zn = None
     l_zn = None
@@ -219,11 +204,10 @@ def liquidity_pools(
     bull_zones: list[dict] = []
     bear_zones: list[dict] = []
 
-    # Pine: var int bs_hw = 0, bs_lw = 0
+    # var int bs_hw = 0, bs_lw = 0
     bs_hw = 0
     bs_lw = 0
 
-    # Previous-bar references for Pine [1] / [2] lookbacks
     prev_h_wick = False
     prev_l_wick = False
     hst_t_1ago = hst["t"]
@@ -244,8 +228,6 @@ def liquidity_pools(
         c_bot = min(o, c)
 
         # -- 1. Adjusting High and Low Check Boundaries ---------------
-        # Pine: if (high > hst.h) and ((c_top > hst.h) or
-        #        (c_top < hst.t))
         if h > hst["h"] and (c_top > hst["h"] or c_top < hst["t"]):
             if h_count > 1:
                 # Reset low reference to current candle
@@ -264,8 +246,6 @@ def liquidity_pools(
             h_count = 1
             last_h_wick = bar
 
-        # Pine: if (low < lst.l) and ((c_bot < lst.l) or
-        #        (c_bot > lst.b))
         if lo < lst["l"] and (c_bot < lst["l"] or c_bot > lst["b"]):
             if l_count > 1:
                 # Reset high reference to current candle
@@ -285,43 +265,34 @@ def liquidity_pools(
             last_l_wick = bar
 
         # -- 2. Compute wicks for current bar -------------------------
-        # Pine: h_wick = high > hst.t and c_top <= hst.t
         h_wick = (h > hst["t"]) and (c_top <= hst["t"])
-        # Pine: l_wick = low < lst.b and c_bot >= lst.b
         l_wick = (lo < lst["b"]) and (c_bot >= lst["b"])
 
-        # -- 3. Counting contacts (Pine uses [1] / [2] refs) ---------
-        # Pine: if (h_wick[1] and (hst.t[1] == hst.t[2])
-        #         and (bs_hw > gapCount))
+        # -- 3. Counting contacts ---------
         if (prev_h_wick
                 and hst_t_1ago == hst_t_2ago
                 and prev_bs_hw > gap_bars):
             h_count += 1
             last_h_wick = bar - 1
 
-        # Pine: if (l_wick[1] and (lst.b[1] == lst.b[2])
-        #         and (bs_lw > gapCount))
         if (prev_l_wick
                 and lst_b_1ago == lst_b_2ago
                 and prev_bs_lw > gap_bars):
             l_count += 1
             last_l_wick = bar - 1
 
         # -- 4. Bars since last wick ----------------------------------
-        # Pine: bs_hw := math.abs(last_h_wick - bar_index)
         bs_hw = abs(last_h_wick - bar)
         bs_lw = abs(last_l_wick - bar)
 
         # -- 5. Track outer extremes ----------------------------------
-        # Pine: if (high > hst.h)  hst.h := high
         if h > hst["h"]:
             hst["h"] = h
-        # Pine: if (low < lst.l)  lst.l := low
+
         if lo < lst["l"]:
             lst["l"] = lo
 
         # -- 6. Volume tracking (reference-level volume) --------------
-        # Pine: hst_vol = max((high - hst.t), 0) / (high-low) * vol
         h_range = h - lo
         if h_range > 0:
             hi_vol += max(h - hst["t"], 0) / h_range * v
@@ -338,8 +309,6 @@ def liquidity_pools(
         )
 
         # -- 7a. Bearish pool (resistance) from high contacts ---------
-        # Pine: if (h_count >= cNum) and ta.crossover(bs_hw, wait)
-        #        and (close < hst.t)
         if (h_count >= contact_count
                 and hw_cross
                 and c < hst["t"]):
@@ -394,8 +363,6 @@ def liquidity_pools(
                 bear_zones.append(h_zn)
 
         # -- 7b. Bullish pool (support) from low contacts -------------
-        # Pine: if (l_count >= cNum) and ta.crossover(bs_lw, wait)
-        #        and (close > lst.b)
         if (l_count >= contact_count
                 and lw_cross
                 and c > lst["b"]):
@@ -460,7 +427,7 @@ def liquidity_pools(
             zb = z["bottom"]
 
             # Most recent zone: accumulate candle volume if
-            # overlapping (Pine get_civ) and extend line
+            # overlapping and extend line
             if i == len(bull_zones) - 1:
                 if c > zt:
                     z["right_bar"] = bar
@@ -488,7 +455,7 @@ def liquidity_pools(
             zb = z["bottom"]
 
             # Most recent zone: accumulate candle volume if
-            # overlapping (Pine get_civ) and extend line
+            # overlapping and extend line
             if i == len(bear_zones) - 1:
                 if c < zb:
                     z["right_bar"] = bar
diff --git a/pyindicators/indicators/liquidity_sweeps.py b/pyindicators/indicators/liquidity_sweeps.py
@@ -49,8 +49,6 @@ def liquidity_sweeps(
     A liquidity sweep occurs when price momentarily pierces a swing
     high or swing low—grabbing resting liquidity—before reversing.
 
-    Three detection modes mirror the Pine Script original:
-
     * ``"wicks"`` – only wick-through sweeps (high > swing high but
       close < swing high, or low < swing low but close > swing low).
     * ``"outbreak_retest"`` – only outbreak-and-retest sweeps (price
@@ -246,8 +244,7 @@ def _detect_pivot_highs(high: np.ndarray, length: int) -> np.ndarray:
     Detect pivot highs.  A pivot high at index *i* means
     ``high[i]`` >= all highs in ``[i-length … i+length]``.
 
-    The result is delayed by *length* bars (like Pine's
-    ``ta.pivothigh(len, len)``).
+    The result is delayed by *length* bars
     """
     n = len(high)
     pivots = np.full(n, np.nan)
@@ -302,7 +299,7 @@ def _liquidity_sweeps_pandas(
     pivot_lows = _detect_pivot_lows(low, swing_length)
 
     # ------------------------------------------------------------------ #
-    #  Pivot tracking structures (mirrors Pine Script UDT arrays)         #
+    #  Pivot tracking structures                                         #
     # ------------------------------------------------------------------ #
     # Each tracked pivot: {price, bar_idx, broken, mitigated, wick_used}
     tracked_highs: List[Dict] = []
diff --git a/pyindicators/indicators/pulse_mean_accelerator.py b/pyindicators/indicators/pulse_mean_accelerator.py
diff --git a/static/images/indicators/pulse_mean_accelerator.png b/static/images/indicators/pulse_mean_accelerator.png
