siglab-py 0.5.30__py3-none-any.whl → 0.6.16__py3-none-any.whl

siglab_py/tests/unit/simple_math_tests.py

@@ -0,0 +1,252 @@
+import unittest
+from typing import List, Dict, Union
+
+from numpy import equal
+
+from util.simple_math import generate_rand_nums, round_to_level, compute_adjacent_levels, bucket_series, bucketize_val
+
+class SimpleMathTests(unittest.TestCase):
+
+    def test_generate_rand_nums(self):
+        range_min : float = 0
+        range_max : float = 1
+        size : int = 100
+        percentage_in_range : float = 91
+        abs_min : float = -0.5
+        abs_max : float = 1.1
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+
+        range_min = -1
+        range_max  = 1
+        percentage_in_range = 91
+        abs_min = -1.5
+        abs_max = 1.5
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+
+        range_min = 0
+        range_max  = 100
+        percentage_in_range = 91
+        abs_min = -150
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+
+        range_min = -100
+        range_max  = 100
+        percentage_in_range = 91
+        abs_min = -150
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+        
+        assert(len(rand_nums)==size)
+        assert(len([x for x in rand_nums if x>=range_min and x<=range_max]) == (percentage_in_range/100) * size)
+        assert(len([x for x in rand_nums if x<abs_min or x>abs_max]) == 0)
+
+    def test_round_to_level(self):
+        prices = [ 
+            { 'price' : 15080, 'rounded' : 15000}, 
+            { 'price' : 15180, 'rounded' : 15200}, 
+            { 'price' : 25080, 'rounded' : 25200}, 
+            { 'price' : 25180, 'rounded' : 25200}, 
+            { 'price' : 25380, 'rounded' : 25500}, 
+            { 'price' : 95332, 'rounded' : 95000}, 
+            { 'price' : 95878, 'rounded' : 96000}, 
+            { 'price' : 103499, 'rounded' : 103000}, 
+            { 'price' : 103500, 'rounded' : 104000}, 
+            { 'price' : 150800, 'rounded' : 150000}, 
+            { 'price' : 151800, 'rounded' : 152000}
+        ]
+        for entry in prices:
+            price = entry['price']
+            expected = entry['rounded']
+            rounded_price = round_to_level(price, level_granularity=0.01)
+            print(f"{price} rounded to: {rounded_price}")
+            assert(rounded_price==expected)
+
+    def test_compute_adjacent_levels(self):
+        gold_price = 4450
+        level_granularity = 0.025 # So levels are $100 apart
+        adjacent_levels = compute_adjacent_levels(num=gold_price, level_granularity=level_granularity, num_levels_per_side=3)
+        assert(adjacent_levels)
+        assert(len(adjacent_levels)==7)
+        equal(adjacent_levels, [4100,4200,4300,4400,4500,4600,4700])
+
+        btc_price = 95000
+        level_granularity = 0.01 # So levels are $1000 apart
+        adjacent_levels = compute_adjacent_levels(num=btc_price, level_granularity=level_granularity, num_levels_per_side=3)
+        assert(adjacent_levels)
+        assert(len(adjacent_levels)==7)
+        equal(adjacent_levels, [92000,93000,94000,95000,96000,97000,98000])
+
+    def test_bucket_series(self):
+
+        level_granularity : float = 0.1
+
+        range_min : float = 0
+        range_max : float = 1
+        size : int = 100
+        percentage_in_range : float = 91
+        abs_min : float = -0.5
+        abs_max : float = 1.1
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets : Dict[
+            str, 
+            Dict[str,Union[float, List[float]]]
+        ] = bucket_series(
+                                                values = rand_nums,
+                                                outlier_threshold_percent = 10,
+                                                level_granularity=level_granularity
+                                            )
+        
+        bucketized = []
+        for num in rand_nums:
+            bucketized.append(
+                bucketize_val(num, buckets=buckets)
+            )
+
+        
+        range_min = -1
+        range_max = 1
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = -1.5
+        abs_max = 1.5
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )
+        
+
+        range_min = 0
+        range_max = 100
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = -0.5
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )
+        
+
+        range_min = -100
+        range_max = 100
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = -150
+        abs_max = 150
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )
+        
+
+        range_min = 20_000
+        range_max = 120_000
+        size : int = 100
+        percentage_in_range = 91
+        abs_min = 15_000
+        abs_max = 130_000
+
+        rand_nums : List[float] = generate_rand_nums(
+                                        range_min = range_min,
+                                        range_max = range_max,
+                                        size = size, 
+                                        percent_in_range = percentage_in_range,
+                                        abs_min = abs_min,
+                                        abs_max = abs_max
+                                    )
+
+        buckets = bucket_series(
+                                    values = rand_nums,
+                                    outlier_threshold_percent = 10,
+                                    level_granularity=level_granularity
+                                )

siglab_py/tests/unit/trading_util_tests.py

@@ -63,24 +63,3 @@ class TradingUtilTests(unittest.TestCase):
             default_effective_tp_trailing_percent = default_effective_tp_trailing_percent
         )
         assert(effective_tp_trailing_percent==0) # Most tight trailing SL
-
-    def test_round_to_level(self):
-        prices = [ 
-            { 'price' : 15080, 'rounded' : 15000}, 
-            { 'price' : 15180, 'rounded' : 15200}, 
-            { 'price' : 25080, 'rounded' : 25200}, 
-            { 'price' : 25180, 'rounded' : 25200}, 
-            { 'price' : 25380, 'rounded' : 25500}, 
-            { 'price' : 95332, 'rounded' : 95000}, 
-            { 'price' : 95878, 'rounded' : 96000}, 
-            { 'price' : 103499, 'rounded' : 103000}, 
-            { 'price' : 103500, 'rounded' : 104000}, 
-            { 'price' : 150800, 'rounded' : 150000}, 
-            { 'price' : 151800, 'rounded' : 152000}
-        ]
-        for entry in prices:
-            price = entry['price']
-            expected = entry['rounded']
-            rounded_price = round_to_level(price, level_granularity=0.01)
-            print(f"{price} rounded to: {rounded_price}")
-            assert(rounded_price==expected)

siglab_py/util/analytic_util.py

@@ -11,9 +11,48 @@ from hurst import compute_Hc # compatible with pypy
 from ccxt.base.exchange import Exchange as CcxtExchange
 from ccxt import deribit
 
+from siglab_py.util.simple_math import bucket_series, bucketize_val
 from siglab_py.util.market_data_util import fix_column_types
 from siglab_py.constants import TrendDirection
 
+def classify_candle(
+    candle : pd.Series,
+    min_candle_height_ratio : float = 5,
+    distance_from_mid_doji_threshold_bps : float = 10
+) -> Union[str, None]:
+    candle_class : Union[str, None] = None
+    open = candle['open']
+    high = candle['high']
+    low = candle['low']
+    close = candle['close']
+    candle_full_height = high - low # always positive
+    candle_body_height = close - open # can be negative
+    candle_full_mid = (high + low)/2
+    candle_body_mid = (open + close)/2
+    distance_from_mid_bps = (candle_full_mid/candle_body_mid -1)*10000 if candle_full_mid>candle_body_mid else (candle_body_mid/candle_full_mid -1)*10000
+
+    candle_height_ratio = candle_full_height / abs(candle_body_height) if candle_body_height!=0 else float('inf')
+
+    if (
+        candle_height_ratio>=min_candle_height_ratio
+        and close>low
+    ):
+        candle_class = 'hammer'
+    elif (
+        candle_height_ratio>=min_candle_height_ratio
+        and close<high
+    ):
+        candle_class = 'shooting_star'
+    elif(
+        candle_height_ratio>=min_candle_height_ratio
+        and distance_from_mid_bps<=distance_from_mid_doji_threshold_bps
+    ):
+        candle_class = 'doji'
+
+    # Keep add more ...
+
+    return candle_class
+
 # Fibonacci
 MAGIC_FIB_LEVELS = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1.00, 1.618, 2.618, 3.618, 4.236]
 
@@ -83,14 +122,15 @@ def trend_from_lows(series: np.ndarray) -> float:
 '''
 compute_candles_stats will calculate typical/basic technical indicators using in many trading strategies:
     a. Basic SMA/EMAs (And slopes)
-    b. ATR
-    c. Boillenger bands (Yes incorrect spelling sorry)
-    d. FVG
-    e. Hurst Exponent
-    f. RSI, MFI
-    g. MACD
-    h. Fibonacci
-    i. Inflections points: where 'close' crosses EMA from above or below.
+    b. EMA crosses
+    c. ATR
+    d. Boillenger bands (Yes incorrect spelling sorry)
+    e. FVG
+    f. Hurst Exponent
+    g. RSI, MFI
+    h. MACD
+    i. Fibonacci
+    j. Inflections points: where 'close' crosses EMA from above or below.
 
 Parameters:
     a. boillenger_std_multiples: For boillenger upper and lower calc
@@ -119,7 +159,14 @@ def compute_candles_stats(
         target_fib_level : float = 0.618,
         pypy_compat : bool = True
         ):
+    BUCKETS_m0_100 = bucket_series(
+						values=list([i for i in range(0,100)]), 
+						outlier_threshold_percent=10, 
+						level_granularity=0.1
+					)
+    
     pd_candles['candle_height'] = pd_candles['high'] - pd_candles['low']
+    pd_candles['candle_body_height'] = pd_candles['close'] - pd_candles['open']
 
     '''
     market_data_gizmo inserted dummy lines --> Need exclude those or "TypeError: unorderable types for comparison": pd_btc_candles = pd_btc_candles[pd_btc_candles.close.notnull()]
@@ -136,12 +183,13 @@ def compute_candles_stats(
 
     pd_candles['is_green'] =  pd_candles['close'] >= pd_candles['open']
 
+    pd_candles['candle_class'] = pd_candles.apply(lambda row: classify_candle(row), axis=1) # type: ignore
+
     close_short_periods_rolling = pd_candles['close'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio))
     close_long_periods_rolling = pd_candles['close'].rolling(window=sliding_window_how_many_candles)
     close_short_periods_ewm = pd_candles['close'].ewm(span=int(sliding_window_how_many_candles/slow_fast_interval_ratio), adjust=False)
     close_long_periods_ewm = pd_candles['close'].ewm(span=sliding_window_how_many_candles, adjust=False)
 
-
     pd_candles['pct_change_close'] = pd_candles['close'].pct_change() * 100
     pd_candles['sma_short_periods'] = close_short_periods_rolling.mean()
     pd_candles['sma_long_periods'] = close_long_periods_rolling.mean()
@@ -157,6 +205,9 @@ def compute_candles_stats(
     pd_candles['candle_height_percent'] = pd_candles['candle_height'] / pd_candles['ema_close'] * 100
     pd_candles['candle_height_percent_rounded'] = pd_candles['candle_height_percent'].round().astype('Int64')
 
+    pd_candles['candle_body_height_percent'] = pd_candles['candle_body_height'] / pd_candles['ema_close'] * 100
+    pd_candles['candle_body_height_percent_rounded'] = pd_candles['candle_body_height_percent'].round().astype('Int64')
+
     '''
     To annualize volatility:
         if candle_interval == '1m':
@@ -168,6 +219,8 @@ def compute_candles_stats(
         pd_candles['annualized_volatility'] = (
             pd_candles['interval_historical_volatility'] * annualization_factor
         )
+
+    Why log return? Trading Dude https://python.plainenglish.io/stop-using-percentage-returns-logarithmic-returns-explained-with-code-64a4634b883a
     '''
     pd_candles['log_return'] = np.log(pd_candles['close'] / pd_candles['close'].shift(1))
     pd_candles['interval_hist_vol'] = pd_candles['log_return'].rolling(window=sliding_window_how_many_candles).std()
@@ -178,7 +231,6 @@ def compute_candles_stats(
     annualization_factor = np.sqrt(candles_per_year)
     pd_candles['annualized_hist_vol'] = pd_candles['interval_hist_vol'] * annualization_factor
 
-
     pd_candles['chop_against_ema'] = (
         (~pd_candles['is_green'] & (pd_candles['close'] > pd_candles['ema_close'])) |  # Case 1: Green candle and close > EMA
         (pd_candles['is_green'] & (pd_candles['close'] < pd_candles['ema_close']))   # Case 2: Red candle and close < EMA
@@ -199,22 +251,29 @@ def compute_candles_stats(
     bearish_ema_crosses = (ema_short_periods_prev >= ema_long_periods_prev) & (ema_short_periods_curr < ema_long_periods_curr)
     pd_candles.loc[bullish_ema_crosses, 'ema_cross'] = 1
     pd_candles.loc[bearish_ema_crosses, 'ema_cross'] = -1
-    pd_candles['ema_bullish_cross_last_id'] = pd_candles['ema_cross'].rolling(window=sliding_window_how_many_candles).apply(lambda x : x.idxmax())
-    pd_candles['ema_bearish_cross_last_id'] = pd_candles['ema_cross'].rolling(window=sliding_window_how_many_candles).apply(lambda x : x.idxmin())
-    pd_candles['ema_cross_last'] = np.where(
-        pd_candles['ema_bullish_cross_last_id'] > pd_candles['ema_bearish_cross_last_id'],
-        'bullish',
-        np.where(
-            pd_candles['ema_bearish_cross_last_id'] > pd_candles['ema_bullish_cross_last_id'],
-            'bearish',
-            None # type: ignore
-        )
-    )
-
-    pd_candles['ema_cross_last'] = pd_candles['ema_cross_last'].where(
-        pd_candles['ema_bullish_cross_last_id'].isnull() & pd_candles['ema_bearish_cross_last_id'].isnull(),
-        None
-    )
+    bullish_indices = pd.Series(pd_candles.index.where(pd_candles['ema_cross'] == 1), index=pd_candles.index).astype('Int64')
+    bearish_indices = pd.Series(pd_candles.index.where(pd_candles['ema_cross'] == -1), index=pd_candles.index).astype('Int64')
+    pd_candles['ema_bullish_cross_last_id'] = bullish_indices.rolling(window=pd_candles.shape[0], min_periods=1).max().astype('Int64')
+    pd_candles['ema_bearish_cross_last_id'] = bearish_indices.rolling(window=pd_candles.shape[0], min_periods=1).max().astype('Int64')
+    conditions = [
+        (pd_candles['ema_bullish_cross_last_id'].notna() & 
+        pd_candles['ema_bearish_cross_last_id'].notna() &
+        (pd_candles['ema_bullish_cross_last_id'] > pd_candles['ema_bearish_cross_last_id'])),
+        
+        (pd_candles['ema_bullish_cross_last_id'].notna() & 
+        pd_candles['ema_bearish_cross_last_id'].notna() &
+        (pd_candles['ema_bearish_cross_last_id'] > pd_candles['ema_bullish_cross_last_id'])),
+        
+        (pd_candles['ema_bullish_cross_last_id'].notna() & 
+        pd_candles['ema_bearish_cross_last_id'].isna()),
+        
+        (pd_candles['ema_bearish_cross_last_id'].notna() & 
+        pd_candles['ema_bullish_cross_last_id'].isna())
+    ]
+    choices = ['bullish', 'bearish', 'bullish', 'bearish']
+    pd_candles['ema_cross_last'] = np.select(conditions, choices, default=None) # type: ignore
+    pd_candles.loc[bullish_ema_crosses, 'ema_cross'] = 'bullish'
+    pd_candles.loc[bearish_ema_crosses, 'ema_cross'] = 'bearish'
 
     pd_candles['max_short_periods'] = close_short_periods_rolling.max()
     pd_candles['max_long_periods'] = close_long_periods_rolling.max()
@@ -226,6 +285,11 @@ def compute_candles_stats(
     pd_candles['idmin_short_periods'] = close_short_periods_rolling.apply(lambda x : x.idxmin())
     pd_candles['idmin_long_periods'] = close_long_periods_rolling.apply(lambda x : x.idxmin())
 
+    pd_candles['max_candle_body_height_percent_long_periods'] = pd_candles['candle_body_height_percent'].rolling(window=sliding_window_how_many_candles).max()
+    pd_candles['idmax_candle_body_height_percent_long_periods'] = pd_candles['candle_body_height_percent'].rolling(window=sliding_window_how_many_candles).apply(lambda x : x.idxmax())
+    pd_candles['min_candle_body_height_percent_long_periods'] = pd_candles['candle_body_height_percent'].rolling(window=sliding_window_how_many_candles).min()
+    pd_candles['idmin_candle_body_height_percent_long_periods'] = pd_candles['candle_body_height_percent'].rolling(window=sliding_window_how_many_candles).apply(lambda x : x.idxmin())
+
     pd_candles['price_swing_short_periods'] = np.where(
         pd_candles['idmax_short_periods'] > pd_candles['idmin_short_periods'],
         pd_candles['max_short_periods'] - pd_candles['min_short_periods'],  # Up swing
@@ -311,14 +375,14 @@ def compute_candles_stats(
                 first_breach_index = aggressive_mask.idxmax()
                 candle_high = pd_candles.at[first_breach_index, 'high'] 
                 candle_low = pd_candles.at[first_breach_index, 'low']
-                candle_height = candle_high - candle_low
+                candle_height = candle_high - candle_low  # type: ignore
         else:
             aggressive_mask = window['close'] <= window['boillenger_lower_agg']
             if aggressive_mask.any():
                 first_breach_index = aggressive_mask.idxmax()
                 candle_high = pd_candles.at[first_breach_index, 'high'] 
                 candle_low = pd_candles.at[first_breach_index, 'low']
-                candle_height = candle_high - candle_low
+                candle_height = candle_high - candle_low  # type: ignore
 
         return {
             'aggressive_move': aggressive_mask.any(),
@@ -423,10 +487,13 @@ def compute_candles_stats(
             mitigated = pd_candles.iloc[idx + 1:row.name]['close'].lt(row['fvg_high']).any()
         return mitigated
 
-    pd_candles['fvg_mitigated'] = pd_candles.apply(lambda row: compute_fvg_mitigated(row, pd_candles), axis=1)
+    pd_candles['fvg_mitigated'] = pd_candles.apply(lambda row: compute_fvg_mitigated(row, pd_candles), axis=1) # type: ignore
 
-
-    # RSI - https://www.youtube.com/watch?v=G9oUTi-PI18&t=809s 
+    '''
+        RSI
+        Divergences from Bybit Learn https://www.youtube.com/watch?v=G9oUTi-PI18&t=809s 
+        RSI Reversals from BK Traders https://www.youtube.com/watch?v=MvkbrHjiQlI
+    '''
     pd_candles.loc[:,'close_delta'] = pd_candles['close'].diff()
     pd_candles.loc[:,'close_delta_percent'] = pd_candles['close'].pct_change()
     lo_up = pd_candles['close_delta'].clip(lower=0)
@@ -452,6 +519,7 @@ def compute_candles_stats(
         
     lo_rs = lo_ma_up / lo_ma_down
     pd_candles.loc[:,'rsi'] = 100 - (100/(1 + lo_rs))
+    pd_candles['rsi_bucket'] = pd_candles['rsi'].apply(lambda x: bucketize_val(x, buckets=BUCKETS_m0_100))
     pd_candles['ema_rsi'] = pd_candles['rsi'].ewm(
         span=rsi_sliding_window_how_many_candles, 
         adjust=False).mean()
@@ -513,13 +581,43 @@ def compute_candles_stats(
         rsi_sliding_window_how_many_candles if rsi_sliding_window_how_many_candles else sliding_window_how_many_candles).sum()
     pd_candles['money_flow_ratio'] = pd_candles['positive_flow_sum'] / pd_candles['negative_flow_sum']
     pd_candles['mfi'] = 100 - (100 / (1 + pd_candles['money_flow_ratio']))
+    pd_candles['mfi_bucket'] = pd_candles['mfi'].apply(lambda x: bucketize_val(x, buckets=BUCKETS_m0_100))
     
 
     # MACD https://www.investopedia.com/terms/m/macd.asp
     # https://www.youtube.com/watch?v=jmPCL3l08ss
     pd_candles['macd'] = pd_candles['ema_short_periods'] - pd_candles['ema_long_periods']
     pd_candles['signal'] = pd_candles['macd'].ewm(span=int(sliding_window_how_many_candles/slow_fast_interval_ratio), adjust=False).mean()
-    pd_candles['macd_minus_signal'] = pd_candles['macd'] - pd_candles['signal']
+    pd_candles['macd_minus_signal'] = pd_candles['macd'] - pd_candles['signal'] # MACD histogram
+    macd_cur = pd_candles['macd_minus_signal']
+    macd_prev = pd_candles['macd_minus_signal'].shift(1)
+    bullish_macd_crosses = (macd_prev < 0) & (macd_cur > 0)
+    bearish_macd_crosses = (macd_prev > 0) & (macd_cur < 0)
+    pd_candles.loc[bullish_macd_crosses, 'macd_cross'] = 1
+    pd_candles.loc[bearish_macd_crosses, 'macd_cross'] = -1
+    bullish_indices = pd.Series(pd_candles.index.where(pd_candles['macd_cross'] == 1), index=pd_candles.index).astype('Int64')
+    bearish_indices = pd.Series(pd_candles.index.where(pd_candles['macd_cross'] == -1), index=pd_candles.index).astype('Int64')
+    pd_candles['macd_bullish_cross_last_id'] = bullish_indices.rolling(window=pd_candles.shape[0], min_periods=1).max().astype('Int64')
+    pd_candles['macd_bearish_cross_last_id'] = bearish_indices.rolling(window=pd_candles.shape[0], min_periods=1).max().astype('Int64')
+    conditions = [
+        (pd_candles['macd_bullish_cross_last_id'].notna() & 
+        pd_candles['macd_bearish_cross_last_id'].notna() &
+        (pd_candles['macd_bullish_cross_last_id'] > pd_candles['macd_bearish_cross_last_id'])),
+        
+        (pd_candles['macd_bullish_cross_last_id'].notna() & 
+        pd_candles['macd_bearish_cross_last_id'].notna() &
+        (pd_candles['macd_bearish_cross_last_id'] > pd_candles['macd_bullish_cross_last_id'])),
+        
+        (pd_candles['macd_bullish_cross_last_id'].notna() & 
+        pd_candles['macd_bearish_cross_last_id'].isna()),
+        
+        (pd_candles['macd_bearish_cross_last_id'].notna() & 
+        pd_candles['macd_bullish_cross_last_id'].isna())
+    ]
+    choices = ['bullish', 'bearish', 'bullish', 'bearish']
+    pd_candles['macd_cross_last'] = np.select(conditions, choices, default=None) # type: ignore
+    pd_candles.loc[bullish_macd_crosses, 'macd_cross'] = 'bullish'
+    pd_candles.loc[bearish_macd_crosses, 'macd_cross'] = 'bearish'
 
     if not pypy_compat:
         calculate_slope(
@@ -568,7 +666,7 @@ def compute_candles_stats(
             pd_data=pd_candles,
             src_col_name='ema_rsi',
             slope_col_name='ema_rsi_slope',
-            sliding_window_how_many_candles=int(sliding_window_how_many_candles)
+            sliding_window_how_many_candles=int(rsi_trend_sliding_window_how_many_candles)
         )
 
         pd_candles['regular_divergence'] = (
@@ -591,6 +689,8 @@ def compute_candles_stats(
 
     # Inflection points
     pd_candles['gap_close_vs_ema'] = pd_candles['close'] - pd_candles['ema_long_periods']
+    pd_candles['gap_close_vs_ema_percent'] = pd_candles['gap_close_vs_ema']/pd_candles['close'] *100
+
     pd_candles['close_above_or_below_ema'] = None
     pd_candles.loc[pd_candles['gap_close_vs_ema'] > 0, 'close_above_or_below_ema'] = 'above'
     pd_candles.loc[pd_candles['gap_close_vs_ema'] < 0, 'close_above_or_below_ema'] = 'below'
@@ -600,6 +700,68 @@ def compute_candles_stats(
         'close_vs_ema_inflection'
     ] = np.sign(pd_candles['close'] - pd_candles['ema_long_periods'])
 
+def lookup_fib_target(
+            row,
+            pd_candles,
+            target_fib_level : float = 0.618
+        ) -> Union[Dict, None]:
+            if row is None:
+                return None
+            
+            fib_target_short_periods = None
+            fib_target_long_periods = None
+
+            max_short_periods = row['max_short_periods']
+            idmax_short_periods = int(row['idmax_short_periods']) if not math.isnan(row['idmax_short_periods']) else None
+            max_long_periods = row['max_long_periods']
+            idmax_long_periods = int(row['idmax_long_periods']) if not math.isnan(row['idmax_long_periods']) else None
+
+            min_short_periods = row['min_short_periods']
+            idmin_short_periods = int(row['idmin_short_periods']) if not math.isnan(row['idmin_short_periods']) else None
+            min_long_periods = row['min_long_periods']
+            idmin_long_periods = int(row['idmin_long_periods']) if not math.isnan(row['idmin_long_periods']) else None
+                        
+            if idmax_short_periods and idmin_short_periods and idmax_short_periods>0 and idmin_short_periods>0:
+                if idmax_short_periods>idmin_short_periods and idmax_short_periods < len(pd_candles):
+                    # Falling from prev peak
+                    last_peak = pd_candles.iloc[idmax_short_periods]
+                    fib_target_short_periods = last_peak[f'fib_{target_fib_level}_short_periods'] if not math.isnan(last_peak[f'fib_{target_fib_level}_short_periods']) else None
+                    
+                else:
+                    # Bouncing from prev bottom
+                    if idmin_short_periods < len(pd_candles):
+                        last_bottom = pd_candles.iloc[idmin_short_periods]
+                        fib_target_short_periods = last_bottom[f'fib_{target_fib_level}_short_periods'] if not math.isnan(last_bottom[f'fib_{target_fib_level}_short_periods']) else None
+                        
+            if idmax_long_periods and idmin_long_periods and idmax_long_periods>0 and idmin_long_periods>0:
+                if idmax_long_periods>idmin_long_periods and idmax_long_periods < len(pd_candles):
+                    # Falling from prev peak
+                    last_peak = pd_candles.iloc[idmax_long_periods]
+                    fib_target_long_periods = last_peak[f'fib_{target_fib_level}_long_periods'] if not math.isnan(last_peak[f'fib_{target_fib_level}_long_periods']) else None
+                    
+                else:
+                    # Bouncing from prev bottom
+                    if idmin_long_periods < len(pd_candles):
+                        last_bottom = pd_candles.iloc[idmin_long_periods]
+                        fib_target_long_periods = last_bottom[f'fib_{target_fib_level}_long_periods'] if not math.isnan(last_bottom[f'fib_{target_fib_level}_long_periods']) else None
+            
+            return {
+                'short_periods' : {
+                    'idmin' : idmin_short_periods,
+                    'idmax' : idmax_short_periods,
+                    'min' : min_short_periods,
+                    'max' : max_short_periods,
+                    'fib_target' : fib_target_short_periods,
+                },
+                'long_periods' : {
+                    'idmin' : idmin_long_periods,
+                    'idmax' : idmax_long_periods,
+                    'min' : min_long_periods,
+                    'max' : max_long_periods,
+                    'fib_target' : fib_target_long_periods
+                }
+            }
+
 ''' 
 The implementation from Geeksforgeeks https://www.geeksforgeeks.org/find-indices-of-all-local-maxima-and-local-minima-in-an-array/ is wrong. 
 If you have consecutive-duplicates, things will gall apart!