siglab-py 0.1.19__py3-none-any.whl → 0.6.33__py3-none-any.whl

siglab_py/util/analytic_util.py

@@ -1,6 +1,7 @@
 import tzlocal
 from datetime import datetime, timezone
 from typing import List, Dict, Union, NoReturn, Any, Tuple
+from enum import Enum
 from pathlib import Path
 import math
 import pandas as pd
@@ -10,7 +11,47 @@ from hurst import compute_Hc # compatible with pypy
 from ccxt.base.exchange import Exchange as CcxtExchange
 from ccxt import deribit
 
-from util.market_data_util import fix_column_types
+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]
@@ -32,17 +73,64 @@ def estimate_fib_retracement(
             
         return retracement_price
 
+def calculate_slope(
+    pd_data : pd.DataFrame,
+    src_col_name : str,
+    slope_col_name : str,
+    sliding_window_how_many_candles : int
+):
+    import statsmodels.api as sm # in-compatible with pypy
+
+    X = sm.add_constant(range(len(pd_data[src_col_name])))
+    rolling_slope = pd_data[src_col_name].rolling(window=sliding_window_how_many_candles).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
+    pd_data[slope_col_name] = rolling_slope
+    max_abs_slope = pd_data[slope_col_name].abs().rolling(window=sliding_window_how_many_candles).max()
+    pd_data[f"normalized_{slope_col_name}"] = pd_data[slope_col_name] / max_abs_slope
+    normalized_slope_rolling = pd_data[f"normalized_{slope_col_name}"].rolling(window=sliding_window_how_many_candles)
+    pd_data[f"normalized_{slope_col_name}_min"] = normalized_slope_rolling.min()
+    pd_data[f"normalized_{slope_col_name}_max"] = normalized_slope_rolling.max()
+    pd_data[f"normalized_{slope_col_name}_idmin"] = normalized_slope_rolling.apply(lambda x : x.idxmin())
+    pd_data[f"normalized_{slope_col_name}_idmax"] = normalized_slope_rolling.apply(lambda x : x.idxmax())
+
+def trend_from_highs(series: np.ndarray) -> float:
+    valid_series = series[~np.isnan(series)]
+    unique_maxima = valid_series[np.concatenate(([True], np.diff(valid_series) != 0))]
+    if len(unique_maxima) < 2:
+        return TrendDirection.UNDEFINED.value
+    first, last = unique_maxima[0], unique_maxima[-1]
+    if first > last:
+        return TrendDirection.LOWER_HIGHS.value
+    elif first < last:
+        return TrendDirection.HIGHER_HIGHS.value
+    else:
+        return TrendDirection.SIDEWAYS.value
+
+def trend_from_lows(series: np.ndarray) -> float:
+    valid_series = series[~np.isnan(series)]
+    unique_minima = valid_series[np.concatenate(([True], np.diff(valid_series) != 0))]
+    if len(unique_minima) < 2:
+        return TrendDirection.UNDEFINED.value
+    first, last = unique_minima[0], unique_minima[-1]
+    if first > last:
+        return TrendDirection.LOWER_LOWS.value
+    elif first < last:
+        return TrendDirection.HIGHER_LOWS.value
+    else:
+        return TrendDirection.SIDEWAYS.value
+    
+    
 '''
 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
@@ -64,12 +152,21 @@ def compute_candles_stats(
         rsi_ema : bool = True,
         boillenger_ema : bool = False,
         slow_fast_interval_ratio : float = 3,
-        rsi_sliding_window_how_many_candles : Union[int, None] = None, # RSI standard 14
+        rsi_sliding_window_how_many_candles : int = 14, # RSI standard 14
+        rsi_trend_sliding_window_how_many_candles : int = 24*7, # This is for purpose of RSI trend identification (Locating local peaks/troughs in RSI). This should typically be multiples of 'rsi_sliding_window_how_many_candles'.
         hurst_exp_window_how_many_candles : Union[int, None] = None, # Hurst exp standard 100-200
         boillenger_std_multiples_for_aggressive_moves_detect : int = 3, # Aggressive moves if candle low/high breaches boillenger bands from 3 standard deviations.
+        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()]
@@ -86,27 +183,145 @@ 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'] = pd_candles['close'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).mean()
-    pd_candles['sma_long_periods'] = pd_candles['close'].rolling(window=sliding_window_how_many_candles).mean()
-    pd_candles['ema_short_periods'] = pd_candles['close'].ewm(span=int(sliding_window_how_many_candles/slow_fast_interval_ratio), adjust=False).mean()
-    pd_candles['ema_long_periods'] = pd_candles['close'].ewm(span=sliding_window_how_many_candles, adjust=False).mean()
+    pd_candles['sma_short_periods'] = close_short_periods_rolling.mean()
+    pd_candles['sma_long_periods'] = close_long_periods_rolling.mean()
+    pd_candles['ema_short_periods'] = close_short_periods_ewm.mean()
+    pd_candles['ema_long_periods'] = close_long_periods_ewm.mean()
     pd_candles['ema_close'] = pd_candles['ema_long_periods'] # Alias, shorter name
-    pd_candles['std'] = pd_candles['close'].rolling(window=sliding_window_how_many_candles).std()
+    pd_candles['std'] = close_long_periods_rolling.std()
+    pd_candles['std_percent'] = pd_candles['std'] / pd_candles['ema_close'] * 100
+
+    pd_candles['vwap_short_periods'] = (pd_candles['close'] * pd_candles['volume']).rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).sum() / pd_candles['volume'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).sum()
+    pd_candles['vwap_long_periods'] = (pd_candles['close'] * pd_candles['volume']).rolling(window=sliding_window_how_many_candles).sum() / pd_candles['volume'].rolling(window=sliding_window_how_many_candles).sum()
+
+    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':
+            annualization_factor = np.sqrt(365 * 24 * 60)  # 1-minute candles
+        elif candle_interval == '1h':
+            annualization_factor = np.sqrt(365 * 24)       # 1-hour candles
+        elif candle_interval == '1d':
+            annualization_factor = np.sqrt(365)            # 1-day candles
+        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()
+    
+    time_gap_sec = int(pd_candles['timestamp_ms'].iloc[1] - pd_candles['timestamp_ms'].iloc[0])/1000
+    seconds_in_year = 365 * 24 * 60 * 60
+    candles_per_year = seconds_in_year / time_gap_sec
+    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
+    )
 
     pd_candles['ema_volume_short_periods'] = pd_candles['volume'].ewm(span=sliding_window_how_many_candles/slow_fast_interval_ratio, adjust=False).mean()
     pd_candles['ema_volume_long_periods'] = pd_candles['volume'].ewm(span=sliding_window_how_many_candles, adjust=False).mean()
 
-    pd_candles['max_short_periods'] = pd_candles['close'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).max()
-    pd_candles['max_long_periods'] = pd_candles['close'].rolling(window=sliding_window_how_many_candles).max()
-    pd_candles['idmax_short_periods'] = pd_candles['close'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).apply(lambda x : x.idxmax())
-    pd_candles['idmax_long_periods'] = pd_candles['close'].rolling(window=sliding_window_how_many_candles).apply(lambda x : x.idxmax())
+    pd_candles['ema_cross'] = None
+    pd_candles['ema_cross_last'] = None
+    pd_candles['ema_bullish_cross_last_id'] = None
+    pd_candles['ema_bearish_cross_last_id'] = None
+    ema_short_periods_prev = pd_candles['ema_short_periods'].shift(1)
+    ema_long_periods_prev = pd_candles['ema_long_periods'].shift(1)
+    ema_short_periods_curr = pd_candles['ema_short_periods']
+    ema_long_periods_curr = pd_candles['ema_long_periods']
+    bullish_ema_crosses = (ema_short_periods_prev <= ema_long_periods_prev) & (ema_short_periods_curr > ema_long_periods_curr)
+    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
+    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()
+    pd_candles['idmax_short_periods'] = close_short_periods_rolling.apply(lambda x : x.idxmax())
+    pd_candles['idmax_long_periods'] = close_long_periods_rolling.apply(lambda x : x.idxmax())
+
+    pd_candles['min_short_periods'] = close_short_periods_rolling.min()
+    pd_candles['min_long_periods'] = close_long_periods_rolling.min()
+    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
+        pd_candles['min_short_periods'] - pd_candles['max_short_periods']   # Down swing (negative)
+    )
 
-    pd_candles['min_short_periods'] = pd_candles['close'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).min()
-    pd_candles['min_long_periods'] = pd_candles['close'].rolling(window=sliding_window_how_many_candles).min()
-    pd_candles['idmin_short_periods'] = pd_candles['close'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).apply(lambda x : x.idxmin())
-    pd_candles['idmin_long_periods'] = pd_candles['close'].rolling(window=sliding_window_how_many_candles).apply(lambda x : x.idxmin())
+    pd_candles['price_swing_long_periods'] = np.where(
+        pd_candles['idmax_long_periods'] > pd_candles['idmin_long_periods'],
+        pd_candles['max_long_periods'] - pd_candles['min_long_periods'],  # Up swing
+        pd_candles['min_long_periods'] - pd_candles['max_long_periods']   # Down swing (negative)
+    )
 
+    pd_candles['trend_from_highs_long_periods'] = np.where(
+												pd.isna(pd_candles['max_long_periods']),
+                                                None, # type: ignore
+												pd_candles['max_long_periods'].rolling(window=sliding_window_how_many_candles).apply(trend_from_highs, raw=True)
+												)
+    pd_candles['trend_from_lows_long_periods'] = np.where(
+												pd.isna(pd_candles['min_long_periods']),
+                                                None, # type: ignore
+												pd_candles['min_long_periods'].rolling(window=sliding_window_how_many_candles).apply(trend_from_lows, raw=True)
+												)
+    pd_candles['trend_from_highs_short_periods'] = np.where(
+												pd.isna(pd_candles['max_short_periods']),
+                                                None, # type: ignore
+												pd_candles['max_short_periods'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).apply(trend_from_highs, raw=True)
+												)
+    pd_candles['trend_from_lows_short_periods'] = np.where(
+												pd.isna(pd_candles['min_short_periods']),
+                                                None, # type: ignore
+												pd_candles['min_short_periods'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).apply(trend_from_lows, raw=True)
+												)
 
     # ATR https://medium.com/codex/detecting-ranging-and-trending-markets-with-choppiness-index-in-python-1942e6450b58 
     pd_candles.loc[:,'h_l'] = pd_candles['high'] - pd_candles['low']
@@ -114,7 +329,9 @@ def compute_candles_stats(
     pd_candles.loc[:,'l_pc'] = abs(pd_candles['low'] - pd_candles['close'].shift(1))
     pd_candles.loc[:,'tr'] = pd_candles[['h_l', 'h_pc', 'l_pc']].max(axis=1)
     pd_candles.loc[:,'atr'] = pd_candles['tr'].rolling(window=sliding_window_how_many_candles).mean()
-
+    pd_candles.loc[:,'atr_avg_short_periods'] = pd_candles['atr'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).mean()
+    pd_candles.loc[:,'atr_avg_long_periods'] = pd_candles['atr'].rolling(window=sliding_window_how_many_candles).mean()
+    
 
     '''
     @hardcode @todo
@@ -125,10 +342,10 @@ def compute_candles_stats(
     Sometimes you may encounter "Exception has occurred: FloatingPointError invalid value encountered in scalar divide"
     And for example adjusting window size from 120 to 125 will resolve the issue.
     '''
+    if not hurst_exp_window_how_many_candles:
+        hurst_exp_window_how_many_candles = (sliding_window_how_many_candles if sliding_window_how_many_candles>=125 else 125)
     pd_candles['hurst_exp'] = pd_candles['close'].rolling(
-        window=(
-            hurst_exp_window_how_many_candles if hurst_exp_window_how_many_candles else (sliding_window_how_many_candles if sliding_window_how_many_candles>=125 else 125)
-            )
+        window=hurst_exp_window_how_many_candles
         ).apply(lambda x: compute_Hc(x, kind='price', simplified=True)[0])
 
 
@@ -158,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(),
@@ -270,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)
@@ -284,9 +504,9 @@ def compute_candles_stats(
     if rsi_ema == True:
         # Use exponential moving average
         lo_ma_up = lo_up.ewm(
-            com = (rsi_sliding_window_how_many_candles if rsi_sliding_window_how_many_candles else sliding_window_how_many_candles) - 1, 
+            com = rsi_sliding_window_how_many_candles -1, 
             adjust=True, 
-            min_periods = rsi_sliding_window_how_many_candles if rsi_sliding_window_how_many_candles else sliding_window_how_many_candles).mean()
+            min_periods = rsi_sliding_window_how_many_candles).mean()
         lo_ma_down = lo_down.ewm(
             com = (rsi_sliding_window_how_many_candles if rsi_sliding_window_how_many_candles else sliding_window_how_many_candles) - 1, 
             adjust=True, 
@@ -294,15 +514,57 @@ def compute_candles_stats(
 
     else:
         # Use simple moving average
-        lo_ma_up = lo_up.rolling(window = rsi_sliding_window_how_many_candles if rsi_sliding_window_how_many_candles else sliding_window_how_many_candles).mean()
-        lo_ma_down = lo_down.rolling(window = rsi_sliding_window_how_many_candles if rsi_sliding_window_how_many_candles else sliding_window_how_many_candles).mean()
+        lo_ma_up = lo_up.rolling(window = rsi_sliding_window_how_many_candles).mean()
+        lo_ma_down = lo_down.rolling(window = rsi_sliding_window_how_many_candles).mean()
         
     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 if rsi_sliding_window_how_many_candles else sliding_window_how_many_candles, 
+        span=rsi_sliding_window_how_many_candles, 
         adjust=False).mean()
 
+    rsi_rolling = pd_candles['rsi'].rolling(window=int(rsi_trend_sliding_window_how_many_candles))
+    pd_candles['rsi_max'] = rsi_rolling.max()
+    pd_candles['rsi_idmax'] = rsi_rolling.apply(lambda x : x.idxmax())
+    pd_candles['rsi_min'] = rsi_rolling.min()
+    pd_candles['rsi_idmin'] = rsi_rolling.apply(lambda x : x.idxmin())
+
+    def rsi_trend(
+            row,
+            rsi_upper_threshold : float = 70,
+            rsi_lower_threshold : float = 30):
+        if pd.isna(row['rsi_idmax']) or pd.isna(row['rsi_idmin']):
+            return np.nan
+        if row['rsi_idmax'] > row['rsi_idmin']:
+            return 'down' if row.name > row['rsi_idmax'] and row['rsi'] <= rsi_upper_threshold else 'up'
+        else:
+            return 'up' if row.name > row['rsi_idmin'] and row['rsi'] >= rsi_lower_threshold else 'down'
+
+    pd_candles['rsi_trend'] = pd_candles.apply(lambda row: rsi_trend(row), axis=1)
+
+    pd_candles['rsi_trend_from_highs'] = np.where(
+												pd.isna(pd_candles['rsi_max']),
+                                                None, # type: ignore
+												pd_candles['rsi_max'].rolling(window=rsi_trend_sliding_window_how_many_candles).apply(trend_from_highs, raw=True)
+												)
+    pd_candles['rsi_trend_from_lows'] = np.where(
+												pd.isna(pd_candles['rsi_min']),
+                                                None, # type: ignore
+												pd_candles['rsi_min'].rolling(window=rsi_trend_sliding_window_how_many_candles).apply(trend_from_lows, raw=True)
+												)
+
+    def _rsi_divergence(row):
+        trend_from_highs_long_periods = TrendDirection(row['trend_from_highs_long_periods']) if row['trend_from_highs_long_periods'] is not None and not pd.isna(row['trend_from_highs_long_periods']) else None  # type: ignore
+        rsi_trend_from_highs = TrendDirection(row['rsi_trend_from_highs']) if row['rsi_trend_from_highs'] is not None and not pd.isna(row['rsi_trend_from_highs']) else None # type: ignore
+        
+        if trend_from_highs_long_periods and rsi_trend_from_highs and trend_from_highs_long_periods == TrendDirection.LOWER_HIGHS and rsi_trend_from_highs == TrendDirection.HIGHER_HIGHS:
+            return 'bullish_divergence'
+        elif trend_from_highs_long_periods and rsi_trend_from_highs and trend_from_highs_long_periods == TrendDirection.HIGHER_HIGHS and rsi_trend_from_highs == TrendDirection.LOWER_HIGHS:
+            return 'bearish_divergence'
+        return 'no_divergence'
+    pd_candles['rsi_divergence'] = pd_candles.apply(_rsi_divergence, axis=1)
+    
 
     # MFI (Money Flow Index) https://randerson112358.medium.com/algorithmic-trading-strategy-using-money-flow-index-mfi-python-aa46461a5ea5 
     pd_candles['typical_price'] = (pd_candles['high'] + pd_candles['low'] + pd_candles['close']) / 3
@@ -319,59 +581,116 @@ 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=9, adjust=False).mean()
-    pd_candles['macd_minus_signal'] = pd_candles['macd'] - pd_candles['signal']
+    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'] # 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:
-        import statsmodels.api as sm # in-compatible with pypy
-
-        # Slopes
-        X = sm.add_constant(range(len(pd_candles['close'])))
-        rolling_slope = pd_candles['close'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
-        pd_candles['close_short_slope'] = rolling_slope
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='close',
+            slope_col_name='close_short_slope',
+            sliding_window_how_many_candles=int(sliding_window_how_many_candles/slow_fast_interval_ratio)
+        )
 
-        X = sm.add_constant(range(len(pd_candles['close'])))
-        rolling_slope = pd_candles['close'].rolling(window=sliding_window_how_many_candles).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
-        pd_candles['close_long_slope'] = rolling_slope
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='close',
+            slope_col_name='close_long_slope',
+            sliding_window_how_many_candles=int(sliding_window_how_many_candles)
+        )
         
-        X = sm.add_constant(range(len(pd_candles['ema_short_periods'])))
-        rolling_slope = pd_candles['ema_short_periods'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
-        pd_candles['ema_short_slope'] = rolling_slope
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='ema_short_periods',
+            slope_col_name='ema_short_slope',
+            sliding_window_how_many_candles=int(sliding_window_how_many_candles/slow_fast_interval_ratio)
+        )
 
-        X = sm.add_constant(range(len(pd_candles['ema_long_periods'])))
-        rolling_slope = pd_candles['ema_long_periods'].rolling(window=sliding_window_how_many_candles).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
-        pd_candles['ema_long_slope'] = rolling_slope
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='ema_long_periods',
+            slope_col_name='ema_long_slope',
+            sliding_window_how_many_candles=int(sliding_window_how_many_candles)
+        )
 
-        X = sm.add_constant(range(len(pd_candles['boillenger_upper'])))
-        rolling_slope = pd_candles['boillenger_upper'].rolling(window=int(sliding_window_how_many_candles/slow_fast_interval_ratio)).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
-        pd_candles['boillenger_upper_slope'] = rolling_slope
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='boillenger_upper',
+            slope_col_name='boillenger_upper_slope',
+            sliding_window_how_many_candles=int(sliding_window_how_many_candles)
+        )
 
-        X = sm.add_constant(range(len(pd_candles['boillenger_lower'])))
-        rolling_slope = pd_candles['boillenger_lower'].rolling(window=sliding_window_how_many_candles).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
-        pd_candles['boillenger_lower_slope'] = rolling_slope
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='boillenger_lower',
+            slope_col_name='boillenger_lower_slope',
+            sliding_window_how_many_candles=int(sliding_window_how_many_candles)
+        )
 
-        X = sm.add_constant(range(len(pd_candles['ema_rsi'])))
-        rolling_slope = pd_candles['ema_rsi'].rolling(window=sliding_window_how_many_candles).apply(lambda x: sm.OLS(x, X[:len(x)]).fit().params[1], raw=False)
-        pd_candles['ema_rsi_slope'] = rolling_slope
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='ema_rsi',
+            slope_col_name='ema_rsi_slope',
+            sliding_window_how_many_candles=int(rsi_trend_sliding_window_how_many_candles)
+        )
 
         pd_candles['regular_divergence'] = (
             (pd_candles['ema_long_slope'] > 0) & (pd_candles['ema_rsi_slope'] < 0) |
             (pd_candles['ema_long_slope'] < 0) & (pd_candles['ema_rsi_slope'] > 0)
         )
+
+        calculate_slope(
+            pd_data=pd_candles,
+            src_col_name='hurst_exp',
+            slope_col_name='hurst_exp_slope',
+            sliding_window_how_many_candles=hurst_exp_window_how_many_candles
+        )
         
 
     # Fibonacci
-    TARGET_FIB_LEVEL = 0.618
-    pd_candles['fib_618_short_periods'] = pd_candles.apply(lambda rw : estimate_fib_retracement(rw['min_short_periods'], rw['idmin_short_periods'], rw['max_short_periods'], rw['idmax_short_periods'], TARGET_FIB_LEVEL), axis=1)
-    pd_candles['fib_618_long_periods'] = pd_candles.apply(lambda rw : estimate_fib_retracement(rw['min_long_periods'], rw['idmin_long_periods'], rw['max_long_periods'], rw['idmax_long_periods'], TARGET_FIB_LEVEL), axis=1)
+    pd_candles[f'fib_{target_fib_level}_short_periods'] = pd_candles.apply(lambda rw : estimate_fib_retracement(rw['min_short_periods'], rw['idmin_short_periods'], rw['max_short_periods'], rw['idmax_short_periods'], target_fib_level), axis=1)
+    pd_candles[f'fib_{target_fib_level}_long_periods'] = pd_candles.apply(lambda rw : estimate_fib_retracement(rw['min_long_periods'], rw['idmin_long_periods'], rw['max_long_periods'], rw['idmax_long_periods'], target_fib_level), axis=1)
 
 
     # 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'
@@ -381,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!
@@ -790,3 +1171,40 @@ def partition_sliding_window(
         'maxima' : maxima,
         'segments' : consolidated_segements
     }
+
+# This relies on statsmodels.api, which is not pypy compatible
+def compute_pair_stats(
+    pd_candles : pd.DataFrame,
+    how_many_candles : int = 24*7
+) -> None:
+    import statsmodels.api as sm
+
+    def _compute_hedge_ratio(
+                prices0 : List[float],
+                prices1 : List[float]
+        ):
+        model = sm.OLS(prices0, prices1).fit()
+        hedge_ratio = model.params[0]
+        return hedge_ratio
+    
+    pd_candles['hedge_ratio'] = np.nan
+    for j in range(how_many_candles, pd_candles.shape[0]):
+        window = pd_candles.iloc[j-how_many_candles:j]
+        hedge_ratio = _compute_hedge_ratio(window['close_1'].values, window['close_2'].values) # type: ignore
+        pd_candles.loc[j, 'hedge_ratio'] = hedge_ratio
+
+    pd_candles['close_spread'] = pd_candles['close_1'] - (pd_candles['close_2'] * pd_candles['hedge_ratio']) # You're fitting one hedge_ratio over a windows
+    mean = pd_candles['close_spread'].rolling(how_many_candles).mean()
+    std = pd_candles['close_spread'].rolling(how_many_candles).std()
+    pd_candles['close_spread_mean'] = mean
+    pd_candles['close_spread_std'] = std
+    pd_candles['zscore_close_spread'] = (pd_candles['close_spread'] - mean)/std
+    pd_candles['zscore_close_spread_min'] = pd_candles['zscore_close_spread'].rolling(how_many_candles).min()
+    pd_candles['zscore_close_spread_max'] = pd_candles['zscore_close_spread'].rolling(how_many_candles).max()
+
+    calculate_slope(
+        pd_data=pd_candles,
+        src_col_name='zscore_close_spread',
+        slope_col_name='zscore_slope',
+        sliding_window_how_many_candles=how_many_candles
+    )